//https://github.com/Microsoft/Windows-universal-samples/tree/master/Samples/BluetoothAdvertisement/cs
public BeaconManagerImpl() {
this.beaconMgr = new BeaconManager();
this.beaconMgr.BluetoothBeacons.CollectionChanged += (sender, args) => { };
this.watcher = new BluetoothLEAdvertisementWatcher();
this.watcher.Received += (sender, args) => this.beaconMgr.ReceivedAdvertisement(args);
// Begin of watcher configuration. Configure the advertisement filter to look for the data advertised by the publisher
// in Scenario 2 or 4. You need to run Scenario 2 on another Windows platform within proximity of this one for Scenario 1 to
// take effect. The APIs shown in this Scenario are designed to operate only if the App is in the foreground. For background
// watcher operation, please refer to Scenario 3.
// Please comment out this following section (watcher configuration) if you want to remove all filters. By not specifying
// any filters, all advertisements received will be notified to the App through the event handler. You should comment out the following
// section if you do not have another Windows platform to run Scenario 2 alongside Scenario 1 or if you want to scan for
// all LE advertisements around you.
// For determining the filter restrictions programatically across APIs, use the following properties:
// MinSamplingInterval, MaxSamplingInterval, MinOutOfRangeTimeout, MaxOutOfRangeTimeout
// Part 1A: Configuring the advertisement filter to watch for a particular advertisement payload
// First, let create a manufacturer data section we wanted to match for. These are the same as the one
// created in Scenario 2 and 4.
//var manufacturerData = new BluetoothLEManufacturerData();
//// Then, set the company ID for the manufacturer data. Here we picked an unused value: 0xFFFE
//manufacturerData.CompanyId = 0xFFFE;
//// Finally set the data payload within the manufacturer-specific section
//// Here, use a 16-bit UUID: 0x1234 -> {0x34, 0x12} (little-endian)
//var writer = new DataWriter();
//writer.WriteUInt16(0x1234);
//// Make sure that the buffer length can fit within an advertisement payload. Otherwise you will get an exception.
//manufacturerData.Data = writer.DetachBuffer();
//// Add the manufacturer data to the advertisement filter on the watcher:
//watcher.AdvertisementFilter.Advertisement.ManufacturerData.Add(manufacturerData);
//// Part 1B: Configuring the signal strength filter for proximity scenarios
//// Configure the signal strength filter to only propagate events when in-range
//// Please adjust these values if you cannot receive any advertisement
//// Set the in-range threshold to -70dBm. This means advertisements with RSSI >= -70dBm
//// will start to be considered "in-range".
//watcher.SignalStrengthFilter.InRangeThresholdInDBm = -70;
//// Set the out-of-range threshold to -75dBm (give some buffer). Used in conjunction with OutOfRangeTimeout
//// to determine when an advertisement is no longer considered "in-range"
//watcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -75;
//// Set the out-of-range timeout to be 2 seconds. Used in conjunction with OutOfRangeThresholdInDBm
//// to determine when an advertisement is no longer considered "in-range"
//watcher.SignalStrengthFilter.OutOfRangeTimeout = TimeSpan.FromMilliseconds(2000);
// By default, the sampling interval is set to zero, which means there is no sampling and all
// the advertisement received is returned in the Received event
}
private void _Watcher_Stopped(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementWatcherStoppedEventArgs args)
{
System.Diagnostics.Debug.WriteLine("Bluetooth LE Advertisement Watcher stopped with status: "+ _Watcher.Status);
if(Stopped != null){
Stopped(_Watcher.Status);
}
}
public BluetoothAdvertismentViewerViewModel()
{
_table = new ConcurrentDictionary<string, BluetoothLEAdvertismentViewModel>();
_devices = new ObservableCollection<BluetoothLEAdvertismentViewModel>();
Advertisements = new CollectionViewSource();
Advertisements.Source = _devices;
_dispatcher = Advertisements.Dispatcher;
_watcher = new BluetoothLEAdvertisementWatcher();
// Finally set the data payload within the manufacturer-specific section
// Here, use a 16-bit UUID: 0x1234 -> {0x34, 0x12} (little-endian)
//var writer = new DataWriter();
//writer.WriteUInt16(0x1234);
//manufacturerData.Data = writer.DetachBuffer();
//watcher.AdvertisementFilter.Advertisement.ManufacturerData.Add(manufacturerData);
_watcher.SignalStrengthFilter.InRangeThresholdInDBm = -70;
_watcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -75;
_watcher.SignalStrengthFilter.OutOfRangeTimeout = TimeSpan.FromMilliseconds(2000);
_watcher.Received += OnAdvertisementReceived;
_watcher.Stopped += OnAdvertisementWatcherStopped;
RunCommand = new SimpleCommand(StartWatcher);
StopCommand = new SimpleCommand(StopWatcher, false);
}
public MainPage()
{
InitializeComponent();
DataContext = this;
_dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Create the Bluetooth LE watcher from the Windows 10 UWP
_watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
// Construct the Universal Bluetooth Beacon manager
_beaconManager = new BeaconManager();
BeaconListView.ItemsSource = _beaconManager.BluetoothBeacons;
// Simulate beacon info
//#if DEBUG
// var eddystoneBeacon = new Beacon(Beacon.BeaconTypeEnum.Eddystone);
// eddystoneBeacon.BeaconFrames.Add(new TlmEddystoneFrame(0, 3100, (float)25.5, 2000, 1000));
// // Ranging Data 0xEE = -18dbM: needs unchecked syntax to cast constants, works without unchecked for runtime variables
// // (sbyte)0x12 = +18dbM
// // Sample values from: https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.tx_power_level.xml
// eddystoneBeacon.BeaconFrames.Add(new UidEddystoneFrame(unchecked((sbyte)0xEE),
// new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A },
// new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }));
// eddystoneBeacon.BeaconFrames.Add(new UrlEddystoneFrame(220, "http://www.tieto.at"));
// eddystoneBeacon.Rssi = -49;
// eddystoneBeacon.BluetoothAddress = 0x0000e27ef189f6c4; // 3
// eddystoneBeacon.Timestamp = DateTimeOffset.Now;
// _beaconManager.BluetoothBeacons.Add(eddystoneBeacon);
//#endif
}
public MainPage()
{
this.InitializeComponent();
DataContext = this;
_dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Create the Bluetooth LE watcher from the Windows 10 UWP
_watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
// Construct the Universal Bluetooth Beacon manager
_beaconManager = new BeaconManager();
BeaconListView.ItemsSource = _beaconManager.BluetoothBeacons;
// Simulate beacon info
//#if DEBUG
// var eddystoneBeacon = new Beacon(Beacon.BeaconTypeEnum.Eddystone);
// eddystoneBeacon.BeaconFrames.Add(new TlmEddystoneFrame(0, 3100, (float)25.5, 2000, 1000));
// eddystoneBeacon.BeaconFrames.Add(new UidEddystoneFrame(220,
// new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A },
// new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }));
// eddystoneBeacon.BeaconFrames.Add(new UrlEddystoneFrame(220, "http://www.tieto.at"));
// eddystoneBeacon.Rssi = -49;
// eddystoneBeacon.BluetoothAddress = 0x0000e27ef189f6c4; // 3
// eddystoneBeacon.Timestamp = DateTimeOffset.Now;
// _beaconManager.BluetoothBeacons.Add(eddystoneBeacon);
//#endif
}
async private void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
// The timestamp of the event
DateTimeOffset timestamp = eventArgs.Timestamp;
// The type of advertisement
BluetoothLEAdvertisementType advertisementType = eventArgs.AdvertisementType;
// The received signal strength indicator (RSSI)
Int16 rssi = eventArgs.RawSignalStrengthInDBm;
// The local name of the advertising device contained within the payload, if any
string localName = eventArgs.Advertisement.LocalName;
// Check if there are any manufacturer-specific sections.
// If there is, print the raw data of the first manufacturer section (if there are multiple).
string manufacturerDataString = "";
var manufacturerSections = eventArgs.Advertisement.ManufacturerData;
var res = String.Empty;
if (manufacturerSections.Count > 0)
{
// Only print the first one of the list
var manufacturerData = manufacturerSections[0];
var data = new byte[manufacturerData.Data.Length];
using (var reader = DataReader.FromBuffer(manufacturerData.Data))
{
reader.ReadBytes(data);
}
var str = BitConverter.ToString(data);
//Char.ConvertFromUtf32(value);
string[] hexValuesSplit = str.Split('-');
foreach (String hex in hexValuesSplit)
{
int value = Convert.ToInt32(hex, 16);
string stringValue = Char.ConvertFromUtf32(value);
char charValue = (char)value;
res += charValue;
}
// Print the company ID + the raw data in hex format
manufacturerDataString = string.Format("0x{0}: {1}",
manufacturerData.CompanyId.ToString("X"), res);
}
// Serialize UI update to the main UI thread
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
// Display these inf
myTextBox.Text = $"[{timestamp.ToString("hh\\:mm\\:ss\\.fff")}]: {res}]";
});
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
// Create and initialize a new publisher instance.
publisher = new BluetoothLEAdvertisementPublisher();
watcher = new BluetoothLEAdvertisementWatcher();
watcher.Received += OnAdvertisementReceived;
}
public CurrentSensorDeviceWatcher()
{
this.watcher = new BluetoothLEAdvertisementWatcher();
this.watcher.Received += (o, e) => {
Debug.WriteLine($"Address:{e.BluetoothAddress:X08},RSSI:{e.RawSignalStrengthInDBm}");
};
this.watcher.ScanningMode = BluetoothLEScanningMode.Active;
this.watcher.Start();
}
private async void _watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
if (args.AdvertisementType == BluetoothLEAdvertisementType.ConnectableUndirected)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
await TryAddDeviceToList(args);
});
}
}
public CloudPageViewModel(IBeaconManagementService beaconManagementService, IAzureEventHubService azureEventHubService)
{
_beaconManagementService = beaconManagementService;
_azureEventHubService = azureEventHubService;
BeaconsList = _beaconManagementService.GetBeaconsList();
StatusLabel = _beaconManagementService.GetStatusLabel();
_watcher = _beaconManagementService.GetWatcher();
_watcher.Received += Watcher_Received;
}
public NotificationsPageViewModel(IBeaconManagementService beaconManagementService, INotificationsService notificationsService)
{
_beaconManagementService = beaconManagementService;
_notificationsService = notificationsService;
BeaconsList = _beaconManagementService.GetBeaconsList();
StatusLabel = _beaconManagementService.GetStatusLabel();
_watcher = _beaconManagementService.GetWatcher();
_watcher.Received += Watcher_Received;
}
private void WatcherOnReceived(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs btAdv)
{
// Let the library manager handle the advertisement to analyse & store the advertisement
_beaconManager.ReceivedAdvertisement(btAdv);
foreach (var bluetoothBeacon in _beaconManager.BluetoothBeacons.ToList())
{
Debug.WriteLine("\nBeacon: " + bluetoothBeacon.BluetoothAddressAsString);
Debug.WriteLine("Type: " + bluetoothBeacon.BeaconType);
Debug.WriteLine("Last Update: " + bluetoothBeacon.Timestamp);
Debug.WriteLine("RSSI: " + bluetoothBeacon.Rssi);
foreach (var beaconFrame in bluetoothBeacon.BeaconFrames.ToList())
{
// Print a small sample of the available data parsed by the library
if (beaconFrame is UidEddystoneFrame)
{
Debug.WriteLine("Eddystone UID Frame");
Debug.WriteLine("ID: " + ((UidEddystoneFrame) beaconFrame).NamespaceIdAsNumber.ToString("X") + " / " +
((UidEddystoneFrame) beaconFrame).InstanceIdAsNumber.ToString("X"));
}
else if (beaconFrame is UrlEddystoneFrame)
{
Debug.WriteLine("Eddystone URL Frame");
Debug.WriteLine("URL: " + ((UrlEddystoneFrame) beaconFrame).CompleteUrl);
}
else if (beaconFrame is TlmEddystoneFrame)
{
Debug.WriteLine("Eddystone Telemetry Frame");
Debug.WriteLine("Temperature [°C]: " + ((TlmEddystoneFrame) beaconFrame).TemperatureInC);
Debug.WriteLine("Battery [mV]: " + ((TlmEddystoneFrame) beaconFrame).BatteryInMilliV);
}
else
{
Debug.WriteLine("Unknown frame - not parsed by the library, write your own derived beacon frame type!");
Debug.WriteLine("Payload: " + BitConverter.ToString(((UnknownBeaconFrame) beaconFrame).Payload));
}
}
}
// Optional: distinguish beacons based on the Bluetooth address (btAdv.BluetoothAddress)
// Check if it's a beacon by Apple
/*if (btAdv.Advertisement.ManufacturerData.Any())
{
foreach (var manufacturerData in btAdv.Advertisement.ManufacturerData)
{
// 0x4C is the ID assigned to Apple by the Bluetooth SIG
if (manufacturerData.CompanyId == 0x4C)
{
// Parse the beacon data according to the Apple iBeacon specification
// Access it through: var manufacturerDataArry = manufacturerData.Data.ToArray();
var data = manufacturerData.Data.ToArray();
Messenger.Default.Send(new BleBeaconMessage {Data = data});
}
}
}*/
}
public void Stop()
{
if(_Watcher == null){
return;
}
_Watcher.Stopped -= _Watcher_Stopped;
_Watcher.Received -= _Watcher_Received;
_Watcher.Stop();
_Watcher = null;
}
/**
* Default constructor
**/
public MainPage()
{
this.InitializeComponent();
// init beacon manager
beaconManager = new BeaconManager();
// create and start the (W10 UWP) BLE watcher
watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
// trigger following method when we receive data
watcher.Received += WatcherOnReceived;
// start watching
watcher.Start();
}
public BeaconManagementService()
{
_dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Create the Bluetooth LE watcher from the Windows 10 UWP
_watcher = new BluetoothLEAdvertisementWatcher { ScanningMode = BluetoothLEScanningMode.Active };
// Create the Bluetooth LE publisher from the Windows 10 UWP
_publisher = new BluetoothLEAdvertisementPublisher();
// Construct the Universal Bluetooth Beacon manager
_beaconManager = new BeaconManager();
BeaconsList = _beaconManager.BluetoothBeacons;
_resourceLoader = ResourceLoader.GetForCurrentView();
StartScanning();
}
private void _watcher_Received(BluetoothLEAdvertisementWatcher sender,
BluetoothLEAdvertisementReceivedEventArgs args)
{
var beacon = new Beacon
{
AddressAsUlong = args.BluetoothAddress,
LocalName = args.Advertisement.LocalName,
UpdatedAt = args.Timestamp.UtcDateTime,
Rssi = args.RawSignalStrengthInDBm
};
//if (args.Advertisement.ManufacturerData != null)
//{
// if (args.Advertisement.ManufacturerData.Count > 0)
// {
// beacon.IsProximityBeacon = true;
// }
// foreach (var manufacturerData in args.Advertisement.ManufacturerData)
// {
// beacon.ManufacturerData.Add(new BeaconManufacturerData(manufacturerData.CompanyId,
// manufacturerData.Data.ToArray()));
// }
//}
//if (args.Advertisement.ServiceUuids != null)
//{
// beacon.ServiceUuids.AddRange(args.Advertisement.ServiceUuids);
//}
//if (args.Advertisement.DataSections != null)
//{
// foreach (var dataSections in args.Advertisement.DataSections)
// {
// beacon.DataSections.Add(new BeaconDataSection(dataSections.DataType,
// dataSections.Data.ToArray()));
// }
//}
BeaconSignalReceived(this, new BeaconOperationEventArgs
{
Beacon = beacon,
LocalAddress = this.LocalAddress
});
}
// BLE device received delegate
private async void Watcher_ReceivedAsync(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
devices.Add(args.Advertisement.LocalName + " " + args.BluetoothAddress);
//(args.Advertisement.LocalName + " " + args.BluetoothAddress.ToString());
//List<string> distinct = devices.Distinct().ToList();
//var codes = distinct.Where(x => x.Any(n => char.IsLetter(n)))
// .Select(x => x)
// .ToList();
//var UniqueDevices = from device in devices
// orderby device descending
// select device;
var Filter = from device in devices
let lowerdevice = device.ToLower()
where lowerdevice.Contains(tbxFilter.Text.ToLower())
orderby lowerdevice
select lowerdevice;
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
lbxBLEDevices.Items.Clear();
try
{
foreach (var item in Filter.Distinct().ToList())
{
lbxBLEDevices.Items.Add(item);
}
}
catch (InvalidOperationException e)
{
Debug.Write(e);
}
});
}
private static void GetTemp(int limit, int timeout)
{
var switchBotMeterThUuid = new Guid("cba20d00-224d-11e6-9fb8-0002a5d5c51b");
var filter = new BluetoothLEAdvertisementFilter();
filter.Advertisement = new BluetoothLEAdvertisement();
filter.Advertisement.ServiceUuids.Add(switchBotMeterThUuid);
var watcher = new BluetoothLEAdvertisementWatcher(filter);
var countdownEvent = new CountdownEvent(limit > 0 ? limit : 1);
watcher.Received += (sender, args) =>
{
if (args.Advertisement.ServiceUuids.Contains(switchBotMeterThUuid))
{
foreach (var ds in args.Advertisement.DataSections)
{
if (ds.DataType == 22 && ds.Data.Length == 8)
{
var data = ds.Data.ToArray(2, 6);
double temp = ((data[3] & 0x0f) / 10.0 + (data[4] & 0x7f)) * ((data[4] & 0x80) != 0 ? 1 : -1);
int humidity = data[5] & 0x7f;
int battery = data[2] & 0x7f;
Console.WriteLine($"{args.BluetoothAddress:X} {temp:f1} {humidity:d} {battery:d}");
if (limit > 0)
{
countdownEvent.Signal();
}
}
}
}
};
watcher.ScanningMode = BluetoothLEScanningMode.Active;
watcher.Start();
if (timeout > 0)
{
countdownEvent.Wait(timeout * 1000);
}
else
{
countdownEvent.Wait();
}
watcher.Stop();
}
private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
string localName = args.Advertisement.LocalName;
if (localName != "heart rate sensor")
{
return;
}
if (!lockO && (BluetoothLEDevice == null || BluetoothLEDevice.ConnectionStatus == BluetoothConnectionStatus.Disconnected))
{
lockO = true;
BluetoothLEDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress);
GattDeviceServicesResult service = await BluetoothLEDevice.GetGattServicesAsync();
foreach (GattDeviceService s in service.Services.Where(x => x.Uuid.ToString().StartsWith("0000180d")))
{
var car = await s.GetCharacteristicsAsync();
foreach (var c in car.Characteristics.Where(x => x.Uuid.ToString().StartsWith("00002a37")))
{
Characteristic = c;
Characteristic.ValueChanged += C_ValueChanged;
var value_result = await c.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
if (value_result != GattCommunicationStatus.Success)
{
Characteristic.ValueChanged -= C_ValueChanged;
Console.WriteLine($"ERROR: Gatt Subscription hat failed: {value_result}");
Console.WriteLine($"{c.Uuid}");
}
else
{
Console.WriteLine("Subscription was successfull");
Console.WriteLine($"{c.Uuid}");
}
}
}
lockO = false;
}
return;
}
/// <summary>
/// Handle the client's request to connect to a particular peripheral.
/// Valid in the discovery state; transitions to connected state on success.
/// </summary>
/// <param name="parameters">
/// A JSON object containing the UUID of a peripheral found by the most recent discovery request
/// </param>
private async Task Connect(JObject parameters)
{
if (_services != null)
{
//throw JsonRpcException.InvalidRequest("already connected to peripheral");
return;
}
var peripheralId = parameters["peripheralId"].ToObject <ulong>();
if (!_reportedPeripherals.Contains(peripheralId))
{
// the client may only connect to devices that were returned by the current discovery request
throw JsonRpcException.InvalidParams($"invalid peripheral ID: {peripheralId}");
}
_peripheral = await BluetoothLEDevice.FromBluetoothAddressAsync(peripheralId);
var servicesResult = await _peripheral.GetGattServicesAsync(BluetoothCacheMode.Uncached);
if (servicesResult.Status != GattCommunicationStatus.Success)
{
throw JsonRpcException.ApplicationError($"failed to enumerate GATT services: {servicesResult.Status}");
}
_peripheral.ConnectionStatusChanged += OnPeripheralStatusChanged;
_services = servicesResult.Services;
// collect optional services plus all services from all filters
// Note: this modifies _optionalServices for convenience since we know it'll go away soon.
_allowedServices = _optionalServices ?? new HashSet <Guid>();
_allowedServices = _filters
.Where(filter => filter.RequiredServices?.Count > 0)
.Aggregate(_allowedServices, (result, filter) =>
{
result.UnionWith(filter.RequiredServices);
return(result);
});
// clean up resources used by discovery
_watcher.Stop();
_watcher = null;
_reportedPeripherals.Clear();
_optionalServices = null;
}
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
ulong address = eventArgs.BluetoothAddress;
BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(address);
if (bleDevice == null)
{
return;
}
if (!isNewAddress(address))
{
return;
}
addresses.Add(address);
bleDevices.Add(bleDevice);
}
private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress);
if (device == null)
{
return;
}
// Logger.log($"BLEDevice detected. DeviceName: {device.Name}");
var targetDevice = TargetDeviceFactory.factory(device);
if (targetDevice != null)
{
Logger.log($"Device Resolved. DeviceName: {device.Name}");
this.ResolvedDevices.Add(targetDevice);
}
}
/**
* Default constructor
**/
public MainPage()
{
this.InitializeComponent();
// init beacon manager
beaconManager = new BeaconManager();
// create and start the (W10 UWP) BLE watcher
watcher = new BluetoothLEAdvertisementWatcher {
ScanningMode = BluetoothLEScanningMode.Active
};
// trigger following method when we receive data
watcher.Received += WatcherOnReceived;
// start watching
watcher.Start();
}
private void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs e)
{
_watchDog = 0; //message received
try
{
//PrintDataSections(e);
MData sections = new MData(e.Advertisement.ManufacturerData);
//PrintManufacturerData(e, sections);
ProcessManufacturerData(e, sections);
}
catch (Exception err)
{
Log.e("ERROR: " + err);
CommonTools.ErrorMessage(err.ToString(), "OnAdvertisementReceived");
}
}
private void CreateLEAdvertisementWatcher()
{
if (bluetoothLEAdvertisementWatcher == null)
{
bluetoothLEAdvertisementWatcher = new BluetoothLEAdvertisementWatcher();
}
bluetoothLEAdvertisementWatcher.AdvertisementFilter.Advertisement.ServiceUuids.Add(MakeServiceUuid(0x18F1));
bluetoothLEAdvertisementWatcher.AdvertisementFilter.Advertisement.ServiceUuids.Add(MakeServiceUuid(0x19F1));
bluetoothLEAdvertisementWatcher.SignalStrengthFilter.InRangeThresholdInDBm = -70;
bluetoothLEAdvertisementWatcher.SignalStrengthFilter.OutOfRangeThresholdInDBm = -75;
bluetoothLEAdvertisementWatcher.SignalStrengthFilter.OutOfRangeTimeout = TimeSpan.FromMilliseconds(2000);
bluetoothLEAdvertisementWatcher.ScanningMode = BluetoothLEScanningMode.Active;
bluetoothLEAdvertisementWatcher.Received += BluetoothLEAdvertisementWatcher_Received;
bluetoothLEAdvertisementWatcher.Stopped += BluetoothLEAdvertisementWatcher_Stopped;
}
protected Task StartScanningForDevicesNativeAsync(Guid[] serviceUuids, bool allowDuplicatesKey, CancellationToken scanCancellationToken)
{
_serviceUuids = serviceUuids;
_bleWatcher = new BluetoothLEAdvertisementWatcher {
ScanningMode = ScanMode.ToNative()
};
Trace.Message("Starting a scan for devices.");
_foundIds = new List <Guid>();
_bleWatcher.Received -= DeviceFoundAsync;
_bleWatcher.Received += DeviceFoundAsync;
_bleWatcher.Start();
return(Task.FromResult(true));
}
/// <summary>
/// Handler for devices found when duplicates are not allowed
/// </summary>
/// <param name="watcher">The bluetooth advertisement watcher currently being used</param>
/// <param name="btAdv">The advertisement recieved by the watcher</param>
private async void DeviceFoundAsync(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs btAdv)
{
//check if the device was already found before calling generic handler
//ensures that no device is mistakenly added twice
if (!_prevScannedDevices.Contains(btAdv.BluetoothAddress))
{
_prevScannedDevices.Add(btAdv.BluetoothAddress);
BluetoothLEDevice currDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(btAdv.BluetoothAddress);
if (currDevice != null) //make sure advertisement bluetooth address actually returns a device
{
var device = new Device(this, currDevice, btAdv.RawSignalStrengthInDBm, btAdv.BluetoothAddress.ToString(), ParseAdvertisementData(btAdv.Advertisement));
Trace.Message("DiscoveredPeripheral: {0} Id: {1}", device.Name, device.Id);
this.HandleDiscoveredDevice(device);
}
return;
}
}
/// <summary>
/// The default constructor
/// </summary>
public DnaBluetoothLEAdvertisementWatcher()
{
// Creat bluetooth listener
mWatcher = new BluetoothLEAdvertisementWatcher
{
ScanningMode = BluetoothLEScanningMode.Active
};
// Listen out for new advertisements
mWatcher.Received += WatcherAdvertisementReceived;
// Listen out for when the watcher stops listening
mWatcher.Stopped += (watcher, e) =>
{
// Inform listeners
StoppedListening();
};
}
BluetoothLEAdvertisementWatcher watcher; //Loading Bluetooth Low Energy Advertisment Driver
#endif
private void Awake()
{
BLT_Text = GetComponent <TextMeshPro>();
currentCoordinates = new List <Coordinates>();
#if WINDOWS_UWP
watcher = new BluetoothLEAdvertisementWatcher(); //Instating BLE Driver
var manufacturerData = new BluetoothLEManufacturerData // Matching ID with ANDROID Device
{
CompanyId = ANDROID_ID
};
watcher.AdvertisementFilter.Advertisement.ManufacturerData.Add(manufacturerData); // Filtering Manuf. Data with ID
watcher.ScanningMode = BluetoothLEScanningMode.Active; // Function required for HOLOLENS2
watcher.Received += Watcher_Received;
watcher.Start();
Debug.Log("Started watching");
#endif
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Debug.WriteLine("Button_Click");
if (watcher != null)
{
watcher.Stop();
}
watcher = new BluetoothLEAdvertisementWatcher();
var manufacturerData = new BluetoothLEManufacturerData
{
CompanyId = BEACON_ID
};
watcher.AdvertisementFilter.Advertisement.ManufacturerData.Add(manufacturerData);
watcher.Received += Watcher_Received;
watcher.Start();
}
private void WatcherAdvertisementReceived(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
DnaBluetoothLEDevice device = null;
var newDiscovered = !mDiscoveredDevices.ContainsKey(args.BluetoothAddress);
var nameChanged =
!newDiscovered &&
!string.IsNullOrEmpty(args.Advertisement.LocalName) &&
mDiscoveredDevices[args.BluetoothAddress].Name != args.Advertisement.LocalName;
lock (mThreadLock)
{
//Get the name of the device
var name = args.Advertisement.LocalName;
if (!string.IsNullOrEmpty(name) && !newDiscovered)
{
name = mDiscoveredDevices[args.BluetoothAddress].Name;
}
device = new DnaBluetoothLEDevice
(
address: args.BluetoothAddress,
name: name,
broadcastTime: args.Timestamp,
rssi: args.RawSignalStrengthInDBm
);
//Add/Update the device in the dictionary
mDiscoveredDevices[args.BluetoothAddress] = device;
}
DeviceDiscovered(device);
if (nameChanged)
{
DeviceNameChanged(device);
}
if (newDiscovered)
{
NewDeviceDiscovered(device);
}
}
public RoboBluetoothLEAdvertisementWatcher()
{
_watcher = new BluetoothLEAdvertisementWatcher
{
ScanningMode = BluetoothLEScanningMode.Active,
};
_watcher.Received += async(sender, args) =>
{
CleanupTimeouts();
//var info = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress);
RoboBluetoothLEDevice device = null;
var newDiscovery = !_discoverDevices.ContainsKey(args.BluetoothAddress);
var nameChanged = !newDiscovery &&
!string.IsNullOrEmpty(args.Advertisement.LocalName) &&
_discoverDevices[args.BluetoothAddress].Name != args.Advertisement.LocalName;
lock (_threadLock)
{
var name = args.Advertisement.LocalName;
if (string.IsNullOrEmpty(name) && !newDiscovery)
{
name = _discoverDevices[args.BluetoothAddress].Name;
}
device = new RoboBluetoothLEDevice
(
args.Timestamp,
args.BluetoothAddress,
name,
args.RawSignalStrengthInDBm
);
_discoverDevices[args.BluetoothAddress] = device;
}
DeviceDiscovered(device);
if (nameChanged)
{
DeviceNameChanged(device);
}
if (newDiscovery)
{
NewDeviceDiscovered(device);
}
};
_watcher.Stopped += (sender, args) => { StoppedListening(); };
}
private void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
//this.MessAgeChanged(MsgType.NotifyTxt, "发现设备FR_NAME:"+ eventArgs.Advertisement.LocalName + "BT_ADDR: " + eventArgs.BluetoothAddress);
BluetoothLEDevice.FromBluetoothAddressAsync(eventArgs.BluetoothAddress).Completed = async(asyncInfo, asyncStatus) =>
{
if (asyncStatus == AsyncStatus.Completed)
{
if (asyncInfo.GetResults() != null)
{
BluetoothLEDevice currentDevice = asyncInfo.GetResults();
Boolean contain = false;
lock (_lock)
{
foreach (BluetoothLEDevice device in DeviceList)//过滤重复的设备
{
if (device.BluetoothAddress == currentDevice.BluetoothAddress)
{
contain = true;
}
}
}
if (!contain)
{
byte[] _Bytes1 = BitConverter.GetBytes(currentDevice.BluetoothAddress);
Array.Reverse(_Bytes1);
lock (_lock)
this.DeviceList.Add(currentDevice);
string str;
if (currentDevice.DeviceInformation.Name != "")
{
str = "发现设备：" + currentDevice.DeviceInformation.Name + " - " + BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToUpper();
}
else
{
str = "发现设备：" + BitConverter.ToString(_Bytes1, 2, 6).Replace('-', ':').ToUpper();
}
this.MessAgeLog(MsgType.NotifyTxt, str);
this.DeviceScan(currentDevice);
}
}
}
};
}
private void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
ConbeeBeacon beacon = new ConbeeBeacon();
var manufacturerSections = eventArgs.Advertisement.ManufacturerData;
String datastring = "";
if (manufacturerSections.Count > 0)
{
// Only print the first one of the list
var manufacturerData = manufacturerSections[0];
var data = new byte[manufacturerData.Data.Length];
using (var reader = DataReader.FromBuffer(manufacturerData.Data))
{
reader.ReadBytes(data);
// Console.WriteLine("");
datastring = ByteArrayToString(data);
beacon = ParseConbee(data);
}
}
if ((beacon.foundDegreeRough || beacon.foundDegreeDetailed || beacon.foundLux || beacon.foundHumidity) &&
(eventArgs.BluetoothAddress.ToString("X2").StartsWith("D0") ||
eventArgs.BluetoothAddress.ToString("X2").StartsWith("FC")))
{
Console.WriteLine();
Console.WriteLine(String.Format(" {0} {1} (dBm: {2}) °C: {3} / {4} - Lux: {5} - Luftfeuchte: {6} %", DateTime.Now.ToString(), FormatMacID(eventArgs.BluetoothAddress.ToString("X2")), eventArgs.RawSignalStrengthInDBm, beacon.degreeCelsiusrough, beacon.degreeCelsiusdetailed, beacon.lux, beacon.percentHumidity));
Console.WriteLine(String.Format(" Data {0}", datastring));
}
else
{
if (eventArgs.BluetoothAddress.ToString("X2").StartsWith("D0"))
{
Console.Write(".");
}
else
{
Console.Write("?");
//Console.WriteLine(FormatMacID(eventArgs.BluetoothAddress.ToString("X2")) + " " + eventArgs.Advertisement.LocalName);
//Console.WriteLine(eventArgs.RawSignalStrengthInDBm);
}
}
}
private void Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
if (toioList.Count(t => t.Address == args.BluetoothAddress) > 0)
{
return;
}
var bleServiceUUIDs = args.Advertisement.ServiceUuids;
foreach (var uuid in bleServiceUUIDs)
{
if (uuid == Toio.ServiceUUID)
{
Task task = Task.Run(async() =>
{
BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress);
GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesForUuidAsync(Toio.ServiceUUID);
if (result.Status == GattCommunicationStatus.Success)
{
var service = result.Services[0];
Toio toio = new Toio(args.BluetoothAddress, service);
byte battery = toio.ReadBatteryLife();
lock (lockObj)
{
toioList.Add(toio);
}
if (newlyFound != null)
{
newlyFound();
}
}
//var services = await bluetoothLeDevice.GetGattServicesForUuidAsync(Toio.ServiceUUID);
});
task.Wait();
}
}
}
/// <summary>
/// Triggered when the watcher receives an advertisement.
/// If the advertisement came from a beacon, a Beacon instance is created based on the
/// received data. A new beacon is added to the list and an existing one is only updated.
/// </summary>
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
Logger.Debug("Scanner: Advertisement received " + args.Timestamp.ToString("HH:mm:ss.fff"));
Beacon beacon = BeaconFactory.BeaconFromBluetoothLeAdvertisementReceivedEventArgs(args);
if (beacon != null)
{
if (_enterDistanceThreshold != null && beacon.Distance > _enterDistanceThreshold.Value)
{
return;
}
if (!FilterBeaconByUuid(beacon))
{
return;
}
NotifyBeaconEvent(beacon);
}
}
private async void WatcherOnReceived(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
_beaconManager.ReceivedAdvertisement(eventArgs);
}
catch (ArgumentException e)
{
// Ignore for real-life scenarios.
// In some very rare cases, analyzing the data can result in an
// Argument_BufferIndexExceedsCapacity. Ignore the error here,
// assuming that the next received frame advertisement will be
// correct.
Debug.WriteLine(e);
}
});
}
private async void _watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
Debug.WriteLine($"LocalName : {args.Advertisement.LocalName}");
if (!string.IsNullOrEmpty(args.Advertisement.LocalName))
{
BleEvent(this, new BleEventArgs(args.Advertisement.LocalName));
}
if (!string.IsNullOrEmpty(_localName) && (_localName == args.Advertisement.LocalName))
{
_timer.Stop();
_watcher.Stop();
_device = await BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress);
if (_device == null)
{
BleEvent(this, new BleEventArgs(BleEventArgs.BleEventType.Error));
return;
}
var result = await _device.GetGattServicesAsync(BluetoothCacheMode.Uncached);
if (result.Status != GattCommunicationStatus.Success)
{
Disconnect();
BleEvent(this, new BleEventArgs(BleEventArgs.BleEventType.Error));
return;
}
_services = new List <GattDeviceService>();
foreach (var s in result.Services)
{
_services.Add(s);
}
_device.GattServicesChanged += _device_GattServicesChanged;
_device.ConnectionStatusChanged += _device_ConnectionStatusChanged;
IsConnected = true;
BleEvent(this, new BleEventArgs(BleEventArgs.BleEventType.Connected));
}
}
public BleScanner()
{
this.watcher = new BluetoothLEAdvertisementWatcher();
this.Advertisements = Observable
.FromEvent<TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementReceivedEventArgs>, BluetoothLEAdvertisementReceivedEventArgs>(
handler => (o, e) => handler(e), handler => this.watcher.Received += handler, handler => this.watcher.Received -= handler)
.Select(e => new BleDeviceAdvertisement(e.Advertisement, e.BluetoothAddress, e.RawSignalStrengthInDBm))
.Buffer(TimeSpan.FromSeconds(1)) // Buffer 1[s]
.SelectMany(buffer => buffer.GroupBy(advertisement => advertisement.Address).Select(group => group.First())) // Distinct by device address.
.ToReadOnlyReactiveCollection(this.resetSubject);
this.IsStopped = Observable
.FromEvent<TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementWatcherStoppedEventArgs>, BluetoothLEAdvertisementWatcherStoppedEventArgs>(
handler => (o, e) => handler(e), handler => this.watcher.Stopped += handler, handler => this.watcher.Stopped -= handler)
.Select(_ => true)
.ToReactiveProperty(true);
}
private void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
// Tell the user we see an advertisement and print some properties
/* Console.WriteLine(String.Format("Advertisement:"));
* Console.WriteLine(String.Format(" BT_ADDR: {0}", eventArgs.BluetoothAddress));
* Console.WriteLine(String.Format(" FR_NAME: {0}", eventArgs.Advertisement.ServiceUuids.FirstOrDefault()));
* List<Guid> test = eventArgs.Advertisement.ServiceUuids.ToList();*/
//Guid s = test.FirstOrDefault();
//eventArgs.Advertisement.ServiceUuids.FirstOrDefault();
System.Threading.Thread.Sleep(1000); //try 5 second lay.
//if (!isConnected)
//ConnectDevice(eventArgs.BluetoothAddress);
// Console.WriteLine();
}
private void FindBLE_Click(object sender, EventArgs e)
{
if (FindBLE.Text != "搜尋中..")
{
BleWatcher = new BluetoothLEAdvertisementWatcher
{
ScanningMode = BluetoothLEScanningMode.Active
};
BleWatcher.Received += BleWatcher_Received;
BleWatcher.Start();
FindBLE.Text = "搜尋中..";
}
else
{
FindBLE.Text = "尋找附近藍芽";
}
}
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
if ((eventArgs.BluetoothAddress != RSL10_BluetoothAddress) || (myDevice != null))
{
return;
}
BluetoothLEDevice x = await BluetoothLEDevice.FromBluetoothAddressAsync(eventArgs.BluetoothAddress);
try
{
myDevice = x;
button1.IsEnabled = true;
watcher.Stop();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Updates device metadata based on advertisement received
/// </summary>
/// <param name="sender">The Bluetooth LE Advertisement Watcher.</param>
/// <param name="args">The advertisement.</param>
private async void AdvertisementWatcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
await DispatcherQueue.ExecuteOnUIThreadAsync(
() =>
{
if (_readerWriterLockSlim.TryEnterReadLock(TimeSpan.FromSeconds(1)))
{
foreach (var device in BluetoothLeDevices)
{
if (device.BluetoothAddressAsUlong == args.BluetoothAddress)
{
device.ServiceCount = args.Advertisement.ServiceUuids.Count();
}
}
_readerWriterLockSlim.ExitReadLock();
}
}, DispatcherQueuePriority.Normal);
}
public IObservable <BluetoothLEAdvertisementReceivedEventArgs> CreateAdvertisementWatcher()
=> Observable.Create <BluetoothLEAdvertisementReceivedEventArgs>(ob =>
{
var adWatcher = new BluetoothLEAdvertisementWatcher
{
ScanningMode = BluetoothLEScanningMode.Active
};
var handler = new TypedEventHandler <BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementReceivedEventArgs>
((sender, args) => ob.OnNext(args)
);
adWatcher.Received += handler;
adWatcher.Start();
return(() =>
{
adWatcher.Stop();
adWatcher.Received -= handler;
});
});
public BeaconManagementService()
{
_dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
// Create the Bluetooth LE watcher from the Windows 10 UWP
_watcher = new BluetoothLEAdvertisementWatcher {
ScanningMode = BluetoothLEScanningMode.Active
};
// Create the Bluetooth LE publisher from the Windows 10 UWP
_publisher = new BluetoothLEAdvertisementPublisher();
// Construct the Universal Bluetooth Beacon manager
_beaconManager = new BeaconManager();
BeaconsList = _beaconManager.BluetoothBeacons;
_resourceLoader = ResourceLoader.GetForCurrentView();
StartScanning();
}
private async void Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
var manufacturerData = args.Advertisement.ManufacturerData;
if (manufacturerData.Any())
{
var manufacturerDataSection = manufacturerData[0];
var data = new byte[manufacturerDataSection.Data.Length];
using (var reader = DataReader.FromBuffer(manufacturerDataSection.Data))
{
reader.ReadBytes(data);
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
this.Rssi = (int)args.RawSignalStrengthInDBm;
this.BeaconData = BitConverter.ToString(data);
});
}
}
public String Start(UInt16 manufacturerId, UInt16 beaconCode)
{
try {
Stop();
_Watcher = new BluetoothLEAdvertisementWatcher();
_Watcher.Stopped += _Watcher_Stopped;
_Watcher.Received += _Watcher_Received;
if (manufacturerId != 0 && beaconCode != 0){
BluetoothLEManufacturerData manufacturerData = BeaconFactory.BeaconManufacturerData(manufacturerId, beaconCode);
_Watcher.AdvertisementFilter.Advertisement.ManufacturerData.Add(manufacturerData);
}
_Watcher.Start();
}catch (Exception ex){
return ex.Message;
}
return null;
}
public MainPage()
{
this.InitializeComponent();
// Create and initialize a new watcher instance.
watcher = new BluetoothLEAdvertisementWatcher();
// Monitor all iBeacons advertisment
watcher.AdvertisementFilter.Advertisement.iBeaconSetAdvertisement(new iBeaconData());
//// Monitor all iBeacons with UUID
//watcher.AdvertisementFilter.Advertisement.SetiBeaconAdvertismentManufacturerData(
// new iBeaconData()
// {
// UUID = Guid.Parse("{307f40b9-f8f5-6e46-aff9-25556b57fe6d}")
// });
//// Monitor all iBeacons with UUID and Major
//watcher.AdvertisementFilter.Advertisement.SetiBeaconAdvertismentManufacturerData(
// new iBeaconData()
// {
// UUID = Guid.Parse("{307f40b9-f8f5-6e46-aff9-25556b57fe6d}"),
// Major = 18012
// });
//// Monitor all iBeacons with UUID and Major
//watcher.AdvertisementFilter.Advertisement.SetiBeaconAdvertismentManufacturerData(
// new iBeaconData()
// {
// UUID = Guid.Parse("{307f40b9-f8f5-6e46-aff9-25556b57fe6d}"),
// Major = 18012,
// Minor = 1040
// });
beacons = new ObservableCollection<iBeaconData>();
this.DataContext = beacons;
}
/// <summary>
/// Invoked as an event handler when an advertisement is received.
/// </summary>
/// <param name="watcher">Instance of watcher that triggered the event.</param>
/// <param name="eventArgs">Event data containing information about the advertisement event.</param>
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
// We can obtain various information about the advertisement we just received by accessing
// the properties of the EventArgs class
var newDevice = new BluetoothLEAdvertismentViewModel(eventArgs);
BluetoothLEAdvertismentViewModel oldDevice = null;
_table.TryGetValue(newDevice.Address, out oldDevice);
_table[newDevice.Address] = newDevice;
// Notify the user that the watcher was stopped
await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
if (oldDevice != null)
{
_devices.Remove(oldDevice);
}
_devices.Add(newDevice);
});
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (this.Frame.CanGoBack)
{
SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility = AppViewBackButtonVisibility.Visible;
SystemNavigationManager.GetForCurrentView().BackRequested += Publish_BackRequested;
}
this.watcher = new BluetoothLEAdvertisementWatcher();
var manufacturerDataWriter = new DataWriter();
manufacturerDataWriter.WriteUInt16(0x1234);
var manufacturerData = new BluetoothLEManufacturerData
{
CompanyId = 0xFFFE,
Data = manufacturerDataWriter.DetachBuffer()
};
this.watcher.AdvertisementFilter.Advertisement.ManufacturerData.Add(manufacturerData);
watcher.Received += Watcher_Received;
watcher.Start();
}
public ImbleWatcher()
{
this.watcher = new BluetoothLEAdvertisementWatcher();
this.watcher.ScanningMode = BluetoothLEScanningMode.Active; // We have to perform active scanning to check scan responses from devices.
this.resetSubject = new Subject<Unit>().AddTo(this.disposables);
var candidateAddresses = new ConcurrentDictionary<ulong, ulong>();
var resetObservable = this.resetSubject
.Do(_ => candidateAddresses.Clear());
var receivedObservable = Observable.FromEvent<TypedEventHandler<BluetoothLEAdvertisementWatcher, BluetoothLEAdvertisementReceivedEventArgs>, BluetoothLEAdvertisementReceivedEventArgs>(
handler => (sender, args) => handler(args),
handler => this.watcher.Received += handler,
handler => this.watcher.Received -= handler)
.Publish();
// Check scan responses and add their address to the candidate device list if they contains the target service UUID as Service Solicitation data.
receivedObservable
.Where(args => args.AdvertisementType.HasFlag(BluetoothLEAdvertisementType.ScanResponse))
.Where(args => args.Advertisement.DataSections.Any(section => MatchSolicitationServiceLong(section, ImbleDevice.ServiceUuid)))
.Subscribe(args => candidateAddresses.TryAdd(args.BluetoothAddress, args.BluetoothAddress))
.AddTo(this.disposables);
// Check advertisement data
this.UnconnectedDevices = receivedObservable
.Where(args => !args.AdvertisementType.HasFlag(BluetoothLEAdvertisementType.ScanResponse))
.Where(args => candidateAddresses.ContainsKey(args.BluetoothAddress))
.Distinct(args => args.BluetoothAddress)
.Select(args => new UnconnectedImbleDevice(args.BluetoothAddress, args.Advertisement, args.RawSignalStrengthInDBm))
.ToReadOnlyReactiveCollection(resetObservable)
.AddTo(this.disposables);
receivedObservable.Connect().AddTo(this.disposables);
this.watcher.Start();
}
/// <summary>
/// Invoked as an event handler when the watcher is stopped or aborted.
/// </summary>
/// <param name="watcher">Instance of watcher that triggered the event.</param>
/// <param name="eventArgs">Event data containing information about why the watcher stopped or aborted.</param>
private async void OnAdvertisementWatcherStopped(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementWatcherStoppedEventArgs eventArgs)
{
// Notify the user that the watcher was stopped
}
private void WatcherOnStopped(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementWatcherStoppedEventArgs args)
{
string errorMsg = null;
if (args != null)
{
switch (args.Error)
{
case BluetoothError.Success:
errorMsg = "WatchingSuccessfullyStopped";
break;
case BluetoothError.RadioNotAvailable:
errorMsg = "ErrorNoRadioAvailable";
break;
case BluetoothError.ResourceInUse:
errorMsg = "ErrorResourceInUse";
break;
case BluetoothError.DeviceNotConnected:
errorMsg = "ErrorDeviceNotConnected";
break;
case BluetoothError.DisabledByPolicy:
errorMsg = "ErrorDisabledByPolicy";
break;
case BluetoothError.NotSupported:
errorMsg = "ErrorNotSupported";
break;
}
}
if (errorMsg == null)
{
// All other errors - generic error message
errorMsg = _restartingBeaconWatch
? "FailedRestartingBluetoothWatch"
: "AbortedWatchingBeacons";
}
SetStatusOutput(_resourceLoader.GetString(errorMsg));
}
/// <summary>
/// Invoked as an event handler when an advertisement is received.
/// </summary>
/// <param name="watcher">Instance of watcher that triggered the event.</param>
/// <param name="eventArgs">Event data containing information about the advertisement event.</param>
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
// We can obtain various information about the advertisement we just received by accessing
// the properties of the EventArgs class
// The timestamp of the event
DateTimeOffset timestamp = eventArgs.Timestamp;
// The type of advertisement
BluetoothLEAdvertisementType advertisementType = eventArgs.AdvertisementType;
// The received signal strength indicator (RSSI)
Int16 rssi = eventArgs.RawSignalStrengthInDBm;
// The local name of the advertising device contained within the payload, if any
string localName = eventArgs.Advertisement.LocalName;
// Get iBeacon specific data
var beaconData = eventArgs.Advertisement.iBeaconParseAdvertisement(eventArgs.RawSignalStrengthInDBm);
if (beaconData == null)
return;
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
var existing = beacons.Where(b => b.UUID == beaconData.UUID && b.Major == beaconData.Major && b.Minor == beaconData.Minor).FirstOrDefault();
if (existing != null)
{
var idx = beacons.IndexOf(existing);
beacons.RemoveAt(idx);
beacons.Insert(idx, beaconData);
}
else
beacons.Add(beaconData);
});
}
/// <summary>
/// Invoked as an event handler when the watcher is stopped or aborted.
/// </summary>
/// <param name="watcher">Instance of watcher that triggered the event.</param>
/// <param name="eventArgs">Event data containing information about why the watcher stopped or aborted.</param>
private async void OnAdvertisementWatcherStopped(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementWatcherStoppedEventArgs eventArgs)
{
// Notify the user that the watcher was stopped
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser(string.Format("Watcher stopped or aborted: {0}", eventArgs.Error.ToString()), NotifyType.StatusMessage);
});
}
/// <summary>
/// Invoked as an event handler when an advertisement is received.
/// </summary>
/// <param name="watcher">Instance of watcher that triggered the event.</param>
/// <param name="eventArgs">Event data containing information about the advertisement event.</param>
private async void OnAdvertisementReceived(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
// We can obtain various information about the advertisement we just received by accessing
// the properties of the EventArgs class
// The timestamp of the event
DateTimeOffset timestamp = eventArgs.Timestamp;
// The type of advertisement
BluetoothLEAdvertisementType advertisementType = eventArgs.AdvertisementType;
// The received signal strength indicator (RSSI)
Int16 rssi = eventArgs.RawSignalStrengthInDBm;
// The local name of the advertising device contained within the payload, if any
string localName = eventArgs.Advertisement.LocalName;
// Check if there are any manufacturer-specific sections.
// If there is, print the raw data of the first manufacturer section (if there are multiple).
string manufacturerDataString = "";
var manufacturerSections = eventArgs.Advertisement.ManufacturerData;
if (manufacturerSections.Count > 0)
{
// Only print the first one of the list
var manufacturerData = manufacturerSections[0];
var data = new byte[manufacturerData.Data.Length];
using (var reader = DataReader.FromBuffer(manufacturerData.Data))
{
reader.ReadBytes(data);
}
// Print the company ID + the raw data in hex format
manufacturerDataString = string.Format("0x{0}: {1}",
manufacturerData.CompanyId.ToString("X"),
BitConverter.ToString(data));
}
// Serialize UI update to the main UI thread
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
// Display these information on the list
ReceivedAdvertisementListBox.Items.Add(string.Format("[{0}]: type={1}, rssi={2}, name={3}, manufacturerData=[{4}]",
timestamp.ToString("hh\\:mm\\:ss\\.fff"),
advertisementType.ToString(),
rssi.ToString(),
localName,
manufacturerDataString));
});
}
/// <summary>
/// Invoked as an event handler when the watcher is stopped or aborted.
/// </summary>
/// <param name="watcher">Instance of watcher that triggered the event.</param>
/// <param name="eventArgs">Event data containing information about why the watcher stopped or aborted.</param>
private void OnAdvertisementWatcherStopped(BluetoothLEAdvertisementWatcher watcher, BluetoothLEAdvertisementWatcherStoppedEventArgs eventArgs)
{
// Notify the user that the watcher was stopped
NotifyUser(string.Format("Watcher stopped or aborted: {0}", eventArgs.Error.ToString()), NotifyType.StatusMessage);
}
private async void WatcherOnReceived(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs eventArgs)
{
await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
_beaconManager.ReceivedAdvertisement(eventArgs);
}
catch (ArgumentException e)
{
// Ignore for real-life scenarios.
// In some very rare cases, analyzing the data can result in an
// Argument_BufferIndexExceedsCapacity. Ignore the error here,
// assuming that the next received frame advertisement will be
// correct.
Debug.WriteLine(e);
}
});
}
private void _Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
if (Discovered != null){
Discovered(args);
}
}
public void Start()
{
// Construct the Universal Bluetooth Beacon manager
_beaconManager = new BeaconManager();
// Create & start the Bluetooth LE watcher from the Windows 10 UWP
_watcher = new BluetoothLEAdvertisementWatcher {ScanningMode = BluetoothLEScanningMode.Active};
_watcher.Received += WatcherOnReceived;
_watcher.Start();
}
