protected async Task <bool> SetupCharacteristicNotifyAsync(Guid characteristicUUID, bool enable, TypedEventHandler <GattCharacteristic, GattValueChangedEventArgs> callback)
{
if (Service == null)
{
await ConnectServiceAsync();
}
if (Service != null)
{
GattCharacteristic characteristic = Service.GetCharacteristics(characteristicUUID).FirstOrDefault();
if (characteristic != null)
{
GattClientCharacteristicConfigurationDescriptorValue value = enable ? GattClientCharacteristicConfigurationDescriptorValue.Notify : GattClientCharacteristicConfigurationDescriptorValue.None;
GattCommunicationStatus status = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(value);
if (status == GattCommunicationStatus.Success)
{
if (enable)
{
characteristic.ValueChanged += callback;
}
else
{
characteristic.ValueChanged -= callback;
}
return(true);
}
}
}
return(false);
}
private void Subscribe(GattClientCharacteristicConfigurationDescriptorValue value)
{
var t = Task.Run(async() => await readCh.WriteClientCharacteristicConfigurationDescriptorAsync(value));
string result = WaitTask(t, 2) == t?t.Result.ToString() : null;
subscription = "CCCD subscription result: " + (result ?? "timed out");
}
private async Task <bool> TurnOnNotification(Guid Characteristic, TypedEventHandler <GattCharacteristic, GattValueChangedEventArgs> Callback)
{
Debug.WriteLine("[miband] activando notificacion");
var _characteristic = getCharacteristic(Characteristic);
if (_characteristic != null)
{
GattClientCharacteristicConfigurationDescriptorValue type = GattClientCharacteristicConfigurationDescriptorValue.None;
if (((int)_characteristic.CharacteristicProperties & (int)GattCharacteristicProperties.Notify) != 0)
{
type = GattClientCharacteristicConfigurationDescriptorValue.Notify;
}
if (((int)_characteristic.CharacteristicProperties & (int)GattCharacteristicProperties.Indicate) != 0)
{
type = GattClientCharacteristicConfigurationDescriptorValue.Indicate;
}
_characteristic.ValueChanged += Callback;
try
{
var ret = await _characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(type);
if (ret == GattCommunicationStatus.Success)
{
Debug.WriteLine("[miband] notificacion activada");
return(true);
}
}
catch (Exception)
{
}
}
Debug.WriteLine("[miband] error al activar notificacion");
return(false);
}
IObservable <object> SetNotify(GattClientCharacteristicConfigurationDescriptorValue value)
=> Observable.FromAsync(async ct =>
{
this.AssertNotify();
var status = await this.Native.WriteClientCharacteristicConfigurationDescriptorAsync(value);
if (status == GattCommunicationStatus.Success)
{
this.context.SetNotifyCharacteristic(this.Native, value != GattClientCharacteristicConfigurationDescriptorValue.None);
return(new object());
}
return(null);
});
private Task <GattCommunicationStatus> Notify(GattCharacteristic charac, GattClientCharacteristicConfigurationDescriptorValue value)
{
var tcs = new TaskCompletionSource <GattCommunicationStatus>();
Task.Run(async() =>
{
var _myres = await charac.WriteClientCharacteristicConfigurationDescriptorAsync(value);
tcs.SetResult(_myres);
});
tcs.Task.Wait();
return(tcs.Task);
}
/// <summary>
/// Sets up the notifications;
/// Will call Status
/// </summary>
/// <param name="notifyType"></param>
/// <returns>true if the notify was set up. </returns>
public async Task <bool> NotifyQWIICAsync(GattClientCharacteristicConfigurationDescriptorValue notifyType = GattClientCharacteristicConfigurationDescriptorValue.Notify)
{
if (!await EnsureCharacteristicAsync())
{
return(false);
}
var ch = Characteristics[5];
if (ch == null)
{
return(false);
}
GattCommunicationStatus result = GattCommunicationStatus.ProtocolError;
try
{
result = await ch.WriteClientCharacteristicConfigurationDescriptorAsync(notifyType);
if (!NotifyQWIIC_ValueChanged_Set)
{
// Only set the event callback once
NotifyQWIIC_ValueChanged_Set = true;
ch.ValueChanged += (sender, args) =>
{
var datameaning = "OEB U8|HEX|Sensor U16|HEX|Channel1 U16|HEX|Channel2 U16|HEX|Channel3 U16|HEX|Channel4 U16|HEX|Channel5";
var parseResult = BluetoothDeviceController.BleEditor.ValueParser.Parse(args.CharacteristicValue, datameaning);
QWIIC_Sensor = parseResult.ValueList.GetValue("Sensor").AsDouble;
QWIIC_Channel1 = parseResult.ValueList.GetValue("Channel1").AsDouble;
QWIIC_Channel2 = parseResult.ValueList.GetValue("Channel2").AsDouble;
QWIIC_Channel3 = parseResult.ValueList.GetValue("Channel3").AsDouble;
QWIIC_Channel4 = parseResult.ValueList.GetValue("Channel4").AsDouble;
QWIIC_Channel5 = parseResult.ValueList.GetValue("Channel5").AsDouble;
QWIICEvent?.Invoke(parseResult);
};
}
}
catch (Exception e)
{
Status.ReportStatus($"NotifyQWIIC: {e.Message}", result);
return(false);
}
Status.ReportStatus($"NotifyQWIIC: set notification", result);
return(true);
}
IObservable <CharacteristicGattResult> SetNotify(GattClientCharacteristicConfigurationDescriptorValue value)
=> Observable.FromAsync(async ct =>
{
var status = await this.Native.WriteClientCharacteristicConfigurationDescriptorAsync(value);
if (status != GattCommunicationStatus.Success)
{
throw new BleException($"Failed to write client characteristic configuration descriptor - {status}");
}
this.IsNotifying = value != GattClientCharacteristicConfigurationDescriptorValue.None;
this.context.SetNotifyCharacteristic(this);
return(new CharacteristicGattResult(this, null));
});
private async Task WriteConfigurationInChar(KeyValuePair<string, RsCharacteristic> rsCharacteristic, GattClientCharacteristicConfigurationDescriptorValue charConfigValue)
{
try
{
DevicesInformation = $" {charConfigValue} {Environment.NewLine}";
await
rsCharacteristic.Value.Characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(charConfigValue);
}
catch (Exception exception)
{
DevicesInformation = $" Exception {exception}";
}
}
/// <summary>
/// Sets up the notifications;
/// Will call Status
/// </summary>
/// <param name="notifyType"></param>
/// <returns>true if the notify was set up. </returns>
public async Task <bool> NotifyData_ValuesAsync(GattClientCharacteristicConfigurationDescriptorValue notifyType = GattClientCharacteristicConfigurationDescriptorValue.Notify)
{
if (!await EnsureCharacteristicAsync())
{
return(false);
}
var ch = Characteristics[5];
if (ch == null)
{
return(false);
}
GattCommunicationStatus result = GattCommunicationStatus.ProtocolError;
try
{
result = await ch.WriteClientCharacteristicConfigurationDescriptorAsync(notifyType);
if (!NotifyData_Values_ValueChanged_Set)
{
// Only set the event callback once
NotifyData_Values_ValueChanged_Set = true;
ch.ValueChanged += (sender, args) =>
{
var datameaning = "I24|HEX|Command U8|DEC|Range OEB U16|DEC|Value U8|DEC|V3 BYTES|HEX|More_Data";
var parseResult = BluetoothDeviceController.BleEditor.ValueParser.Parse(args.CharacteristicValue, datameaning);
Data_Values_Command = parseResult.ValueList.GetValue("Command").AsDouble;
Data_Values_Range = parseResult.ValueList.GetValue("Range").AsDouble;
Data_Values_Value = parseResult.ValueList.GetValue("Value").AsDouble;
Data_Values_V3 = parseResult.ValueList.GetValue("V3").AsDouble;
Data_Values_More_Data = parseResult.ValueList.GetValue("More_Data").AsString;
Data_ValuesEvent?.Invoke(parseResult);
};
}
}
catch (Exception e)
{
Status.ReportStatus($"NotifyData_Values: {e.Message}", result);
return(false);
}
Status.ReportStatus($"NotifyData_Values: set notification", result);
return(true);
}
private async Task WriteConfigurationInChar(GattCharacteristic characteristic, GattClientCharacteristicConfigurationDescriptorValue charConfigValue)
{
try
{
DevicesInformation += $" {charConfigValue} {Environment.NewLine}";
await
characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(charConfigValue);
DevicesInformation += $" - Ok{Environment.NewLine}";
}
catch (Exception exception)
{
DevicesInformation += $" - Exception {exception.Message}{Environment.NewLine}";
}
}
/// <summary>
/// Convenience class for writing the config value.
/// </summary>
/// <param name="Enable"></param>
/// <returns></returns>
public async Task WriteBarometer_ConfigNotify(GattClientCharacteristicConfigurationDescriptorValue Enable)
{
switch (Enable)
{
case GattClientCharacteristicConfigurationDescriptorValue.Notify:
await WriteBarometer_Config(1);
break;
case GattClientCharacteristicConfigurationDescriptorValue.None:
await WriteBarometer_Config(0);
break;
}
}
/// <summary>
/// Convenience class for writing the config value.
/// </summary>
/// <param name="Enable"></param>
/// <returns></returns>
///
public async Task WriteAccelerometer_ConfigNotify(GattClientCharacteristicConfigurationDescriptorValue Enable)
{
switch (Enable)
{
case GattClientCharacteristicConfigurationDescriptorValue.Notify:
await WriteAccelerometer_Config(0xFFFF); // always just write the same value.
break;
case GattClientCharacteristicConfigurationDescriptorValue.None:
await WriteAccelerometer_Config(0);
break;
}
}
/// <summary>
/// Convenience class for writing the config value.
/// </summary>
/// <param name="Enable"></param>
/// <returns></returns>
public async Task WriteGyroscope_ConfigNotify(GattClientCharacteristicConfigurationDescriptorValue Enable)
{
switch (Enable)
{
case GattClientCharacteristicConfigurationDescriptorValue.Notify:
await WriteGyroscope_Configure(7); // always just write the same value to enable all three axis
break;
case GattClientCharacteristicConfigurationDescriptorValue.None:
await WriteGyroscope_Configure(0);
break;
}
}
/// <summary>
/// Sets up the notifications;
/// Will call Status
/// </summary>
/// <param name="notifyType"></param>
/// <returns>true if the notify was set up. </returns>
public async Task <bool> NotifyAnalogAsync(GattClientCharacteristicConfigurationDescriptorValue notifyType = GattClientCharacteristicConfigurationDescriptorValue.Notify)
{
if (!await EnsureCharacteristicAsync())
{
return(false);
}
var ch = Characteristics[4];
if (ch == null)
{
return(false);
}
GattCommunicationStatus result = GattCommunicationStatus.ProtocolError;
try
{
result = await ch.WriteClientCharacteristicConfigurationDescriptorAsync(notifyType);
if (!NotifyAnalog_ValueChanged_Set)
{
// Only set the event callback once
NotifyAnalog_ValueChanged_Set = true;
ch.ValueChanged += (sender, args) =>
{
var datameaning = "I32^100000_/|FIXED|A1|volts I32^100000_/|FIXED|A2|volts I32^100000_/|FIXED|A3|volts I32^100000_/|FIXED|A4|volts";
var parseResult = BluetoothDeviceController.BleEditor.ValueParser.Parse(args.CharacteristicValue, datameaning);
Analog_A1 = parseResult.ValueList.GetValue("A1").AsDouble;
Analog_A2 = parseResult.ValueList.GetValue("A2").AsDouble;
Analog_A3 = parseResult.ValueList.GetValue("A3").AsDouble;
Analog_A4 = parseResult.ValueList.GetValue("A4").AsDouble;
AnalogEvent?.Invoke(parseResult);
};
}
}
catch (Exception e)
{
Status.ReportStatus($"NotifyAnalog: {e.Message}", result);
return(false);
}
Status.ReportStatus($"NotifyAnalog: set notification", result);
return(true);
}
/// <summary>
/// Subscribes to the given GattCharacteristic if it allows it.
/// </summary>
/// <param name="c">The GattCharacteristic you want to subscribe to.</param>
/// <returns>Returns true on success.</returns>
private async Task <bool> SubscribeToCharacteristicAsync(GattCharacteristic c)
{
// Check if characteristic supports subscriptions:
GattClientCharacteristicConfigurationDescriptorValue cccdValue = GattClientCharacteristicConfigurationDescriptorValue.None;
if (c.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Indicate))
{
cccdValue = GattClientCharacteristicConfigurationDescriptorValue.Indicate;
}
else if (c.CharacteristicProperties.HasFlag(GattCharacteristicProperties.Notify))
{
cccdValue = GattClientCharacteristicConfigurationDescriptorValue.Notify;
}
else
{
return(false);
}
// Set subscribed:
GattCommunicationStatus status;
try
{
status = await c.WriteClientCharacteristicConfigurationDescriptorAsync(cccdValue);
}
catch (Exception e)
{
Logger.Warn("Failed to subscribe to characteristic " + c.Uuid + " with " + e.ToString());
return(false);
}
// Add event handler:
if (status == GattCommunicationStatus.Success)
{
c.ValueChanged -= C_ValueChanged;
c.ValueChanged += C_ValueChanged;
Logger.Debug("Subscribed to characteristic: " + c.Uuid);
return(true);
}
else
{
Logger.Warn("Failed to subscribe to characteristic " + c.Uuid + " with " + status);
}
return(false);
}
public GattCommunicationStatus Notify_Characteristic(GattCharacteristic charac, GattClientCharacteristicConfigurationDescriptorValue value)
{
Task nRes = Notify(charac, value).ContinueWith((anteNC) =>
{
if (anteNC.Status == TaskStatus.RanToCompletion)
{
var CharNotStat = anteNC.Result;
charac.ValueChanged += ReceiveData;
return(CharNotStat);
}
else
{
return(GattCommunicationStatus.Unreachable);
}
});
return(GattCommunicationStatus.Unreachable);
}
/// <summary>
/// Sets up the notifications;
/// Will call Status
/// </summary>
/// <param name="notifyType"></param>
/// <returns>true if the notify was set up. </returns>
public async Task <bool> NotifyMicrophoneAsync(GattClientCharacteristicConfigurationDescriptorValue notifyType = GattClientCharacteristicConfigurationDescriptorValue.Notify)
{
if (!await EnsureCharacteristicAsync())
{
return(false);
}
var ch = Characteristics[9];
if (ch == null)
{
return(false);
}
GattCommunicationStatus result = GattCommunicationStatus.ProtocolError;
try
{
result = await ch.WriteClientCharacteristicConfigurationDescriptorAsync(notifyType);
if (!NotifyMicrophone_ValueChanged_Set)
{
// Only set the event callback once
NotifyMicrophone_ValueChanged_Set = true;
ch.ValueChanged += (sender, args) =>
{
var datameaning = "BYTES|HEX|Audio";
var parseResult = BluetoothDeviceController.BleEditor.ValueParser.Parse(args.CharacteristicValue, datameaning);
Microphone = parseResult.ValueList.GetValue("Audio").AsString;
MicrophoneEvent?.Invoke(parseResult);
};
}
}
catch (Exception e)
{
Status.ReportStatus($"NotifyMicrophone: {e.Message}", result);
return(false);
}
Status.ReportStatus($"NotifyMicrophone: set notification", result);
return(true);
}
public async Task InitChararacteristicsConfiguration()
{
ClearExceptions();
const GattClientCharacteristicConfigurationDescriptorValue charValue =
GattClientCharacteristicConfigurationDescriptorValue.Indicate;
try
{
await InitCount1To20.WriteClientCharacteristicConfigurationDescriptorAsync(charValue);
}
catch (Exception exception)
{
AddException(exception);
}
try
{
await PowerMotors.WriteClientCharacteristicConfigurationDescriptorAsync(charValue);
}
catch (Exception exception)
{
AddException(exception);
}
try
{
await DateTime.WriteClientCharacteristicConfigurationDescriptorAsync(charValue);
}
catch (Exception exception)
{
AddException(exception);
}
try
{
await EmergencyStop.WriteClientCharacteristicConfigurationDescriptorAsync(charValue);
}
catch (Exception exception)
{
AddException(exception);
}
}
private static async void SubscribeToValueChange(GattCharacteristic characteristic)
{
string device = characteristic.Service.Device.DeviceInformation.Id.Substring(41);
GattClientCharacteristicConfigurationDescriptorValue gcccdValue = GattClientCharacteristicConfigurationDescriptorValue.None;
if ((characteristic.CharacteristicProperties & GattCharacteristicProperties.Indicate) != GattCharacteristicProperties.None)
{
gcccdValue = GattClientCharacteristicConfigurationDescriptorValue.Indicate;
}
else if ((characteristic.CharacteristicProperties & GattCharacteristicProperties.Notify) != GattCharacteristicProperties.None)
{
gcccdValue = GattClientCharacteristicConfigurationDescriptorValue.Notify;
}
else
{
blePowermates[device].isSubscribing = false;
Console.WriteLine("Couldn't set Characteristic Configuration Descriptor");
}
try
{
GattCommunicationStatus status = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(gcccdValue);
if (status == GattCommunicationStatus.Success)
{
blePowermates[device].readCharacteristic = characteristic;
blePowermates[device].isSubscribing = false;
AddValueChangedHandler(blePowermates[device].readCharacteristic);
Console.WriteLine("Successfully subscribed for value changes");
}
}catch (Exception ex)
{
blePowermates[device].isSubscribing = false;
Console.WriteLine("Error registering for value changes: Status = ", ex.Message);
}
}
private async Task WriteConfigurationInChar(GattCharacteristic characteristic, GattClientCharacteristicConfigurationDescriptorValue charConfigValue)
{
try
{
DevicesInformation += $" {charConfigValue} {Environment.NewLine}";
await
characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(charConfigValue);
DevicesInformation += $" - Ok{Environment.NewLine}";
}
catch (Exception exception)
{
DevicesInformation += $" - Exception {exception.Message}{Environment.NewLine}";
}
}
private async Task WriteConfigurationInChar(KeyValuePair <string, RsCharacteristic> rsCharacteristic, GattClientCharacteristicConfigurationDescriptorValue charConfigValue)
{
try
{
DevicesInformation = $" {charConfigValue} {Environment.NewLine}";
await
rsCharacteristic.Value.Characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(charConfigValue);
}
catch (Exception exception)
{
DevicesInformation = $" Exception {exception}";
}
}
public ClientDescriptorViewModel(GattClientCharacteristicConfigurationDescriptorValue descriptor, string title)
{
Descriptor = descriptor;
Title = title;
Info = "State unknown";
}
public WriteClientConfigDescriptorCommand(CharacteristicInfo characteristicInfo, GattClientCharacteristicConfigurationDescriptorValue descriptor) : base(characteristicInfo)
{
Descriptor = descriptor;
}
