/// <summary>
/// Registers characteristic handlers for the device driver module service.
/// </summary>
/// <param name="service"></param>
private async Task RegisterDeviceModuleDriverServiceCharacteristicsAsync(GattDeviceService service)
{
//Getting the characteristics of the service.
GattCharacteristicsResult results = await service.GetCharacteristicsAsync();
if (results.Status == GattCommunicationStatus.Success)
{
foreach (GattCharacteristic characteristic in results.Characteristics)
{
if (characteristic.Uuid == DEVICE_BATTERY_WRITE_CHARACTERISTIC_UUID)
{
//Caching the device module driver
deviceModuleDriverReadWriteCharacteristic = characteristic;
//Registering block state changed indicator.
GattCommunicationStatus commStatus = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
if (commStatus == GattCommunicationStatus.Success)
{
characteristic.ValueChanged += OnDeviceBatteryInfoUpdated;
Console.WriteLine("Successfully registered notify for battery read.");
}
else
{
OnConnectionError(commStatus);
}
}
}
}
else
{
OnConnectionError(results.Status);
}
}
/// <summary>
/// Retrieves the characteristics of the given service.
/// The error logging is handled in the function.
/// </summary>
/// <param name="service"></param>
/// <returns>The list of characteristic if it succeed, null otherwise</returns>
public static async Task <IReadOnlyList <GattCharacteristic> > GetCharacteristics(GattDeviceService service)
{
try
{
DeviceAccessStatus status = await service.RequestAccessAsync();
if (status == DeviceAccessStatus.Allowed)
{
GattCharacteristicsResult result = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
return(result.Characteristics);
}
else
{
LogHelper.Error("Error accessing device");
return(null);
}
}
else
{
LogHelper.Error("Error accessing device: access not granted");
return(null);
}
}
catch (Exception e)
{
LogHelper.Error("Restricted service. Can't read characteristics: " + e.Message);
return(null);
}
}
/// <summary>
/// Get the list of the GATT characteristics included in a specific GATT service
/// </summary>
/// <returns>List of the included GATT characteristics</returns>
public async Task <IList <BleGattCharacteristic> > GetCharacteristicsAsync(BleGattService service)
{
List <BleGattCharacteristic> characteristics = new List <BleGattCharacteristic>();
GattDeviceService gatt_service = service.Context as GattDeviceService;
GattCharacteristicsResult result = await gatt_service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);
foreach (GattCharacteristic characteristic in result.Characteristics)
{
BleGattCharacteristic ble_characteristic = new BleGattCharacteristic();
ble_characteristic.Name = "";
ble_characteristic.Guid = characteristic.Uuid;
ble_characteristic.Context = characteristic;
ble_characteristic.CanRead = characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Read);
ble_characteristic.CanWrite = ((characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write)) ||
(characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.WriteWithoutResponse)));
ble_characteristic.CanNotify = ((characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify)) ||
(characteristic.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Indicate)));
characteristics.Add(ble_characteristic);
_ble_characteristics.Add(characteristic, ble_characteristic);
}
return(characteristics);
}
/// <summary>
/// Registers characteristic handlers for the device data service.
/// </summary>
/// <param name="service"></param>
private async Task RegisterDataServiceCharacteristicsAsync(GattDeviceService service)
{
//Getting the characteristics of the service.
GattCharacteristicsResult results = await service.GetCharacteristicsAsync();
if (results.Status == GattCommunicationStatus.Success)
{
foreach (GattCharacteristic characteristic in results.Characteristics)
{
if (characteristic.Uuid == DEVICE_DATA_READ_CHARACTERISTIC_UUID)
{
//Registering block state changed indicator.
GattCommunicationStatus commStatus = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
if (commStatus == GattCommunicationStatus.Success)
{
characteristic.ValueChanged += OnBlockStateInfoUpdate;
Console.WriteLine("Successfully registered notify for data read.");
}
else
{
OnConnectionError(commStatus);
}
}
}
}
else
{
OnConnectionError(results.Status);
}
}
public async Task FindAllServices(GattDeviceService service)
{
try
{
IReadOnlyList <GattCharacteristic> characteristics = null;
var accessStatus = await service.RequestAccessAsync();
if (accessStatus == DeviceAccessStatus.Allowed)
{
var result = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
characteristics = result.Characteristics;
}
else
{
// On error, act as if there are no characteristics.
characteristics = new List <GattCharacteristic>();
}
foreach (GattCharacteristic c in characteristics)
{
// add to a list
}
}
}
catch
{
}
}
private async Task DiscoverControlCharacteristics()
{
if (_controlService != null)
{
var characteristicsResult = await _controlService.GetCharacteristicsAsync();
foreach (var characteristic in characteristicsResult.Characteristics)
{
if (characteristic.Uuid == MyoInfoCharacteristicUUID)
{
_myoInfoCharacteristic = characteristic;
}
else if (characteristic.Uuid == FirmwareVersionCharacteristicUUID)
{
_firmwareVersionCharacteristic = characteristic;
}
else if (characteristic.Uuid == CommandCharacteristicUUID)
{
_commandCharacteristic = characteristic;
}
}
}
else
{
Debug.LogError("Control Service is missing!");
}
}
private async Task DiscoverEmgDataCharacteristics()
{
if (_emgDataService != null)
{
var characteristicsResult = await _emgDataService.GetCharacteristicsAsync();
foreach (var characteristic in characteristicsResult.Characteristics)
{
if (characteristic.Uuid == EmgData0CharacteristicUUID)
{
_emgData0Characteristic = characteristic;
}
else if (characteristic.Uuid == EmgData1CharacteristicUUID)
{
_emgData1Characteristic = characteristic;
}
else if (characteristic.Uuid == EmgData2CharacteristicUUID)
{
_emgData2Characteristic = characteristic;
}
else if (characteristic.Uuid == EmgData3CharacteristicUUID)
{
_emgData3Characteristic = characteristic;
}
}
}
else
{
Debug.LogError("EMG Data Service is missing!");
}
}
/// <summary>
/// Add a service (and it's included services, characteristics, and descriptors) to the lists
/// </summary>
/// <param name="service">The service to add</param>
private async Task AddService(GattDeviceService service)
{
if (!serviceObjects.Contains(service))
{
GattDeviceServicesResult res = await service.GetIncludedServicesAsync();
if (res.Status == GattCommunicationStatus.Success)
{
foreach (GattDeviceService s in res.Services)
{
await AddService(s);
}
}
GattCharacteristicsResult charRes = await service.GetCharacteristicsAsync();
if (charRes.Status == GattCommunicationStatus.Success)
{
foreach (GattCharacteristic c in charRes.Characteristics)
{
GattDescriptorsResult descRes = await c.GetDescriptorsAsync();
if (descRes.Status == GattCommunicationStatus.Success)
{
foreach (GattDescriptor d in descRes.Descriptors)
{
descriptorObjects.Add(d);
}
}
characteristicObjects.Add(c);
}
}
serviceObjects.Add(service);
}
}
private void GetCharacteristics()
{
_Service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached)
.AsTask()
.ContinueWith(async r3 =>
{
_Characteristics = r3.Result.Characteristics.ToList();
if (_Characteristics?.Count != 4)
{
Thread.Sleep(300);
GetCharacteristics();
}
else
{
_WriteChar = _Characteristics.First(c => c.Uuid == WriteCharUUID);
_ReadChar = _Characteristics.First(c => c.Uuid == ReadCharUUID);
_NotifyChar = _Characteristics.First(c => c.Uuid == NotifyCharUUID);
_ReadChar.ValueChanged += _Read;
_NotifyChar.ValueChanged += _Read;
await _ReadChar.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
await _NotifyChar.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
}
})
.Wait();
}
/// <summary>
/// Get GATT characteristic by service UUID.
/// Returns <see cref="GattCharacteristic"/>'s default in case of "Access denied" or "Service not found".
/// </summary>
/// <param name="service">GATT Service</param>
/// <param name="characteristicUuid">GATT Characteristic UUID</param>
/// <returns>GattCharacteristic object if characteristic is exists, else returns null</returns>
public static async Task <GattCharacteristic> GetCharacteristicFromUuid(GattDeviceService service,
Guid characteristicUuid)
{
GattCharacteristicsResult currentResult = await service.GetCharacteristicsAsync();
return(currentResult.Characteristics.FirstOrDefault(characteristic =>
characteristic.Uuid == characteristicUuid));
}
public async Task <GattCharacteristic> GetCharacteristic(GattDeviceService service)
{
var characteristics = await service.GetCharacteristicsAsync();
var characteristic = characteristics.Characteristics.Single(c => c.Uuid == new Guid("00001624-1212-efde-1623-785feabcd123"));
return(characteristic);
}
//public IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
public async Task Init(GattDeviceService service)
{
var characteristics = await service.GetCharacteristicsAsync(); //NOTE: cache mode?
foreach (var characteristic in characteristics.Characteristics)
{
}
}
/// <summary>
/// Gets all the characteristics of this service
/// </summary>
private async Task GetAllCharacteristics()
{
StringBuilder sb = new StringBuilder();
sb.Append("ObservableGattDeviceService::getAllCharacteristics: ");
sb.Append(name);
try
{
// Request the necessary access permissions for the service and abort
// if permissions are denied.
GattOpenStatus status = await service.OpenAsync(GattSharingMode.SharedReadAndWrite);
if (status != GattOpenStatus.Success && status != GattOpenStatus.AlreadyOpened)
{
string error = " - Error: " + status.ToString();
Name += error;
sb.Append(error);
Debug.WriteLine(sb.ToString());
return;
}
GattCharacteristicsResult result = await service.GetCharacteristicsAsync(Services.SettingsServices.SettingsService.Instance.UseCaching?BluetoothCacheMode.Cached : BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
sb.Append(" - getAllCharacteristics found ");
sb.Append(result.Characteristics.Count());
sb.Append(" characteristics");
Debug.WriteLine(sb);
foreach (GattCharacteristic gattchar in result.Characteristics)
{
ObservableGattCharacteristics temp = new ObservableGattCharacteristics(gattchar, this);
await temp.Initialize();
Characteristics.Add(temp);
}
}
else if (result.Status == GattCommunicationStatus.Unreachable)
{
sb.Append(" - getAllCharacteristics failed with Unreachable");
Debug.WriteLine(sb.ToString());
}
else if (result.Status == GattCommunicationStatus.ProtocolError)
{
sb.Append(" - getAllCharacteristics failed with Unreachable");
Debug.WriteLine(sb.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("getAllCharacteristics: Exception - {0}" + ex.Message);
Name += " - Exception: " + ex.Message;
}
}
//Get all the characteristics of this service
private async void GetAllCharacteristics()
{
Console.WriteLine("ObservableGattDeviceService::getAllCharacteristics: ");
try
{
//Request the necessary access permission for the service and abort if permissions are denied
GattOpenStatus status = await service.OpenAsync(GattSharingMode.SharedReadAndWrite);
if (status != GattOpenStatus.Success && status != GattOpenStatus.AlreadyOpened)
{
Console.WriteLine("Error: " + status.ToString());
return;
}
CancellationTokenSource tokenSource = new CancellationTokenSource(5000);
var task = Task.Run(() => service.GetCharacteristicsAsync(Windows.Devices.Bluetooth.BluetoothCacheMode.Uncached), tokenSource.Token);
GattCharacteristicsResult result = null;
result = await task.Result;
if (result.Status == GattCommunicationStatus.Success)
{
Console.WriteLine("getAllCharacteristics found " + result.Characteristics.Count() + " characteristics");
foreach (GattCharacteristic gattChar in result.Characteristics)
{
characteristics.Add(new ObservableGattCharacteristics(gattChar, this));
}
}
else if (result.Status == GattCommunicationStatus.Unreachable)
{
Console.WriteLine("getAllCharacteristics failed with Unreachable");
}
else if (result.Status == GattCommunicationStatus.ProtocolError)
{
Console.WriteLine("getAllCharacteristics failed with Unreachable");
}
}
catch (AggregateException ae)
{
foreach (var ex in ae.InnerExceptions)
{
if (ex is TaskCanceledException)
{
Console.WriteLine("Getting characteristics took too long. Timed out.");
return;
}
}
}
catch (Exception ex)
{
Console.WriteLine("getAllCharacteristics: Exception: " + ex.Message);
throw;
}
}
async void Build(ChangeEvent pEvent)
{
mCharacteristics = null;
mCharacteristics = new List <ICharacteristicBLE>();
await mService.GetCharacteristicsAsync().AsTask().ContinueWith((arg) =>
{
Debug.WriteLine("Found Characteristics.");
CharacteristicsAquired(arg.Result, pEvent);
});
}
public static async Task <IReadOnlyList <GattCharacteristic> > GetCharacteristics2Async(this GattDeviceService service)
{
var result = await service.GetCharacteristicsAsync();
if (result.Status != GattCommunicationStatus.Success)
{
throw new Exception("Could not get characteristics from service");
}
return(result.Characteristics);
}
//MOSTRA LE CARATTERISTICHE DEL SERVIZIO HR
private async void servizi()
{
GattDeviceService HRservice = BluetoothDevice.GetGattService(HRserviceGuid);
GattCharacteristicsResult HRcharacteristics = await HRservice.GetCharacteristicsAsync();
foreach (GattCharacteristic caratteristica in HRcharacteristics.Characteristics.Where(caratteristica => caratteristica.AttributeHandle == 36)) //13
{
HRreader = caratteristica;
OutputList.Items.Insert(0, "Servizio HR trovato in" + HRreader.CharacteristicProperties.ToString());
}
}
protected async override Task <IList <ICharacteristic> > GetCharacteristicsNativeAsync()
{
var nativeChars = (await _nativeService.GetCharacteristicsAsync()).Characteristics;
var charList = new List <ICharacteristic>();
foreach (var nativeChar in nativeChars)
{
var characteristic = new Characteristic(nativeChar, this);
charList.Add(characteristic);
}
return(charList);
}
/// <summary>Build the GATT service data model</summary>
/// <param name="service">The OS GATT service object</param>
/// <param name="deviceDataModel">The portable GATT session data model</param>
/// <returns>The async task</returns>
public async Task BuildServiceDataModel(GattDeviceService service, BluetoothLEDeviceInfo deviceDataModel)
{
this.log.Info("BuildServiceDataModel", () => string.Format("Gatt Service:{0} Uid:{1}",
BLE_DisplayHelpers.GetServiceName(service), service.Uuid.ToString()));
// New service data model to add to device info
BLE_ServiceDataModel serviceDataModel = new BLE_ServiceDataModel()
{
Characteristics = new Dictionary <string, BLE_CharacteristicDataModel>(),
AttributeHandle = service.AttributeHandle,
DeviceId = deviceDataModel.Id,
DisplayName = BLE_DisplayHelpers.GetServiceName(service),
Uuid = service.Uuid,
SharingMode = (BLE_SharingMode)service.SharingMode,
};
if (service.DeviceAccessInformation != null)
{
serviceDataModel.DeviceAccess = (BLE_DeviceAccessStatus)service.DeviceAccessInformation.CurrentStatus;
}
this.BuildSessionDataModel(service.Session, serviceDataModel.Session);
// TODO
//service.ParentServices
// Get the characteristics for the service
GattCharacteristicsResult characteristics = await service.GetCharacteristicsAsync();
if (characteristics.Status == GattCommunicationStatus.Success)
{
if (characteristics.Characteristics != null)
{
if (characteristics.Characteristics.Count > 0)
{
foreach (GattCharacteristic ch in characteristics.Characteristics)
{
await this.BuildCharacteristicDataModel(ch, serviceDataModel);
}
}
else
{
this.log.Info("ConnectToDevice", () => string.Format("No characteristics"));
}
}
}
else
{
this.log.Error(9999, "HarvestDeviceInfo", () => string.Format("Failed to get Characteristics result {0}", characteristics.Status.ToString()));
}
// Add the service data model to the device info data model
deviceDataModel.Services.Add(serviceDataModel.Uuid.ToString(), serviceDataModel);
}
private static async Task <BleGattService> ExtractDomainModel(GattDeviceService gattDeviceService)
{
var srvChars = await gattDeviceService.GetCharacteristicsAsync(BluetoothCacheMode.Cached);
return(new BleGattService
{
Uuid = gattDeviceService.Uuid,
DeviceId = gattDeviceService.Session?.DeviceId?.Id ?? string.Empty,
Characteristics = srvChars.Characteristics.AsEnumerable()
.Select(sc => new BleGattCharacteristic(sc.Uuid, sc.UserDescription)).ToArray()
});
}
private async void Get_Characteriisics(GattDeviceService myService)
{
var CharResult = await myService.GetCharacteristicsAsync();
if (CharResult.Status == GattCommunicationStatus.Success)
{
foreach (GattCharacteristic c in CharResult.Characteristics)
{
if (c.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify))
{
selectedCharacteristic = c;
break;
}
}
try
{
// Write the ClientCharacteristicConfigurationDescriptor in order for server to send notifications.
var result = await selectedCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify);
if (result == GattCommunicationStatus.Success)
{
var dialogNotifications = new MessageDialog("Successfully registered for notifications");
await dialogNotifications.ShowAsync();
selectedCharacteristic.ValueChanged += SelectedCharacteristic_ValueChanged;
}
else
{
var dialogNotifications = new MessageDialog($"Error registering for notifications: {result}");
await dialogNotifications.ShowAsync();
}
}
catch (Exception ex)
{
// This usually happens when not all characteristics are found
// or selected characteristic has no Notify.
var dialogNotifications = new MessageDialog(ex.Message);
await dialogNotifications.ShowAsync();
await Task.Delay(100);
Get_Characteriisics(myService); //try again
//!!! Add a max try counter to prevent infinite loop!!!!!!!
}
}
else
{
var dialogNotifications = new MessageDialog("Restricted service. Can't read characteristics");
await dialogNotifications.ShowAsync();
}
}
private async Task <IReadOnlyList <GattCharacteristic> > GetCharacteristics(GattDeviceService service)
{
if (service != null)
{
var characteristicsResult = await service.GetCharacteristicsAsync();
if (characteristicsResult.Status == GattCommunicationStatus.Success)
{
return(characteristicsResult.Characteristics);
}
}
return(null);
}
private async void AchieveCharateristic(GattDeviceService service)
{
var result = await service.GetCharacteristicsAsync();
var characteristics = result.Characteristics;
_ListCharacteristics = new ObservableCollection <GattCharacteristicModel>();
foreach (var characteristic in characteristics)
{
Debug.WriteLine(characteristic.Service.Uuid + ": " + characteristic.Uuid);
_ListCharacteristics.Add(new GattCharacteristicModel(characteristic));
}
lvBTDevice.ItemsSource = _ListCharacteristics;
}
private async void ListCharactericsButton_Click(object sender, RoutedEventArgs e)
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => listView.Items.Clear());
service = ((GattDeviceServiceListItem)selectedListItem).service;
var characteristics = await service.GetCharacteristicsAsync();
foreach (GattCharacteristic characteristic in characteristics.Characteristics)
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => listView.Items.Add(new GattCharacteristicListItem(characteristic)));
Debug.WriteLine($"Characteristic UUID: {characteristic.Uuid}");
}
}
private static async void GetCharacteristics(GattDeviceService service)
{
IReadOnlyList <GattCharacteristic> characteristics = null;
string device = service.Device.DeviceInformation.Id.Substring(41);
try
{
DeviceAccessStatus accessStatus = await service.RequestAccessAsync();
if (accessStatus == DeviceAccessStatus.Allowed)
{
GattCharacteristicsResult result = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
characteristics = result.Characteristics;
Console.WriteLine("Found Characteristics");
}
else
{
blePowermates[device].isSubscribing = false;
Console.WriteLine("Error accessing service.");
characteristics = new List <GattCharacteristic>();
}
}
else
{
blePowermates[device].isSubscribing = false;
Console.WriteLine("Error accessing service.");
}
} catch (Exception ex)
{
blePowermates[device].isSubscribing = false;
Console.WriteLine("Error: Restricted service. Can't read characteristics: " + ex.ToString());
}
if (characteristics != null)
{
foreach (GattCharacteristic characteristic in characteristics)
{
Console.WriteLine("└Characteristic uuid: " + characteristic.Uuid.ToString());
if (UuidEquals(uuidRead, characteristic.Uuid))
{
SubscribeToValueChange(characteristic);
Console.WriteLine(" └Subscribing to Read Characteristic");
}
}
}
}
/// <summary>
/// Helper function, enumerates a service searching for a specific characteristic.
/// </summary>
/// <param name="service">Service to enumerate.</param>
/// <param name="characteristicAssignedNumber">Characteristic to find.</param>
/// <returns><see cref="GattCharacteristic"/> of found characteristic, or null.</returns>
private async Task <GattCharacteristic> FindCharacteristicInService(GattDeviceService service, ushort characteristicAssignedNumber)
{
var characteristics = await service.GetCharacteristicsAsync();
foreach (var characteristic in characteristics.Characteristics)
{
var can = Bluetooth.Utility.UuidToAssignedNumber(characteristic.Uuid);
if (can == characteristicAssignedNumber)
{
return(characteristic);
}
}
return(null);
}
private async void EnumeratingChara(GattDeviceService service)
{
string charaName;
characteristics = null;
try
{
var accessStatus = await service.RequestAccessAsync();
if (accessStatus == DeviceAccessStatus.Allowed)
{
var result = await service.GetCharacteristicsAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
characteristics = result.Characteristics;
}
else
{
NotifyUser("Error accessing service.", NotifyType.ErrorMessage);
characteristics = new List <GattCharacteristic>();
}
}
else
{
NotifyUser("Error accessing service.", NotifyType.ErrorMessage);
characteristics = new List <GattCharacteristic>();
}
}
catch (Exception ex)
{
NotifyUser("Restricted service. Can't read charcteristics:" + ex.Message, NotifyType.ErrorMessage);
characteristics = new List <GattCharacteristic>();
}
var chara = characteristics[0];
charaName = DisplayHelpers.GetCharacteristicName(chara);
CharaReadUUID.Text = charaName;
CharaReadUUIDBorder.Visibility = Visibility.Visible;
EnumerationReadDescriptor(chara);
chara = characteristics[1];
charaName = DisplayHelpers.GetCharacteristicName(chara);
CharaWriteUUID.Text = charaName;
CharaWriteUUIDBorder.Visibility = Visibility.Visible;
EnumerationWriteDescriptor(chara);
CharaReadUUIDBorder.Visibility = Visibility.Visible;
}
async Task <IReadOnlyList <GattCharacteristic> > DoGetCharacteristics()
{
List <GattCharacteristic> characteristics = new List <GattCharacteristic>();
var result = await _service.GetCharacteristicsAsync();
if (result.Status == GattCommunicationStatus.Success)
{
foreach (var c in result.Characteristics)
{
characteristics.Add(new GattCharacteristic(this, c));
}
}
return(characteristics.AsReadOnly());
}
private async void ListServices_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (connected)
{
ListCharacteristics.Items.Clear();
selectedService = ListServices.SelectedItem as GattDeviceService;
var characteristics = await selectedService.GetCharacteristicsAsync();
foreach (var charact in characteristics.Characteristics)
{
ListCharacteristics.Items.Add(charact);
connectedDeviceCharacteristics.Add(charact);
}
}
}
public async Task ConnectDevice(string id)
{
BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(id);
if (bluetoothLeDevice != null)
{
GattDeviceServicesResult gattDeviceServicesResult = await bluetoothLeDevice.GetGattServicesAsync();
Log.Debug($"{bluetoothLeDevice.Name} Services: {gattDeviceServicesResult.Services.Count}, {gattDeviceServicesResult.Status}, {gattDeviceServicesResult.ProtocolError}");
if (gattDeviceServicesResult.Status == GattCommunicationStatus.Success)
{
_selectedDeviceServices = gattDeviceServicesResult.Services.FirstOrDefault(x => x.Uuid.ToString() == ServiceUUID);
foreach (var service in gattDeviceServicesResult.Services)
{
Log.Debug("service: " + service.Uuid);
}
if (_selectedDeviceServices != null)
{
GattCharacteristicsResult gattCharacteristicsResult = await _selectedDeviceServices.GetCharacteristicsAsync();
if (gattCharacteristicsResult.Status == GattCommunicationStatus.Success)
{
var characteristics = gattCharacteristicsResult.Characteristics.Where(x => x.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Write));
_commandCharacteristic = gattCharacteristicsResult.Characteristics.FirstOrDefault(x => x.Uuid.ToString() == CommandUUID);
_serialCharacteristic = gattCharacteristicsResult.Characteristics.FirstOrDefault(x => x.Uuid.ToString() == SerialPortUUID);
GattCharacteristicProperties properties = _serialCharacteristic.CharacteristicProperties;
if (_serialCharacteristic != null)
{
if (properties.HasFlag(GattCharacteristicProperties.Read))
{
ReadBLESerial();
}
if (properties.HasFlag(GattCharacteristicProperties.Write))
{
WriteBlunoSettings();
}
if (properties.HasFlag(GattCharacteristicProperties.Notify))
{
// This characteristic supports subscribing to notifications.
}
}
}
}
}
}
}
