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);
}
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;
}
}
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");
}
}
private ScanSettings BuildScanSettings()
{
var builder = new ScanSettings.Builder();
builder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower);
return(builder.Build());
}
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());
}
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 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(() =>
{
}));
}
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....";
}
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));
});
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 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 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.");
}
}
public bool StartScanning()
{
if (isScanning)
{
return(true);
}
if (IsEnabled)
{
// Stops scanning after a pre-defined scan period.
//scanHandler.PostDelayed(new Runnable(() =>
//{
// isScanning = false;
// scanner.StopScan(scanCallback);
//}), 10000);
isScanning = true;
ScanFilter.Builder builder = new ScanFilter.Builder();
builder.SetServiceUuid(DottedUUID);
ScanSettings.Builder sBuilder = new ScanSettings.Builder();
sBuilder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowPower);
scanner.StartScan(new List <ScanFilter> {
builder.Build()
},
sBuilder.Build(),
scanCallback);
return(true);
}
else
{
isScanning = false;
scanner.StopScan(scanCallback);
return(false);
}
}
private void StartScanningNew(ScanFilterOptions scanFilterOptions)
{
var hasFilter = scanFilterOptions?.HasFilter == true;
List <ScanFilter> scanFilters = null;
if (hasFilter)
{
scanFilters = new List <ScanFilter>();
if (scanFilterOptions.HasServiceIds)
{
foreach (var serviceUuid in scanFilterOptions.ServiceUuids)
{
var sfb = new ScanFilter.Builder();
sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString()));
scanFilters.Add(sfb.Build());
}
}
if (scanFilterOptions.HasServiceData)
{
foreach (var serviceDataFilter in scanFilterOptions.ServiceDataFilters)
{
var sfb = new ScanFilter.Builder();
if (serviceDataFilter.ServiceDataMask == null)
{
sfb.SetServiceData(ParcelUuid.FromString(serviceDataFilter.ServiceDataUuid.ToString()), serviceDataFilter.ServiceData);
}
else
{
sfb.SetServiceData(ParcelUuid.FromString(serviceDataFilter.ServiceDataUuid.ToString()), serviceDataFilter.ServiceData, serviceDataFilter.ServiceDataMask);
}
scanFilters.Add(sfb.Build());
}
}
if (scanFilterOptions.HasManufacturerIds)
{
foreach (var manufacturerDataFilter in scanFilterOptions.ManufacturerDataFilters)
{
var sfb = new ScanFilter.Builder();
if (manufacturerDataFilter.ManufacturerDataMask != null)
{
sfb.SetManufacturerData(manufacturerDataFilter.ManufacturerId, manufacturerDataFilter.ManufacturerData);
}
else
{
sfb.SetManufacturerData(manufacturerDataFilter.ManufacturerId, manufacturerDataFilter.ManufacturerData, manufacturerDataFilter.ManufacturerDataMask);
}
scanFilters.Add(sfb.Build());
}
}
if (scanFilterOptions.HasDeviceAddresses)
{
foreach (var deviceAddress in scanFilterOptions.DeviceAddresses)
{
if (BluetoothAdapter.CheckBluetoothAddress(deviceAddress))
{
var sfb = new ScanFilter.Builder();
sfb.SetDeviceAddress(deviceAddress);
scanFilters.Add(sfb.Build());
}
else
{
Trace.Message($"Device address {deviceAddress} is invalid. The correct format is \"01:02:03:AB:CD:EF\"");
}
}
}
if (scanFilterOptions.HasDeviceNames)
{
foreach (var deviceName in scanFilterOptions.DeviceNames)
{
var sfb = new ScanFilter.Builder();
sfb.SetDeviceName(deviceName);
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)
{
if (scanFilterOptions.HasServiceIds)
{
Trace.Message($"Service UUID Scan Filters: {string.Join(", ", scanFilterOptions.ServiceUuids)}");
}
if (scanFilterOptions.HasServiceData)
{
Trace.Message($"Service Data Scan Filters: {string.Join(", ", scanFilterOptions.ServiceDataFilters.ToString())}");
}
if (scanFilterOptions.HasManufacturerIds)
{
Trace.Message($"Manufacturer Id Scan Filters: {string.Join(", ", scanFilterOptions.ManufacturerDataFilters.ToString())}");
}
if (scanFilterOptions.HasDeviceAddresses)
{
Trace.Message($"Device Address Scan Filters: {string.Join(", ", scanFilterOptions.DeviceAddresses)}");
}
if (scanFilterOptions.HasDeviceNames)
{
Trace.Message($"Device Name Scan Filters: {string.Join(", ", scanFilterOptions.DeviceNames)}");
}
}
_bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback);
}
else
{
Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off");
}
}
private ScanSettings CreateScanSettings()
{
ScanSettings.Builder mBuilder = new ScanSettings.Builder();
mBuilder.SetReportDelay(0);
mBuilder.SetScanMode(ScanMode.LowPower);
return mBuilder.Build();
}
