private void StartScanningNew(Guid[] serviceUuids) { var hasFilter = serviceUuids?.Any() ?? false; List <ScanFilter> scanFilters = null; if (hasFilter) { scanFilters = new List <ScanFilter>(); foreach (var serviceUuid in serviceUuids) { var sfb = new ScanFilter.Builder(); sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString())); scanFilters.Add(sfb.Build()); } } var ssb = new ScanSettings.Builder(); ssb.SetScanMode(ScanMode.ToNative()); //ssb.SetCallbackType(ScanCallbackType.AllMatches); if (_bluetoothAdapter.BluetoothLeScanner != null) { Trace.Message($"Adapter >=21: Starting a scan for devices. ScanMode: {ScanMode}"); if (hasFilter) { Trace.Message($"ScanFilters: {string.Join(", ", serviceUuids)}"); } _bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback); } else { Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off"); } }
void InitializeScanner() { if (_adapter == null) { return; } // initialize scanner var sb = new ScanSettings.Builder() .SetCallbackType(ScanCallbackType.AllMatches) .SetScanMode(ScanMode.LowLatency); if (Build.VERSION.SdkInt >= BuildVersionCodes.M) { sb = sb.SetMatchMode(BluetoothScanMatchMode.Aggressive).SetNumOfMatches(1); } _scanSettings = sb.Build(); sb.SetReportDelay(1000); _scanSettingsBatch = sb.Build(); _scanner = _adapter.BluetoothLeScanner; _scanCallback = new ScanCallbackImpl(this); _scanCallbackBatch = new BatchScanCallbackImpl(); }
public ScanEventSource() { ScanResults = Observable.FromEvent<ScanResult>(h => OnDeviceDetected += h, h => OnDeviceDetected -= h); var appContext = Application.Context; var builder = new ScanSettings.Builder(); builder.SetReportDelay(0); builder.SetScanMode(ScanMode.LowLatency); var manager = (BluetoothManager)appContext.GetSystemService(Context.BluetoothService); var adapter = manager.Adapter; bluetoothLeScanner = adapter.BluetoothLeScanner; var simpleScanCallback = new SimpleScanCallback(result => { var payload = result.ScanRecord.GetBytes(); var majorId = payload[26]; if (payload[5] == 76 && majorId == Constants.MajorId) { var txPower = 255 - payload[29]; var minorId = (payload[27] << 8) + payload[28]; var deviceId = new DeviceIdentifier(new Guid(), majorId, minorId); var data = new ScanResult(deviceId, result.Rssi, txPower); OnDeviceDetected?.Invoke(data); } }); // taken from https://www.pubnub.com/blog/2015-04-15-build-android-beacon-ibeacon-detector/ , but not detecting our beacons //bluetoothLeScanner.StartScan(new List<ScanFilter> {CreateScanFilter()}, CreateScanSettings(), simpleScanCallback); bluetoothLeScanner.StartScan(simpleScanCallback); }
static async Task <IReadOnlyCollection <BluetoothDevice> > PlatformScanForDevices(RequestDeviceOptions options) { List <ScanFilter> filters = new List <ScanFilter>(); foreach (var f in options.Filters) { foreach (var u in f.Services) { ScanFilter.Builder b = new ScanFilter.Builder(); b.SetServiceUuid(ParcelUuid.FromString(u.Value.ToString())); filters.Add(b.Build()); } } ScanSettings.Builder sb = new ScanSettings.Builder(); sb.SetScanMode(Android.Bluetooth.LE.ScanMode.Balanced); var settings = sb.Build(); var callback = new DevicesCallback(); _manager.Adapter.BluetoothLeScanner.StartScan(callback); await Task.Delay(30000); return(callback.Devices.AsReadOnly()); }
private async Task <bool> NewScanAsync(Action <BrickController2.PlatformServices.BluetoothLE.ScanResult> scanCallback, CancellationToken token) { try { var leScanner = new BluetoothLENewScanner(scanCallback); var settingsBuilder = new ScanSettings.Builder() .SetCallbackType(ScanCallbackType.AllMatches) .SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency); _bluetoothAdapter.BluetoothLeScanner.StartScan(null, settingsBuilder.Build(), leScanner); var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously); using (token.Register(() => { _bluetoothAdapter.BluetoothLeScanner.StopScan(leScanner); tcs.TrySetResult(true); })) { return(await tcs.Task); } } catch (Exception) { return(false); } }
private async void RunAction() { var settings = new ScanSettings.Builder().SetScanMode(ScanMode.LowPower).Build(); var filters = GetScanFilters(); //var intent = new Intent(ApplicationContext, typeof(BackgroundService)); //intent.PutExtra("o-scan", true); //var pendingIntent = // PendingIntent.GetBroadcast(ApplicationContext, 0, intent, PendingIntentFlags.UpdateCurrent); //_bluetoothAdapter.BluetoothLeScanner.StartScan(filters, settings,new AppScanCallBack()); var advSettings = new AdvertiseSettings.Builder().SetAdvertiseMode(AdvertiseMode.LowPower) .SetConnectable(false).SetTimeout(1000).Build(); var advData = new AdvertiseData.Builder() .AddServiceUuid(ParcelUuid.FromString("FC51BA92-74D5-4972-B2D9-9ECBC62ACFC9")).Build(); _bluetoothAdapter.BluetoothLeAdvertiser.StartAdvertising(advSettings, advData, new AppAdvertisingCallBack()); //Log.Info(TAG, $"Service is still running, near devices: {devices.Count}"); //if (!devices.Any()) Log.Info(TAG, $"Device NOt MATCH"); //foreach (var device in devices) // Log.Info(TAG, // $"Service is still running, DEVICE: id({device.BondState}) adress({string.Join(",", device.Address)})) "); Toast.MakeText(this, $"Service is still running, near devices: NA", ToastLength.Long).Show(); handler.PostDelayed(runnable, 10000); }
private ScanSettings BuildScanSettings() { var builder = new ScanSettings.Builder(); builder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower); return(builder.Build()); }
protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); // Set our view from the "main" layout resource SetContentView(Resource.Layout.activity_main); // Start scanning for the beacon we want to write a value to var scanModeBuilder = new ScanSettings.Builder(); scanModeBuilder.SetScanMode(ScanMode.LowLatency); var deviceAddressFilterBuilder = new ScanFilter.Builder(); deviceAddressFilterBuilder.SetDeviceAddress(_MyDeviceAddress); _Manager = (BluetoothManager)GetSystemService("bluetooth"); _Adapter = _Manager.Adapter; _Scanner = _Adapter.BluetoothLeScanner; _ScanCallback = new BleScanCallback(this); _GattCallback = new BleGattCallback(this); _LogTextView = FindViewById <TextView>(Resource.Id.logTextView); _Scanner.StartScan( new List <ScanFilter> { deviceAddressFilterBuilder.Build() }, scanModeBuilder.Build(), _ScanCallback); _LogTextView.Text = "Started scanning...."; }
public void StartDiscoverDevices() { Thread DiscoverThread = new Thread(() => { try { ScanSettings settings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency).Build(); var item = new ScanFilter.Builder().SetServiceUuid(Android.OS.ParcelUuid.FromString("f000aa00-0451-4000-b000-000000000000")).Build(); var scanFilter = new List <ScanFilter>() { }; BluetoothManager.Adapter.BluetoothLeScanner.StartScan(scanFilter, settings, ScanCallback); } catch (System.Exception ex) { string title = this.GetType().Name + " - " + System.Reflection.MethodBase.GetCurrentMethod().Name; BalizaFacil.App.Instance.UnhandledException(title, ex); } }) { IsBackground = true, Priority = ThreadPriority.Highest, Name = nameof(DiscoverThread) }; DiscoverThread.Start(); }
public void Start() { ScanSettings.Builder scanSettingsBuilder = null; ScanSettings scanSettings = null; switch (this.DriverState) { case BluetoothDriverStates.NotPresent: return; case BluetoothDriverStates.Enabled: this.scannerCallback = new DroidLEScannerCallback(); this.bluetoothLeScanner = this.bluetoothAdapter.BluetoothLeScanner; if (this.scanfiltersList.Count == 0) { this.bluetoothLeScanner.StartScan(this.scannerCallback); } else { scanSettingsBuilder = new ScanSettings.Builder(); scanSettingsBuilder.SetMatchMode(BluetoothScanMatchMode.Aggressive); scanSettingsBuilder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency); scanSettings = scanSettingsBuilder.Build(); try { this.bluetoothLeScanner.StartScan(this.scanfiltersList, scanSettings, this.scannerCallback); } catch (Exception) { } } this.DriverState = BluetoothDriverStates.Discovering; break; } }
public IObservable <IScanResult> Scan() { return(Observable.Create <ScanResult>(ob => { _callback = new LollipopScanCallback((native, rssi, sr) => { var scanResult = ToScanResult(native, rssi, sr); ob.OnNext(scanResult); }); var builder = new ScanSettings.Builder(); builder.SetScanMode(ScanMode.Balanced); var scanFilters = new List <ScanFilter>(); _manager.Adapter.BluetoothLeScanner.StartScan( scanFilters, builder.Build(), _callback); return () => _manager.Adapter.BluetoothLeScanner?.StopScan(_callback); }) .Finally(() => { })); }
public void ScanLeDevice() { if (bluetoothAdapter == null) { logger.TraceWarning("Turn on the bluetooth adapter before you begin scanning."); return; } mHandler.PostDelayed(scanerCallback, SCAN_PERIOD); scannerViewModel.Scanning = true; ScanFilter scanFilter = (new ScanFilter.Builder()).SetServiceUuid(parcelUuid).Build(); List <ScanFilter> scanFilters = new List <ScanFilter>(); if (devicesList.Count != 0) { logger.TraceInformation("Cleaning device`s list"); devicesList.Clear(); scannerViewModel.Devices.Clear(); } scanFilters.Add(scanFilter); ScanSettings scanSettings = new ScanSettings.Builder().Build(); bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, scanSettings, this); logger.TraceInformation("Start scanning."); }
public DroidBluetoothDriver(Guid[] filter) : this(null, null) { ScanSettings.Builder scanSettingsBuilder = null; scanSettingsBuilder = new ScanSettings.Builder(); scanSettingsBuilder.SetMatchMode(BluetoothScanMatchMode.Aggressive); scanSettingsBuilder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency); this.scanSettings = scanSettingsBuilder.Build(); this.scanfiltersList = new List <ScanFilter>(); if (filter != null && filter.Length > 0) { foreach (Guid selectedFilter in filter) { ParcelUuid parcelUuid = null; ScanFilter.Builder filterBuilder = new ScanFilter.Builder(); ScanFilter currentFilter = null; try { parcelUuid = ParcelUuid.FromString(selectedFilter.ToString()); filterBuilder.SetServiceUuid(parcelUuid); currentFilter = filterBuilder.Build(); this.scanfiltersList.Add(currentFilter); } catch (Exception) { } } } }
public BtError enumerateDevices() { if (!isScanning && !_isConnected) { devices.Clear(); deviceAddresses.Clear(); serviceObjects.Clear(); characteristicObjects.Clear(); descriptorObjects.Clear(); var error = checkBtSupport(); if (error != BtError.None) { return(error); } var settings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.Balanced).Build(); var filters = new List <ScanFilter>(); scanServices.ForEach((item) => { filters.Add(new ScanFilter.Builder().SetServiceUuid(new ParcelUuid(UUID.FromString(item))).Build()); }); if (filters.Count == 0) { btAdapter.BluetoothLeScanner.StartScan(scanCallback); } else { btAdapter.BluetoothLeScanner.StartScan(filters, settings, scanCallback); } isScanning = true; return(BtError.None); } else { return(BtError.AlreadyRunning); } }
public void Start() { SystemDebug.WriteLine($"{nameof(Start)}()", LogTag); if (_adapter is null || _adapter.BluetoothLeScanner is null) { SystemDebug.WriteLine("adapter is null, please turn bluetooth on", LogTag); return; } var scanSettings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower).Build(); SystemDebug.WriteLine("starting scan", LogTag); lock (_lock) { _cancellationTokenSource = new CancellationTokenSource(); _cancellationToken = _cancellationTokenSource.Token; // if Start/Stop were called on different threads and start ran first the token // will be canceled and this will cancel immediately anyways _scanTask = Task.Run(async() => { while (!_cancellationToken.IsCancellationRequested) { //SystemDebug.WriteLine("scanning for beacons...", LogTag); var scanCallback = new BLEScanCallback(); scanCallback.OnAdvertisementPacketReceived += ScanCallback_OnAdvertisementPacketReceived; _adapter.BluetoothLeScanner.StartScan(null, scanSettings, scanCallback); try { await Task.Delay(ScanDurationMs, _cancellationToken); } catch (TaskCanceledException) { SystemDebug.WriteLine("Scan duration delay cancelled", LogTag); } //SystemDebug.WriteLine("scanning for beacons completed...", LogTag); _adapter.BluetoothLeScanner.StopScan(scanCallback); scanCallback.OnAdvertisementPacketReceived -= ScanCallback_OnAdvertisementPacketReceived; //SystemDebug.WriteLine("scanning for beacons paused...", LogTag); try { await Task.Delay(ScanDelayMs, _cancellationToken); } catch (TaskCanceledException) { SystemDebug.WriteLine("Scan delay cancelled", LogTag); } } }, _cancellationToken); } }
protected override async Task ScanAsync(CancellationToken cancellationToken) { // start a scan if bluetooth is present and enabled if (BluetoothAdapter.DefaultAdapter?.IsEnabled ?? false) { try { ScanFilter scanFilter = new ScanFilter.Builder() .SetServiceUuid(new ParcelUuid(_deviceIdService.Uuid)) .Build(); List <ScanFilter> scanFilters = new List <ScanFilter>(new[] { scanFilter }); ScanSettings.Builder scanSettingsBuilder = new ScanSettings.Builder() .SetScanMode(global::Android.Bluetooth.LE.ScanMode.Balanced); // return batched scan results periodically if supported on the BLE chip if (BluetoothAdapter.DefaultAdapter.IsOffloadedScanBatchingSupported) { scanSettingsBuilder.SetReportDelay((long)(ScanDurationMS / 2.0)); } // start a fresh manager delegate to collect/read results _bluetoothScannerCallback = new AndroidBluetoothClientScannerCallback(_deviceIdService, _deviceIdCharacteristic, this); BluetoothAdapter.DefaultAdapter.BluetoothLeScanner.StartScan(scanFilters, scanSettingsBuilder.Build(), _bluetoothScannerCallback); TaskCompletionSource <bool> scanCompletionSource = new TaskCompletionSource <bool>(); cancellationToken.Register(() => { try { BluetoothAdapter.DefaultAdapter.BluetoothLeScanner.StopScan(_bluetoothScannerCallback); } catch (Exception ex) { SensusServiceHelper.Get().Logger.Log("Exception while stopping scan: " + ex.Message, LoggingLevel.Normal, GetType()); } finally { scanCompletionSource.TrySetResult(true); } }); await scanCompletionSource.Task; } catch (Exception ex) { SensusServiceHelper.Get().Logger.Log("Exception while scanning: " + ex.Message, LoggingLevel.Normal, GetType()); } } }
protected override void StartScan() { TimeSpan?reportDelay = null; SensusContext.Current.MainThreadSynchronizer.ExecuteThreadSafe(() => { // start a scan if bluetooth is present and enabled if (BluetoothAdapter.DefaultAdapter?.IsEnabled ?? false) { try { ScanFilter scanFilter = new ScanFilter.Builder() .SetServiceUuid(new ParcelUuid(_deviceIdService.Uuid)) .Build(); List <ScanFilter> scanFilters = new List <ScanFilter>(new[] { scanFilter }); ScanSettings.Builder scanSettingsBuilder = new ScanSettings.Builder() .SetScanMode(global::Android.Bluetooth.LE.ScanMode.LowPower); // return batched scan results periodically if supported on the BLE chip if (BluetoothAdapter.DefaultAdapter.IsOffloadedScanBatchingSupported) { reportDelay = TimeSpan.FromSeconds(10); scanSettingsBuilder.SetReportDelay((long)reportDelay.Value.TotalMilliseconds); } BluetoothAdapter.DefaultAdapter.BluetoothLeScanner.StartScan(scanFilters, scanSettingsBuilder.Build(), _bluetoothScannerCallback); } catch (Exception ex) { SensusServiceHelper.Get().Logger.Log("Exception while starting scanner: " + ex.Message, LoggingLevel.Normal, GetType()); } } }); // if we're batching, wait twice the report delay for some results to come in. we sleep below so as not to return from the poll // and release the wakelock we're currently holding. if (reportDelay != null) { SensusServiceHelper.Get().AssertNotOnMainThread("Waiting for BLE scan results."); Thread.Sleep((int)(reportDelay.Value.TotalMilliseconds * 2)); lock (EncounteredDeviceData) { SensusServiceHelper.Get().Logger.Log("Encountered " + EncounteredDeviceData.Count + " device(s).", LoggingLevel.Normal, GetType()); } } // we've scanned and waited for results to come in. stop scanning and wait for next poll. StopScan(); }
/// <summary> /// Scan for a single device using its address /// </summary> /// <param name="iDiscoveryFinished">Event handler for caller to be notified when the scan has completed</param> /// <param name="iDeviceAddress">Device address in the form of a GUID string</param> /// <param name="iScanSeconds">Number of seconds to scan; set to zero for indefinite</param> /// <returns></returns> public bool ScanSingleDevice(EventHandler iDiscoveryFinished, string iDeviceAddress, int iScanSeconds = 0) { // Hold the event handler DiscoveryFinished = iDiscoveryFinished ?? throw new ArgumentNullException("Disovery finished event handler must be specified"); try { // Clear list of received devices FoundDevices.Clear(); // Ensure it has stopped StopScan(); BluetoothLeScannerCompat scanner = BluetoothLeScannerCompat.Scanner; ScanSettings settings = new ScanSettings.Builder() .SetLegacy(false) .SetScanMode(ScanSettings.ScanModeLowLatency) .SetUseHardwareBatchingIfSupported(false).Build(); List <ScanFilter> filters = new List <ScanFilter>(); // Add filter to return only the specified device filters.Add(new ScanFilter.Builder().SetDeviceAddress(iDeviceAddress).Build()); _skfScanCallback = new NordicScanCallBack(); // Add in the event handlers _skfScanCallback.ScanResult += Receiver_ScanResult; _skfScanCallback.ScanFailure += Receiver_ScanFailure; // Scan scanner.StartScan(filters, settings, _skfScanCallback); _scanning = true; if (iScanSeconds != 0) { // Use a timer to end the scan _scanTimer = new Timer(iScanSeconds * 1000); _scanTimer.Elapsed += _scanTimer_Elapsed; _scanTimer.AutoReset = false; _scanTimer.Start(); } return(true); } catch (Exception ex) { Log(string.Format("Exception thrown in ScanSingleDevice: {0}", ex.Message)); return(false); } }
protected virtual IObservable <ScanResult> NewScan(ScanConfig config) => Observable.Create <ScanResult>(ob => { this.callbacks = new LollipopScanCallback((native, rssi, sr) => { var scanResult = this.ToScanResult(native, rssi, new AdvertisementData(sr)); ob.OnNext(scanResult); }); var builder = new ScanSettings.Builder(); var scanMode = this.ToNative(config.ScanType); builder.SetScanMode(scanMode); if (CrossBleAdapter.AndroidConfiguration.AdvancedScannerSettings) { if (config.MatchMode != null) { builder.SetMatchMode(this.ToNative(config.MatchMode.Value)); } if (config.NumOfMatches != null) { builder.SetNumOfMatches((int)this.ToNative(config.NumOfMatches.Value)); } } var scanFilters = new List <ScanFilter>(); if (config.ServiceUuids != null && config.ServiceUuids.Count > 0) { foreach (var guid in config.ServiceUuids) { var uuid = guid.ToParcelUuid(); scanFilters.Add(new ScanFilter.Builder() .SetServiceUuid(uuid) .Build() ); } } if (config.AndroidUseScanBatching && this.manager.Adapter.IsOffloadedScanBatchingSupported) { builder.SetReportDelay(100); } this.manager.Adapter.BluetoothLeScanner.StartScan( scanFilters, builder.Build(), this.callbacks ); return(() => this.manager.Adapter.BluetoothLeScanner?.StopScan(this.callbacks)); });
public void StartScan() { StopScan(); var bluetoothService = GetSystemService(BluetoothService) as BluetoothManager; Scan = new DT1WatchdogScanCallback(this); var scanSettings = new ScanSettings.Builder() .SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency) .Build(); Log.Debug(Logging.WatchdogTag, "DT1WatchdogService starting scan..."); bluetoothService.Adapter.BluetoothLeScanner.StartScan(null, scanSettings, Scan); }
private void startLeScan2() { Scanning = true; Log.Info(TAG, "Scan Started"); ScanSettings settings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower).Build(); List <ScanFilter> filters = new List <ScanFilter> { new ScanFilter.Builder().SetDeviceName("DEXADAPTER").Build() }; Scanner.StartScan(filters, settings, ScanCallback); Log.Info(TAG, "Start Scanning"); }
private void StartScanningNew(Guid[] serviceUuids, ManufacturerData[] manufacturerDataFilters) { var hasFilter = serviceUuids?.Any() ?? false; List <ScanFilter> scanFilters = null; if (hasFilter) { scanFilters = new List <ScanFilter>(); foreach (var serviceUuid in serviceUuids) { var sfb = new ScanFilter.Builder(); sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString())); scanFilters.Add(sfb.Build()); } foreach (var manufacturerData in manufacturerDataFilters) { var sfb = new ScanFilter.Builder(); sfb.SetManufacturerData(manufacturerData.Id, manufacturerData.Data); scanFilters.Add(sfb.Build()); } } var ssb = new ScanSettings.Builder(); ssb.SetScanMode(ScanMode.ToNative()); if (Build.VERSION.SdkInt >= BuildVersionCodes.O) { // enable Bluetooth 5 Advertisement Extensions on Android 8.0 and above ssb.SetLegacy(false); } //ssb.SetCallbackType(ScanCallbackType.AllMatches); if (_bluetoothAdapter.BluetoothLeScanner != null) { Trace.Message($"Adapter >=21: Starting a scan for devices. ScanMode: {ScanMode}"); if (hasFilter) { Trace.Message($"ScanFilters: {string.Join(", ", serviceUuids)}"); } _bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback); } else { Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off"); } }
public async void StartScanningForDevices(int timeOutSeconds = 10, string serviceUuid = null) { Console.WriteLine("Adapter: Starting a scan for devices."); // clear out the list this._discoveredDevices = new List <IDevice> (); // start scanning this._isScanning = true; var scanFilterBuilder = new ScanFilter.Builder(); if (!string.IsNullOrWhiteSpace(serviceUuid)) { scanFilterBuilder.SetServiceUuid(ParcelUuid.FromString(serviceUuid)); } var filter = scanFilterBuilder.Build(); var filterList = new List <ScanFilter>() { filter }; var scanSettingBuilder = new ScanSettings.Builder(); scanSettingBuilder.SetScanMode(ScanMode.Balanced); var scanSettings = scanSettingBuilder.Build(); this._adapter.BluetoothLeScanner.StartScan(filterList, scanSettings, _scanCallback); //this._adapter.StartLeScan (this); // in 10 seconds, stop the scan await Task.Delay(TimeSpan.FromSeconds(timeOutSeconds)); // if we're still scanning if (this._isScanning) { Console.WriteLine("BluetoothLEManager: Scan timeout has elapsed."); // Use the method, because it also updates the _isScanning portion. StopScanningForDevices(); this.ScanTimeoutElapsed(this, new EventArgs()); } }
public void StartLeScan() { Scanning = true; Log.Info(TAG, "ScanStarted"); // ScanSettings settings = new ScanSettings.Builder() .SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower) // LowPower uses the least amount of power. It is enforced is the application is not in the foreground .Build(); List <ScanFilter> filters = new List <ScanFilter>(); filters.Add(new ScanFilter.Builder().SetDeviceName("DEXAdapter").Build()); // Filter allows the application to look only for the DEX adapter. Scanner.StartScan(filters, settings, ScanCallback); System.Diagnostics.Debug.Write("START SCANNING"); //cTimer.Start(); }
/// <summary> /// This function switches the bluetooth on if it is not on /// It then uses the BLE scanner to scan the bluetooth active devices in /// the surrounding, and receives the data in the callback function provided /// </summary> public void startConnectingBluetooth() { BluetoothAdapter adapter = BluetoothAdapter.DefaultAdapter; var scanner = adapter.BluetoothLeScanner; if (adapter != null && !adapter.IsEnabled) { adapter.Enable(); } var callback = new project3.CallBackClass(); ScanSettings settings = new ScanSettings.Builder() .SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency) .SetReportDelay(0) .Build(); scanner.StartScan(new List <ScanFilter>(), settings, callback); }
public void Start() { var bluetoothManager = (BluetoothManager)_context.ApplicationContext.GetSystemService(BluetoothService); var bluetoothAdapter = bluetoothManager.Adapter; var myBeaconService = new MyBeaconService(_context); var intent = new Intent(_context, typeof(MyBeaconService)); intent.PutExtra("o-scan", true); var settings = new ScanSettings.Builder().SetScanMode(ScanMode.LowPower).Build(); var filters = GetScanFilters(); // Make a scan filter matching the beacons I care about var pendingIntent = PendingIntent.GetBroadcast(_context, 0, intent, PendingIntentFlags.UpdateCurrent); bluetoothAdapter.BluetoothLeScanner.StartScan(filters, settings, pendingIntent); Toast.MakeText(_context, "MyService created!", ToastLength.Long).Show(); }
public bool StartScan(int timeoutMs, bool filtered) { try { if (!BleEnabled) { BLE_ERR("can't start scan, ble not enabled"); return(false); } if (!Init()) { return(false); } _Timeout = new Timer((obj) => { StopScan(); }, null, timeoutMs, Timeout.Infinite); BLE("start scan"); _Devices.Clear(); if (filtered) { var filter = new ScanFilter.Builder().SetServiceUuid(ParcelUuid.FromString(BleConstants.BLE_SERVER_SERVICE_UUID)).Build(); var settings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency).Build(); _CentralManager.Adapter.BluetoothLeScanner.StartScan(new List <ScanFilter> { filter }, settings, this); } else { _CentralManager.Adapter.BluetoothLeScanner.StartScan(this); } return(true); } catch (Exception ex) { BLE_ERR("start scan error", ex); return(false); } }
public IObservable <ScanResult> Scan(ScanConfig config) => Observable.Create <ScanResult>(ob => { this.devices.Clear(); this.callbacks = new LollipopScanCallback( sr => { var scanResult = this.ToScanResult(sr.Device, sr.Rssi, new AdvertisementData(sr)); ob.OnNext(scanResult); }, errorCode => ob.OnError(new BleException("Error during scan: " + errorCode.ToString())) ); var builder = new ScanSettings.Builder(); var scanMode = this.ToNative(config.ScanType); builder.SetScanMode(scanMode); var scanFilters = new List <ScanFilter>(); if (config.ServiceUuids != null && config.ServiceUuids.Count > 0) { foreach (var uuid in config.ServiceUuids) { var parcel = new ParcelUuid(UUID.FromString(uuid)); scanFilters.Add(new ScanFilter.Builder() .SetServiceUuid(parcel) .Build() ); } } if (config.AndroidUseScanBatching && this.Manager.Adapter.IsOffloadedScanBatchingSupported) { builder.SetReportDelay(100); } this.Manager.Adapter.BluetoothLeScanner.StartScan( scanFilters, builder.Build(), this.callbacks ); return(() => this.Manager.Adapter.BluetoothLeScanner?.StopScan(this.callbacks)); });
public async Task BeginScanningForDevices() { this._discoveredDevices = new List <BluetoothDevice>(); this._isScanning = true; ScanSettings settings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower).SetCallbackType(ScanCallbackType.AllMatches).Build(); ScanFilter filter = new ScanFilter.Builder().SetDeviceAddress("63:8A:87:FE:F3:76").Build(); //ScanFilter filter2 = new ScanFilter.Builder().SetServiceUuid(ParcelUuid.fromString(serviceUUIDs[i].toString())).build(); List <ScanFilter> filters = new List <ScanFilter>(); filters.Add(filter); this._scanner.StartScan(filters, settings, new BluetoothScanCallback()); await Task.Delay(10000); if (this._isScanning) { //this._scanner.StopScan(new PendingIntent()); } }
public DroidBluetoothDriver(IEnumerable <ScanFilter> scanFilters, ScanSettings scanSettings) { ScanSettings.Builder scanSettingsBuilder = null; if (scanFilters != null) { this.scanfiltersList = new List <ScanFilter>(scanFilters); } else { this.scanfiltersList = new List <ScanFilter>(); } if (scanSettings != null) { this.scanSettings = scanSettings; } else { scanSettingsBuilder = new ScanSettings.Builder(); scanSettingsBuilder.SetMatchMode(BluetoothScanMatchMode.Aggressive); scanSettingsBuilder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency); this.scanSettings = scanSettingsBuilder.Build(); } if (!Application.Context.PackageManager.HasSystemFeature(PackageManager.FeatureBluetoothLe)) { this.State = BluetoothDriverStates.NotPresent; return; } this.bluetoothManager = Application.Context.GetSystemService(Context.BluetoothService) as BluetoothManager; if (this.bluetoothManager != null) { this.bluetoothAdapter = this.bluetoothManager.Adapter; if (this.bluetoothAdapter != null) { this.State = BluetoothDriverStates.Enabled; } } }
void IAdvertiseAndDiscoverBluetoothDevice.Discover() { try { Analytics.TrackEvent(Build.Model + " Discover method called."); List <ScanFilter> filters = new List <ScanFilter>(); ScanFilter filter = new ScanFilter.Builder() .SetServiceUuid(new ParcelUuid(MY_UUID)) .Build(); filters.Add(filter); //ScanSettings settings = new ScanSettings.Builder() // .SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency) // .Build(); ScanSettings.Builder builder = new ScanSettings.Builder(); builder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency); if (Build.VERSION.SdkInt >= BuildVersionCodes.M /* Marshmallow */) { builder.SetMatchMode(BluetoothScanMatchMode.Aggressive); builder.SetNumOfMatches((int)BluetoothScanMatchNumber.MaxAdvertisement); builder.SetCallbackType(ScanCallbackType.AllMatches); } var settings = builder.Build(); myScanCallback = new MyScanCallback(); bluetoothLeScanner = BluetoothAdapter.DefaultAdapter.BluetoothLeScanner; bluetoothLeScanner.StartScan(filters, settings, myScanCallback); } catch (System.Exception ex) { Analytics.TrackEvent(Build.Model + " Something went wrong in Discover method."); } }
private async void StartLeScan(Guid[] serviceUuids) { if (_isScanning) { Mvx.Trace("Adapter: Already scanning."); return; } _isScanning = true; // clear out the list _discoveredDevices = new List<IDevice>(); if (serviceUuids == null || !serviceUuids.Any()) { if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop) { Mvx.Trace("Adapter < 21: Starting a scan for devices."); //without filter _adapter.StartLeScan(this); } else { Mvx.Trace("Adapter >= 21: Starting a scan for devices."); if (_adapter.BluetoothLeScanner != null) { _adapter.BluetoothLeScanner.StartScan(_api21ScanCallback); } else { Mvx.Trace("Adapter >= 21: Scan failed. Bluetooth is probably off"); } } } else { if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop) { var uuids = serviceUuids.Select(u => UUID.FromString(u.ToString())).ToArray(); Mvx.Trace("Adapter < 21: Starting a scan for devices."); _adapter.StartLeScan(uuids, this); } else { Mvx.Trace("Adapter >=21: Starting a scan for devices with service ID {0}.", serviceUuids.First()); var scanFilters = new List<ScanFilter>(); foreach (var serviceUuid in serviceUuids) { var sfb = new ScanFilter.Builder(); sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString())); scanFilters.Add(sfb.Build()); } var ssb = new ScanSettings.Builder(); //ssb.SetCallbackType(ScanCallbackType.AllMatches); if (_adapter.BluetoothLeScanner != null) { _adapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback); } else { Mvx.Trace("Adapter >= 21: Scan failed. Bluetooth is probably off"); } } } // in ScanTimeout seconds, stop the scan _cancellationTokenSource = new CancellationTokenSource(); try { await Task.Delay(ScanTimeout, _cancellationTokenSource.Token); Mvx.Trace("Adapter: Scan timeout has elapsed."); StopScan(); TryDisposeToken(); _isScanning = false; //important for this to be caled after _isScanning = false; ScanTimeoutElapsed(this, new EventArgs()); } catch (TaskCanceledException) { Mvx.Trace("Adapter: Scan was cancelled."); StopScan(); TryDisposeToken(); _isScanning = false; } }
private ScanSettings CreateScanSettings() { ScanSettings.Builder mBuilder = new ScanSettings.Builder(); mBuilder.SetReportDelay(0); mBuilder.SetScanMode(ScanMode.LowPower); return mBuilder.Build(); }