public BleCharacteristicControl(NameDevice device, GattDeviceService service, GattCharacteristic characteristic)
{
this.DataContext = this;
this.InitializeComponent();
if (device == null)
{
;
}
Loaded += async(s, e) => await SetupAsync(device, service, characteristic);
}
private void OnSelectJsonFile(object sender, SelectionChangedEventArgs e)
{
if (e.AddedItems.Count != 1)
{
return;
}
var name = (e.AddedItems[0] as ComboBoxItem).Content as string;
var localSettings = ApplicationData.Current.LocalSettings;
localSettings.Values[SAVED_DEVICE_NAME] = name;
SelectedNameDevice = BleNames.GetDevice(name, BleNames.AllRawDevices);
DisplaySelection();
}
// Sets up all of the flags, values, etc.
private async Task SetupAsync(NameDevice device, GattDeviceService service, GattCharacteristic characteristic)
{
Service = service;
Characteristic = characteristic;
NC = BleNames.Get(device, service, characteristic);
#if NEVER_EVER_DEFINED
// Setting it up differently now via the UILIst + uiUI
Commands.Clear();
foreach (var(_, command) in NC.Commands)
{
command.WriteCharacteristic = this;
Commands.Add(command);
}
#endif
var props = characteristic.CharacteristicProperties;
uiNotifyFlag.Visibility = props.HasFlag(GattCharacteristicProperties.Notify) ? Visibility.Visible : Visibility.Collapsed;
uiNotifyOnFlag.Visibility = Visibility.Collapsed;
uiReadFlag.Visibility = props.HasFlag(GattCharacteristicProperties.Read) ? Visibility.Visible : Visibility.Collapsed;
uiWriteFlag.Visibility = props.HasFlag(GattCharacteristicProperties.WriteWithoutResponse) ? Visibility.Visible : Visibility.Collapsed;
uiIncrementWriteFlag.Visibility = uiWriteFlag.Visibility;
uiWriteWithResponseFlag.Visibility = props.HasFlag(GattCharacteristicProperties.Write) ? Visibility.Visible : Visibility.Collapsed;
uiIncrementWriteWithResponseFlag.Visibility = uiWriteWithResponseFlag.Visibility;
uiIndicateFlag.Visibility = props.HasFlag(GattCharacteristicProperties.Indicate) ? Visibility.Visible : Visibility.Collapsed;
uiIndicateOnFlag.Visibility = Visibility.Collapsed;
// The less common flags
uiBroadcastFlag.Visibility = props.HasFlag(GattCharacteristicProperties.Broadcast) ? Visibility.Visible : Visibility.Collapsed;
uiAuthenticatedSignedWritesFlag.Visibility = props.HasFlag(GattCharacteristicProperties.AuthenticatedSignedWrites) ? Visibility.Visible : Visibility.Collapsed;
uiExtendedPropertiesFlag.Visibility = props.HasFlag(GattCharacteristicProperties.ExtendedProperties) ? Visibility.Visible : Visibility.Collapsed;
uiReliableWritesFlag.Visibility = props.HasFlag(GattCharacteristicProperties.ReliableWrites) ? Visibility.Visible : Visibility.Collapsed;
uiWritableAuxilariesFlag.Visibility = props.HasFlag(GattCharacteristicProperties.WritableAuxiliaries) ? Visibility.Visible : Visibility.Collapsed;
// Set the little edit marker
uiEditFlag.Visibility = (props.HasFlag(GattCharacteristicProperties.Write) ||
props.HasFlag(GattCharacteristicProperties.WriteWithoutResponse))
? Visibility.Visible : Visibility.Collapsed;
await DoReadAsync(true); // update the value field even if it's not readable
var namestr = "";
if (!String.IsNullOrEmpty(NC?.Name))
{
namestr = NC.Name;
}
else
{
var uidname = service.Uuid.ToString().GetCommon(characteristic.Uuid.ToString());
if (uidname.Length < 8)
{
namestr = uidname;
if (namestr == "ffa2")
{
; // something handy to put a debugger on!
}
if (namestr == "ffa3")
{
; // a handy line to put a debugger on!
}
if (!String.IsNullOrWhiteSpace(characteristic.UserDescription))
{
namestr += " " + characteristic.UserDescription;
}
else
{
;
}
}
}
// Either we have a good name (yay!) or we use the alternate route of using the
// uuid info area.
if (namestr != "")
{
// Don't need the UUID area or the line break
uiName.Text = namestr;
uiInfo.Visibility = Visibility.Collapsed;
}
else
{
var infostr = "";
if (!string.IsNullOrWhiteSpace(NC?.Name))
{
infostr = NC.Name + " ";
}
infostr += characteristic.Uuid.ToString();
uiInfo.Text = infostr;
uiInfo.Visibility = Visibility.Visible;
}
// If there's a readable value with displayFormatPrimary=ASCII and secondary of LONG (ASCII^LONG)
// then make the text area multi-line
var vps = ValueParserSplit.ParseLine(NC?.Type ?? "");
if (vps.Count == 1)
{
var displayFormat = vps[0].DisplayFormatPrimary;
var displayFormatSecondary = vps[0].Get(1, 1);
switch (displayFormat)
{
case "ASCII":
switch (displayFormatSecondary)
{
case "LONG":
var h = uiValueShow.ActualHeight;
uiValueShowScroll.MinHeight = h * 3;
uiValueShowScroll.MaxHeight = h * 7;
CurrValueShowMethod = ValueShowMethod.Append;
break;
}
break;
}
}
try
{
SetupUI();
}
catch (Exception)
{
;
}
if (NC != null && NC.Commands != null)
{
foreach (var(_, command) in NC.Commands)
{
command.InitVariables();
command.WriteCharacteristic = this;
}
}
}
private async Task DisplayBluetooth(NameDevice knownDevice, DeviceInformationWrapper di, BluetoothLEDevice ble)
{
var jsonFormat = Newtonsoft.Json.Formatting.Indented;
var jsonSettings = new Newtonsoft.Json.JsonSerializerSettings()
{
DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ContractResolver = IgnoreEmptyEnumerableResolver.Instance,
};
var wireAllDevices = new NameAllBleDevices();
WireDevice = new NameDevice();
WireDevice.Name = di.di.Name;
WireDevice.Details += $"Id:{di.di.Id}\nCanPair:{di.di.Pairing.CanPair} IsPaired:{di.di.Pairing.IsPaired}";
wireAllDevices.AllDevices.Add(WireDevice);
WireDevice.ClassModifiers = knownDevice.ClassModifiers;
WireDevice.ClassName = knownDevice.ClassName;
WireDevice.Description = knownDevice.Description;
uiRawData.Text = Newtonsoft.Json.JsonConvert.SerializeObject(WireDevice, jsonFormat);
string raw = null;
if (ble == null)
{
// Happens if another program is trying to use the device!
raw = $"BLE: ERROR: Another app is using this device.\n";
}
else
{
// TODO: remove this code which is only here while I investigate the WESCALE scale
#if NEVER_EVER_DEFINED
{
// WESCALE: no gatt services
var services = ble.GattServices;
var count = services.Count;
var devacc = ble.DeviceAccessInformation;
var devaccstatus = devacc.CurrentStatus;
foreach (var service in services)
{
var chars = service.GetAllCharacteristics();
}
try
{
var guid = Guid.Parse("0000fff0-0000-1000-8000-00805f9b34fb");
var request = await ble.RequestAccessAsync();
var allservice = await ble.GetGattServicesForUuidAsync(guid);
var servicefff0 = ble.GetGattService(guid);
var charsfff0 = servicefff0.GetAllCharacteristics();
var countfff0 = charsfff0.Count;
foreach (var ch in charsfff0)
{
;
}
}
catch (Exception ex)
{
;
}
}
#endif
var result = await ble.GetGattServicesAsync();
if (result.Status != GattCommunicationStatus.Success)
{
raw += GetStatusString(result.Status, result.ProtocolError);
}
else
{
var header = new BleDeviceHeaderControl();
await header.InitAsync(ble);
int serviceCount = 0;
foreach (var service in result.Services)
{
await header.AddServiceAsync(ble, service);
var shouldDisplay = ServiceShouldBeEdited(service);
var defaultService = knownDevice.GetService(service.Uuid.ToString("D"));
var wireService = new NameService(service, defaultService, serviceCount++);
WireDevice.Services.Add(wireService);
try
{
var cresult = await service.GetCharacteristicsAsync();
if (cresult.Status != GattCommunicationStatus.Success)
{
raw += GetStatusString(cresult.Status, cresult.ProtocolError);
}
else
{
var characteristicCount = 0;
foreach (var characteristic in cresult.Characteristics)
{
//The descriptors don't seem to be actually interesting. it's how we read and write.
var descriptorStatus = await characteristic.GetDescriptorsAsync();
if (descriptorStatus.Status == GattCommunicationStatus.Success)
{
foreach (var descriptor in descriptorStatus.Descriptors)
{
;
}
}
var defaultCharacteristic = defaultService?.GetChacteristic(characteristic.Uuid.ToString("D"));
var wireCharacteristic = new NameCharacteristic(characteristic, defaultCharacteristic, characteristicCount++);
wireService.Characteristics.Add(wireCharacteristic);
if (wireCharacteristic.Suppress)
{
continue; // don't show a UI for a supressed characteristic.
}
//
// Here are each of the editor children items
//
var edit = new BleCharacteristicControl(knownDevice, service, characteristic);
uiEditor.Children.Add(edit);
var dc = DeviceCharacteristic.Create(characteristic);
//NOTE: does any device have a presentation format?
foreach (var format in characteristic.PresentationFormats)
{
raw += $" Fmt: Description:{format.Description} Namespace:{format.Namespace} Type:{format.FormatType} Unit: {format.Unit} Exp:{format.Exponent}\n";
}
try
{
if (wireCharacteristic.IsRead)
{
var vresult = await characteristic.ReadValueAsync();
if (vresult.Status != GattCommunicationStatus.Success)
{
raw += GetStatusString(vresult.Status, vresult.ProtocolError);
}
else
{
var dt = BluetoothLEStandardServices.GetDisplayInfo(service, characteristic);
var hexResults = dt.AsString(vresult.Value);
wireCharacteristic.ExampleData.Add(hexResults);
// And add as a converted value
var NC = BleNames.Get(knownDevice, service, characteristic);
var decode = NC?.Type;
if (decode != null && !decode.StartsWith("BYTES|HEX"))
{
var decoded = ValueParser.Parse(vresult.Value, decode);
wireCharacteristic.ExampleData.Add(decoded.UserString);
}
}
}
}
catch (Exception e)
{
raw += $" Exception reading value: {e.HResult} {e.Message}\n";
}
// Update the UI with the latest discovery
// Later: or not. The raw data isn't super useful.
//uiRawData.Text = Newtonsoft.Json.JsonConvert.SerializeObject(WireDevice, jsonFormat);
}
}
}
catch (Exception e)
{
raw += $" Exception reading characteristic: {e.HResult} {e.Message}\n";
}
}
}
}
JsonAsList = Newtonsoft.Json.JsonConvert.SerializeObject(wireAllDevices, jsonFormat, jsonSettings);
JsonAsSingle = Newtonsoft.Json.JsonConvert.SerializeObject(WireDevice, jsonFormat, jsonSettings);
uiProgress.IsActive = false;
uiRawData.Text += raw;
return;
}
