public bool ConnectUEI(string address) { int ndx = addressList.IndexOf(address); rssi = ndx >= 0 ? (int)(short)rssiList[ndx] : 1; string addrStr = "0x"; for (int i = 0; i < 18; i += 3) { addrStr += address.Substring(i, 2); } ulong addrVal = Convert.ToUInt64(addrStr, 16); var selector = BluetoothLEDevice.GetDeviceSelectorFromBluetoothAddress(addrVal, BluetoothAddressType.Public); var deviceWatcher = DeviceInformation.CreateWatcher(selector); deviceWatcher.Added += DeviceWatcher_Added; deviceWatcher.Removed += DeviceWatcher_Removed; stage = 1; done = false; deviceWatcher.Start(); while (!done) { } ; stage = 2; if (bleDevice != null) { bleDevice.ConnectionStatusChanged += BleDevice_ConnectionStatusChanged; } return(bleDevice != null); }
public async Task FindDevice(ulong address) { BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(address); if (device != null) { Device = device; } string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" }; DeviceWatcher deviceWatcher = DeviceInformation.CreateWatcher( BluetoothLEDevice.GetDeviceSelectorFromBluetoothAddress(address), requestedProperties); deviceWatcher.Added += DeviceWatcher_Added; deviceWatcher.Removed += DeviceWatcher_Removed; deviceWatcher.Updated += DeviceWatcher_Updated; deviceWatcher.Start(); Device = await BluetoothLEDevice.FromBluetoothAddressAsync(address); if (Device == null) { throw new KeyNotFoundException(); } }
/// <summary> /// Initialize the device. /// </summary> /// <param name="deviceInformation">An instance of DeviceInformation class corresponding to the BluetoothLEDevice.</param> /// <param name="bluetoothAddress">The bluetooth address of the device.</param> /// <param name="cancellationToken"></param> /// <returns></returns> private async Task Initialize(DeviceInformation deviceInformation, ulong bluetoothAddress, CancellationToken cancellationToken) { if (deviceInformation.Pairing.IsPaired) { // If the device is paired, all we have to do is just getting BluetoothLEDevice object by its ID. this.bleDevice = (await BluetoothLEDevice.FromIdAsync(deviceInformation.Id)).AddTo(this.disposables); this.service = this.bleDevice.GetGattService(ServiceUuid).AddTo(this.disposables); } else { // If the device is not paired, pair with the device. var result = await deviceInformation.Pairing.PairAsync(DevicePairingProtectionLevel.None); switch (result.Status) { case DevicePairingResultStatus.Paired: // The device has been paired successfully. break; default: throw new ImbleOperationException("Failed to pair with the device."); } // After the PairAsync method returns, we have to wait until the device paired is registered to the system. var selector = BluetoothLEDevice.GetDeviceSelectorFromBluetoothAddress(bluetoothAddress); var watcher = DeviceInformation.CreateWatcher(selector); var deviceAddedTask = EventSubscription.ReceiveFirst <DeviceWatcher, DeviceInformation>(handler => watcher.Added += handler, handler => watcher.Added -= handler, cancellationToken); watcher.Start(); var bleDeviceInformation = await deviceAddedTask; // Wait until the target device is added. watcher.Stop(); this.bleDevice = (await BluetoothLEDevice.FromIdAsync(bleDeviceInformation.Id)).AddTo(this.disposables); var gattServiceChangedTask = EventSubscription.ReceiveFirst <BluetoothLEDevice, object>(handler => this.bleDevice.GattServicesChanged += handler, handler => this.bleDevice.GattServicesChanged -= handler, cancellationToken); this.service = this.bleDevice.GetGattService(ServiceUuid); if (this.service == null) { // If the GATT services have not been enumerated yet, wait until the enumeration completes. await gattServiceChangedTask; this.service = this.bleDevice.GetGattService(ServiceUuid); } } // Get the READ characteristic in the IMBLE service. this.readCharacteristic = this.service.GetCharacteristics(ReadCharacteristicUuid).Single(); EventSubscription.Subscribe <GattCharacteristic, GattValueChangedEventArgs>( handler => this.readCharacteristic.ValueChanged += handler, handler => this.readCharacteristic.ValueChanged -= handler, (sender, args) => { if (args.CharacteristicValue.Length < 4) { return; // The length of data is too short. } var data = args.CharacteristicValue.ToArray(); var length = data[0] + 1; if (data.Length < length) { return; // The length field is invalid. Ignore this data. } var body = new byte[length - 4]; Array.Copy(data, 4, body, 0, body.Length); this.DataArrived?.Invoke(this, new DataArrivedEventArgs(body, args.Timestamp)); }) .AddTo(this.disposables); // Enable notification of the READ characteristic. var readCccdResult = await this.readCharacteristic.ReadClientCharacteristicConfigurationDescriptorAsync().AsTask(cancellationToken); var readCccd = readCccdResult.ClientCharacteristicConfigurationDescriptor | GattClientCharacteristicConfigurationDescriptorValue.Notify; for (var retryCount = 0;; retryCount++) { try { using (var timeoutCancel = new CancellationTokenSource(TimeSpan.FromSeconds(5))) using (var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCancel.Token)) { await this.readCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(readCccd).AsTask(linkedTokenSource.Token); } break; } catch (Exception ex) { if (retryCount > 3) { throw new ImbleOperationException("Failed to configure the device.", ex); } } } this.writeCharacteristic = this.service.GetCharacteristics(WriteCharacteristicUuid).Single(); EventSubscription.Subscribe <TypedEventHandler <BluetoothLEDevice, object> >( handler => this.bleDevice.ConnectionStatusChanged += handler, handler => this.bleDevice.ConnectionStatusChanged -= handler, (device, _) => { this.ConnectionStatus = device.ConnectionStatus; }) .AddTo(this.disposables); this.ConnectionStatus = this.service.Device.ConnectionStatus; this.Status = ImbleDeviceStatus.Running; }