Ejemplo n.º 1
0
        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");
            }
        }
Ejemplo n.º 2
0
        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();
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        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());
        }
Ejemplo n.º 5
0
        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);
            }
        }
Ejemplo n.º 6
0
        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);
        }
Ejemplo n.º 7
0
        private ScanSettings BuildScanSettings()
        {
            var builder = new ScanSettings.Builder();

            builder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower);
            return(builder.Build());
        }
Ejemplo n.º 8
0
        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....";
        }
Ejemplo n.º 9
0
        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();
        }
Ejemplo n.º 10
0
        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(() =>
            {
            }));
        }
Ejemplo n.º 12
0
        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)
                    {
                    }
                }
            }
        }
Ejemplo n.º 14
0
 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);
     }
 }
Ejemplo n.º 15
0
        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();
        }
Ejemplo n.º 18
0
        /// <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);
            }
        }
Ejemplo n.º 19
0
        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));
        });
Ejemplo n.º 20
0
        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);
        }
Ejemplo n.º 21
0
        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");
        }
Ejemplo n.º 22
0
        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");
            }
        }
Ejemplo n.º 23
0
        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());
            }
        }
Ejemplo n.º 24
0
        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);
        }
Ejemplo n.º 26
0
        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();
        }
Ejemplo n.º 27
0
        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);
            }
        }
Ejemplo n.º 28
0
        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));
        });
Ejemplo n.º 29
0
        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].toStri‌​ng())).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.");
            }
        }
Ejemplo n.º 32
0
        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;
            }
        }
Ejemplo n.º 33
0
 private ScanSettings CreateScanSettings()
 {
     ScanSettings.Builder mBuilder = new ScanSettings.Builder();
     mBuilder.SetReportDelay(0);
     mBuilder.SetScanMode(ScanMode.LowPower);
     return mBuilder.Build();
 }