public async Task StartScanning()
{
await WaitForState(CBCentralManagerState.PoweredOn);
_centralManager.ScanForPeripherals(peripheralUuids: null);
RaiseScanningStateChanged(true);
await Task.Delay(10 *1000);
_centralManager.StopScan();
RaiseScanningStateChanged(false);
}
public async void StartScanningForDevices(Guid serviceUuid)
{
//
// Wait for the PoweredOn state
//
await WaitForState(CBCentralManagerState.PoweredOn);
Debug.WriteLine("Adapter: Starting a scan for devices.");
CBUUID[] serviceUuids = null; // TODO: convert to list so multiple Uuids can be detected
if (serviceUuid != Guid.Empty)
{
var suuid = CBUUID.FromString(serviceUuid.ToString());
serviceUuids = new[] { suuid };
Debug.WriteLine("Adapter: Scanning for " + suuid);
}
// clear out the list
_discoveredDevices = new List <IDevice>();
// start scanning
_isScanning = true;
_central.ScanForPeripherals(serviceUuids);
// in 20 seconds, stop the scan
// await Task.Delay (20000, source.Token);
cancelScan = false;
for (var i = 0; i < 20; i++)
{
if (!cancelScan)
{
await Task.Delay(1000);
}
else
{
break;
}
}
// if we're still scanning
if (_isScanning)
{
Console.WriteLine("BluetoothLEManager: Scan timeout has elapsed.");
_isScanning = false;
_central.StopScan();
ScanTimeoutElapsed(this, new EventArgs());
}
}
public Task <bool> ScanDevicesAsync(Action <ScanResult> scanCallback, CancellationToken token)
{
if (!IsBluetoothLESupported || !IsBluetoothOn || _centralManager.IsScanning)
{
return(Task.FromResult(false));
}
_scanCallback = scanCallback;
_centralManager.ScanForPeripherals(null, new PeripheralScanningOptions {
AllowDuplicatesKey = true
});
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
token.Register(() =>
{
lock (_lock)
{
_centralManager.StopScan();
_scanCallback = null;
tcs.SetResult(true);
}
});
return(tcs.Task);
}
/// <summary>
/// Method subscribed to a CBMCentralManager's OnDiscoveredPeripheral Event
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">E.</param>
private void OnDiscoveredPeripheral(Object sender, CBDiscoveredPeripheralEventArgs e)
{
var peripheral = e.Peripheral;
// Get advertised data and convert to dict
var serviceDataDict = (NSDictionary)e.AdvertisementData[CBAdvertisement.DataServiceDataKey];
// Get keys becase keys are NSobjects and are weird to decipher, if no keys then null
var serviceDataKeys = serviceDataDict?.Keys;
// If the previous ID matches or the peripheral has the desired content...
if (TemperatureSensor.Instance.UUID == peripheral.Identifier.ToString() ||
(serviceDataKeys != null &&
serviceDataKeys.Length == 2 &&
serviceDataKeys[0].Description == Constants.HEALTH_THERMOMETER &&
serviceDataKeys[1].Description == Constants.BATTERY))
{
// Extract data
var temperature = serviceDataDict[serviceDataKeys[0]].Description;
temperature = Regex.Replace(temperature, "[<>]", "");
var battery = serviceDataDict[serviceDataKeys[1]].Description;
battery = Regex.Replace(battery, "[<>]", "");
// Stop the scan once found
_centralManager.StopScan();
_SetActivePeripheral(peripheral, temperature);
}
}
void UpdateScan()
{
if (_scanners.Count == 0)
{
_central.StopScan();
}
else
{
HashSet <ServiceUuid> services = null;
if (!_scanners.Any(scn => scn.Services == null))
{
// all scanners want only specific services, create a union over all
services = new HashSet <ServiceUuid>();
foreach (var scn in _scanners)
{
services.UnionWith(scn.Services);
}
}
_central.ScanForPeripherals(services?.Select(uuid => CBUUID.FromBytes(uuid.Uuid.ToByteArrayBE())).ToArray(), new PeripheralScanningOptions
{
AllowDuplicatesKey = true,
});
}
}
void UpdatedState(object sender, EventArgs e)
{
switch (manager.State)
{
case CBCentralManagerState.PoweredOn:
State = "Scanning...";
manager.ScanForPeripherals((CBUUID[])null);
break;
case CBCentralManagerState.PoweredOff:
case CBCentralManagerState.Resetting:
case CBCentralManagerState.Unauthorized:
case CBCentralManagerState.Unknown:
case CBCentralManagerState.Unsupported:
State = "Waiting for Bluetooth PowerOn...";
manager.StopScan();
break;
default:
State = "<unknown state>";
break;
}
OnSomethingHappened();
}
public void Stop()
{
Debug.WriteLine("BluetoothPacketProvider:Stop()");
centralDelegate.OnAdvertisementPacketReceived -= ScanCallback_OnAdvertisementPacketReceived;
central.StopScan();
WatcherStopped?.Invoke(sender: this, e: new BTError(BTError.BluetoothError.Success));
}
public async Task BeginScanningForDevices()
{
Console.WriteLine("Begin scanning");
mDiscoveredDevices.Clear();
isScanning = true;
//mCentralManager.ScanForPeripherals (peripheralUuids: null);
mCentralManager.ScanForPeripherals((CBUUID [])null);
//mCentralManager.ScanForPeripherals (new[] { UUID });
await Task.Delay(10000);
if (isScanning)
{
mCentralManager.StopScan();
ScanTimeoutElapsed(this, new EventArgs());
}
}
public void endEnumeration()
{
if (isScanning)
{
centralManager.StopScan();
isScanning = false;
}
}
public void StopScanning()
{
Debug.WriteLine("StopScanning");
if (_centralManager != null && _centralManager.IsScanning)
{
_centralManager.StopScan();
}
IsScanning = false;
}
public IEnumerable <BluetoothDevice> ScanForDevices()
{
_devices = new List <BluetoothDevice>();
_nativeDevices = new List <CBPeripheral>();
_manager?.ScanForPeripherals(CBUUID.FromString("00001101-0000-1000-8000-00805F9B34FB"));
_manager?.StopScan();
return(_devices);
}
internal static void StopScanning()
{
_scanCount--;
if (_scanCount == 0 && _manager.IsScanning)
{
_manager.StopScan();
}
}
public virtual void UpdatedState(CBCentralManager central)
{
if (central.State == CBCentralManagerState.PoweredOn)
{
centralManager.ScanForPeripherals(peripheralUuids: null, options: (NSDictionary)null);
}
else
{
centralManager.StopScan();
}
}
public async Task <bool> Search()
{
if (manager.State == CBCentralManagerState.PoweredOn)
{
manager.ScanForPeripherals(new CBUUID[0]);
await Task.Delay(15000);
manager.StopScan();
return(await Task.FromResult(false));
}
return(await Task.FromResult(true));
}
public static void Connect(CBPeripheral peripheral)
{
if (BleClient.peripheral != null)
{
return;
}
BleClient.peripheral = peripheral;
manager.StopScan();
manager.ConnectPeripheral(peripheral);
}
void ConnectedPeripheral(object sender, CBPeripheralEventArgs e)
{
Console.Error.WriteLine("Connected. Discovering services.");
central.ConnectedPeripheral -= ConnectedPeripheral;
central.StopScan();
connectedCbPeripheral = e.Peripheral;
connectedCbPeripheral.DiscoveredService += DiscoveredService;
connectedCbPeripheral.UpdatedCharacterteristicValue += UpdatedCharacterteristicValue;
connectedCbPeripheral.WroteCharacteristicValue += WroteCharacteristicValue;
connectedCbPeripheral.DiscoverServices();
}
public async Task <bool> ConnectAsync(RomeRemoteSystem system)
{
_tsc = new TaskCompletionSource <bool>();
_manager.StopScan();
myDel.Connected = (s) =>
{
_tsc.TrySetResult(true);
};
_manager.ConnectPeripheral((CBPeripheral)system.NativeObject);
return(await _tsc.Task);
}
/// <summary>
/// Begins the scanning for bluetooth LE devices. Automatically called after 10 seconds
/// to prevent battery drain.
/// </summary>
/// <returns>The scanning for devices.</returns>
public async void BeginScanningForDevices()
{
Console.WriteLine("BluetoothLEManager: Starting a scan for devices.");
// clear out the list
_discoveredDevices = new List <CBPeripheral> ();
// start scanning
IsScanning = true;
_central.ScanForPeripherals((CBUUID[])null);
// in 10 seconds, stop the scan
await Task.Delay(10000);
// if we're still scanning
if (IsScanning)
{
Console.WriteLine("BluetoothLEManager: Scan timeout has elapsed.");
_central.StopScan();
ScanTimeoutElapsed(this, new EventArgs());
}
}
public void Stop()
{
if (_centralManager == null)
{
// not started
return;
}
_centralManager.StopScan();
_logger.LogDebug("Scanning - stopped.");
Covi.Features.BluetoothTracing.TracingState.Instance.SetScanningState(false);
_enabled = false;
}
public override void UpdatedState(CBCentralManager manager)
{
if (manager.State == CBCentralManagerState.PoweredOn)
{
CBUUID[] cbuuids = null;
manager.ScanForPeripherals(cbuuids);
var timer = new Timer(30000);
timer.Elapsed += (sender, e) => manager.StopScan();
}
else
{
Console.WriteLine("Bluetooth is not available");
}
}
public async Task Stop()
{
_centralManager.StopScan();
foreach (var beaconRegion in _listOfCLBeaconRegion)
{
_locationMgr.StopRangingBeacons(beaconRegion);
_locationMgr.StopMonitoring(beaconRegion);
}
_listOfCLBeaconRegion.Clear();
_locationMgr.DidRangeBeacons -= HandleDidRangeBeacons;
_locationMgr.StopUpdatingLocation();
}
override public void UpdatedState(CBCentralManager mgr)
{
if (mgr.State == CBCentralManagerState.PoweredOn)
{
//Passing in null scans for all peripherals. Peripherals can be targeted by using CBUIIDs
CBUUID[] cbuuids = new[] { CBUUID.FromString("61353090-8231-49cc-b57a-886370740041") };
mgr.ScanForPeripherals(cbuuids); //Initiates async calls of DiscoveredPeripheral
//Timeout after 30 seconds
var timer = new Timer(30 * 1000);
timer.Elapsed += (sender, e) => mgr.StopScan();
}
else
{
//Invalid state -- Bluetooth powered down, unavailable, etc.
System.Diagnostics.Debug.WriteLine("Bluetooth is not available");
}
}
/// <summary>
/// Stop scanning for devices.
/// </summary>
public void StopScanningForDevices()
{
Debug.WriteLine("StopScanningForDevices");
if (IsScanning && _scanCancellationToken != null)
{
try
{
_scanCancellationToken.Cancel();
}
catch (TaskCanceledException e)
{
// ignored
}
}
IsScanning = false;
_centralManager.StopScan();
}
public void ScanForBroadcasters(CBCentralManager mgr, UIButton Scanner)
{
//Passing in null scans for all peripherals. Peripherals can be targeted by using CBUIIDs
mgr.ScanForPeripherals (cbuuids); //Initiates async calls of DiscoveredPeripheral
Scanner.SetTitle("Started scan Scan", UIControlState.Normal);
//Timeout after 30 seconds
var timer = new Timer (30 * 1000);
//mgr.StopScan ();
timer.Elapsed += (sender, e) => {
Console.WriteLine("Stopping scan");
mgr.StopScan ();
Console.WriteLine("Scan stopped");
Scanner.SetTitle("Stopped Scan", UIControlState.Normal);
};
}
protected override void StopScan()
{
SensusContext.Current.MainThreadSynchronizer.ExecuteThreadSafe(() =>
{
try
{
_bluetoothCentralManager?.StopScan();
}
catch (Exception ex)
{
SensusServiceHelper.Get().Logger.Log("Exception while stopping scanning: " + ex.Message, LoggingLevel.Normal, GetType());
}
finally
{
_bluetoothCentralManager = null;
}
});
}
override public void UpdatedState(CBCentralManager mgr)
{
if (mgr.State == CBCentralManagerState.PoweredOn)
{
Console.WriteLine("Bluetooth is available");
//Passing in null scans for all peripherals. Peripherals can be targeted by using CBUIIDs
CBUUID[] cbuuids = null;
mgr.ScanForPeripherals(cbuuids); //Initiates async calls of DiscoveredPeripheral
//Timeout after 30 seconds
var timer = new Timer(30 * 1000);
timer.Elapsed += (sender, e) => mgr.StopScan();
}
else
{
//Invalid state -- Bluetooth powered down, unavailable, etc.
System.Console.WriteLine("Bluetooth is not available");
}
}
public async Task ScanForDevices(CBCentralManager manager)
{
if (manager.State == CBCentralManagerState.PoweredOn)
{
//Passing in null scans for all peripherals. Peripherals can be targeted by using CBUIIDs
CBUUID[] cbuuids = null;
manager.ScanForPeripherals(cbuuids);
await Task.Delay((int)_scanTimeout.TotalMilliseconds);
manager.StopScan();
_isScanning = false;
_scanForDevicesTCS.SetResult(_discoveredDevices);
}
else
{
Console.WriteLine("Bluetooth is not available");
_scanForDevicesTCS.SetException(new Exception("Bluetooth is not available"));
}
}
protected override async Task ScanAsync(CancellationToken cancellationToken)
{
try
{
// start a fresh manager delegate to collect/read results
_bluetoothCentralManagerDelegate = new iOSBluetoothDeviceProximityProbeCentralManagerDelegate(_deviceIdService, _deviceIdCharacteristic, this);
// initialize manager, which starts scan.
_bluetoothCentralManager = new CBCentralManager(_bluetoothCentralManagerDelegate,
new DispatchQueue("ble"),
NSDictionary.FromObjectAndKey(NSNumber.FromBoolean(false), CBCentralManager.OptionShowPowerAlertKey)); // the base class handles prompting using to turn on bluetooth and stops the probe if the user does not.
TaskCompletionSource <bool> scanCompletionSource = new TaskCompletionSource <bool>();
cancellationToken.Register(() =>
{
try
{
_bluetoothCentralManager.StopScan();
}
catch (Exception ex)
{
SensusServiceHelper.Get().Logger.Log("Exception while stopping scan: " + ex.Message, LoggingLevel.Normal, GetType());
}
finally
{
_bluetoothCentralManager = null;
scanCompletionSource.TrySetResult(true);
}
});
await scanCompletionSource.Task;
}
catch (Exception ex)
{
SensusServiceHelper.Get().Logger.Log("Exception while scanning: " + ex.Message, LoggingLevel.Normal, GetType());
}
}
protected override void StopScanNative()
{
_centralManager.StopScan();
}
public void StopScan()
{
_CentralManager.StopScan();
}
public void StopS(String d)
{
Console.WriteLine("From " + d);
manager.StopScan();
Console.WriteLine("Scan is stopped!!!");
}
