public async Task <String> getAddress()
{
#if WINDOWS_PHONE_APP
BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromIdAsync(device.Id);
ulong maclong = bleDevice.BluetoothAddress;
var tempMac = maclong.ToString("X");
var mac = Regex.Replace(tempMac, "(.{2})(.{2})(.{2})(.{2})(.{2})(.{2})", "$1:$2:$3:$4:$5:$6");
return(mac);
#endif
#if WINDOWS_APP
return("00:00:00:00:00:00");
#endif
}
/// <summary>
/// 按MAC地址查找系统中配对设备
/// </summary>
/// <param name="MAC"></param>
public async Task SelectDevice(string bleDevice)
{
CurrentDevice = await BluetoothLEDevice.FromIdAsync(bleDevice);
if (CurrentDevice == null)
{
string msg = "没有发现设备";
ValueChanged(MsgType.Error, msg, CurrentDevice == null ? null : CurrentDevice.DeviceId);
}
else
{
await Connect();
}
}
async static void DeviceAdded(DeviceWatcher sender, DeviceInformation deviceInfo)
{
// If the random device matches our device name, connect to it.
//Console.WriteLine("Device found: " + deviceInfo.Name);
if (deviceInfo.Name.CompareTo(deviceName) == 0)
{
// Get the bluetooth object and save it. This function will connect to the device
device = await BluetoothLEDevice.FromIdAsync(deviceInfo.Id);
Console.WriteLine("Connected to " + device.Name);
isDeviceConnected = true;
}
}
public async void SetupBLE()
{
txtProgress.Text = "Obtaining BTLE Info...";
var query = BluetoothLEDevice.GetDeviceSelector();
var deviceList = await DeviceInformation.FindAllAsync(query);
int count = deviceList.Count();
if (count > 0)
{
//Assumes default name of the Adafruit Bluefruit LE
var deviceInfo = deviceList.Where(x => x.Name == "Adafruit Bluefruit LE").FirstOrDefault();
if (deviceInfo != null)
{
var bleDevice = await BluetoothLEDevice.FromIdAsync(deviceInfo.Id);
var deviceServices = bleDevice.GattServices;
txtProgress.Text = "Retrieving service and GATT characteristics...";
var deviceSvc = deviceServices.Where(svc => svc.AttributeHandle == 0x003a).FirstOrDefault();
if (deviceSvc != null)
{
var characteristics = deviceSvc.GetAllCharacteristics();
_notifyCharacteristic = characteristics.Where(x => x.AttributeHandle == 0x003b).FirstOrDefault();
_writeCharacteristic = characteristics.Where(x => x.AttributeHandle == 0x003e).FirstOrDefault();
_readCharacteristic = characteristics.Where(x => x.AttributeHandle == 0x0040).FirstOrDefault();
_notifyCharacteristic.ValueChanged += NotifyCharacteristic_ValueChanged;
await _notifyCharacteristic.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
txtProgress.Text = "Bluetooth LE Device service and characteristics initialized";
txtBTLEStatus.Text = "Initialized";
txtBTLEStatus.Foreground = new SolidColorBrush(Colors.Green);
btnBlue.IsEnabled = true;
btnGreen.IsEnabled = true;
btnYellow.IsEnabled = true;
btnOrange.IsEnabled = true;
btnPurple.IsEnabled = true;
btnRead.IsEnabled = true;
}
else
{
txtInfo.Text = "Custom GATT Service Not Found on the Bluefruit";
}
}
else
{
txtInfo.Text = "Adafruit Bluefruit LE not found, is it paired ??";
}
}
}
/// <summary>
/// attempts to pair a BLE device by ID
/// </summary>
/// <param name="deviceId">the BLE device Id</param>
/// <returns></returns>
public async Task PairToDeviceAsync(string deviceId)
{
// get bluetooth device info
var device = await BluetoothLEDevice.FromIdAsync(deviceId).AsTask();
// null check
if (device == null)
{
// TODO: Localize
throw new ArgumentNullException("Failed to get information about the Bluetooth device");
}
// if we already paired...
if (device.DeviceInformation.Pairing.IsPaired)
{
// do nothing..
return;
}
// listen out for pairing requests
device.DeviceInformation.Pairing.Custom.PairingRequested += (sender, args) =>
{
// log it
// TODO: Remove
Console.WriteLine("Accepting pairing request...");
// accept all attempts
args.Accept();
};
// try and pair to the device
var result = await device.DeviceInformation.Pairing.Custom.PairAsync(
// for contour we should try provide pin
// TODO: try different types to see if any works
DevicePairingKinds.ProvidePin
).AsTask();
// log the result
if (result.Status == DevicePairingResultStatus.Paired)
{
// TODO: Remove
Console.WriteLine("Pairing successful");
}
else
{
// TODO: remove
Console.WriteLine($"Pairing failed: {result.Status}");
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
DeviceWatcher deviceWatcher =
DeviceInformation.CreateWatcher(
BluetoothLEDevice.GetDeviceSelectorFromPairingState(false),
requestedProperties,
DeviceInformationKind.AssociationEndpoint);
// Register event handlers before starting the watcher.
// Added, Updated and Removed are required to get all nearby devices
deviceWatcher.Added += new TypedEventHandler <DeviceWatcher, DeviceInformation>(async(watcher, devInfo) =>
{
if (devInfo.Name != "")
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
DeviceList.Text += String.Format("{0} : {1}\r\n", devInfo.Name, devInfo.Id);
});
Console.WriteLine(String.Format("{0} : {1}", devInfo.Name, devInfo.Id));
}
if (devInfo.Name == "MI Band 2")
{
Console.WriteLine("Find Mi");
BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(devInfo.Id);
//Console.WriteLine(String.Format("{0} : {1}", bluetoothLeDevice.Name, bluetoothLeDevice.DeviceInformation));
}
});;
deviceWatcher.Updated += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, devInfo) =>
{
});;
deviceWatcher.Removed += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, devInfo) =>
{
});;
// EnumerationCompleted and Stopped are optional to implement.
deviceWatcher.EnumerationCompleted += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
Console.WriteLine(String.Format("EnumerationCompleted"));
});
deviceWatcher.Stopped += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
Console.WriteLine(String.Format("deviceWatcher.Stopped"));
});;
// Start the watcher.
deviceWatcher.Start();
}
protected async override void OnNavigatedTo(NavigationEventArgs args)
{
SetStatusActive(true);
var di = args.Parameter as DeviceInformationWrapper;
var ble = await BluetoothLEDevice.FromIdAsync(di.di.Id);
SetStatusActive(false);
bleDevice.ble = ble;
bleDevice.Status.OnBluetoothStatus += bleDevice_OnBluetoothStatus;
await DoReadDevice_Name();
await DoNotifyDistance();
await DoNotifyAmbientLight();
}
private async void ConnectKnownDevice(DeviceInformation deviceInfo)
{
var bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(deviceInfo.Id);
var services = await bluetoothLeDevice.GetGattServicesAsync();
if (services.Services.Single(s => s.Uuid == ControlServiceUUID) != null)
{
Debug.Log("Found known Myo");
StopScanningForMyo();
_myoBle = bluetoothLeDevice;
await ConnectToMyo();
}
}
protected async override void OnNavigatedTo(NavigationEventArgs args)
{
uiProgress.IsActive = true;
var di = args.Parameter as DeviceInformationWrapper;
var ble = await BluetoothLEDevice.FromIdAsync(di.di.Id);
uiProgress.IsActive = false;
bleDevice.ble = ble;
bleDevice.Status.OnBluetoothStatus += device_OnBluetoothStatus;
OnResetTime(null, null);
IsFullyInitialized = true;
}
private async void OHbtnConn_Click(object sender, RoutedEventArgs e)
{
OHbtnConn.IsEnabled = false;
if (OHbtnConn.Content.ToString() == "Connect")
{
if (lstDevices.SelectedItem != null)
{
device = lstDevices.SelectedItem as DeviceInformation;
OHtxtStat.Text = "Initializing device...";
//HeartRateService.Instance.DeviceConnectionUpdated += OnDeviceConnectionUpdated;
//await HeartRateService.Instance.InitializeServiceAsync(device);
try
{
// BT_Code: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent.
bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.Id);
if (bluetoothLeDevice == null)
{
var dialog = new MessageDialog("Failed to connect to device.");
await dialog.ShowAsync();
}
else
{
GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
var services = result.Services;
OHtxtStat.Text = String.Format("Connected & Found {0} services", services.Count);
}
}
}
catch (Exception ex)
{
var dialog = new MessageDialog("Retrieving device properties failed with message: " + ex.Message);
await dialog.ShowAsync();
}
}
}
else//Disconnect
{
characteristics.ValueChanged -= Characteristic_ValueChanged;
service.Dispose();
bluetoothLeDevice = null;
GC.Collect();
}
OHbtnConn.Content = OHbtnConn.Content.ToString() == "Disconnect" ? "Connect" : "Disconnect";
OHbtnConn.IsEnabled = true;
}
public async void Connect(string id)
{
try
{
// BT_Code: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent.
bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(id);
if (bluetoothLeDevice == null)
{
Log.d("Failed to connect to device.", NotifyType.ErrorMessage);
return;
}
bluetoothLeDevice.ConnectionStatusChanged += ConnectionStatusChangedHandler;
mBluetoothGatt = await GattSession.FromDeviceIdAsync(bluetoothLeDevice.BluetoothDeviceId);
mBluetoothGatt.MaintainConnection = true;
}
catch (Exception ex) when(ex.HResult == E_DEVICE_NOT_AVAILABLE)
{
Log.d("Bluetooth radio is not on.", NotifyType.ErrorMessage);
return;
}
if (bluetoothLeDevice != null)
{
// Note: BluetoothLEDevice.GattServices property will return an empty list for unpaired devices. For all uses we recommend using the GetGattServicesAsync method.
// BT_Code: GetGattServicesAsync returns a list of all the supported services of the device (even if it's not paired to the system).
// If the services supported by the device are expected to change during BT usage, subscribe to the GattServicesChanged event.
GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesForUuidAsync(RX_SERVICE_UUID);
if (result.Status == GattCommunicationStatus.Success)
{
_services.Clear();
_services.AddRange(result.Services);
Log.d(String.Format("Found {0} services", _services.Count), NotifyType.StatusMessage);
foreach (var service in _services)
{
Log.d("SERVICE: " + DisplayHelpers.GetServiceName(service));
GetCharachteristics(service);
}
}
else
{
Log.d("Device unreachable", NotifyType.ErrorMessage);
}
}
}
private async Task connectDirectDeviceAsync()
{
String bluetoothAddress = "BluetoothLE#BluetoothLE3c:f8:62:c6:77:e3-cc:32:24:e9:13:1a";
try
{
BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(bluetoothAddress);
var instance = UARTService.Instance;
var dfuVersionCharacteristics = instance.Service.GetCharacteristics(new Guid(UARTService.UARTCharacteristics_UUID_TX));
GattCharacteristicProperties properties = dfuVersionCharacteristics[0].CharacteristicProperties;
if (properties.HasFlag(GattCharacteristicProperties.Read))
{
Console.WriteLine("This characteristic supports reading from it.");
}
if (properties.HasFlag(GattCharacteristicProperties.Write))
{
Console.WriteLine("This characteristic supports reading from it.");
}
if (properties.HasFlag(GattCharacteristicProperties.Notify))
{
Console.WriteLine("This characteristic supports subscribing to notifications.");
}
GattCommunicationStatus status = await dfuVersionCharacteristics[0].WriteClientCharacteristicConfigurationDescriptorAsync(
GattClientCharacteristicConfigurationDescriptorValue.Notify);
if (status == GattCommunicationStatus.Success)
{
Console.WriteLine("Success");
dfuVersionCharacteristics[0].ValueChanged += Characteristic_ValueChanged;
// ...
void Characteristic_ValueChanged(GattCharacteristic sender,
GattValueChangedEventArgs args)
{
Console.WriteLine("Characteristic_ValueChanged");
// An Indicate or Notify reported that the value has changed.
var reader = DataReader.FromBuffer(args.CharacteristicValue);
Console.WriteLine("Read:" + reader.ReadString(10));
}
}
}catch (Exception e)
{
Console.WriteLine("Error " + e.StackTrace);
}
Console.ReadLine();
}
private async void ConnectButton_Click()
{
ConnectButton.IsEnabled = false;
if (!await ClearBluetoothLEDeviceAsync())
{
rootPage.NotifyUser("Error: Unable to reset state, try again.", NotifyType.ErrorMessage);
ConnectButton.IsEnabled = false;
return;
}
try
{
// BT_Code: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent.
bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(rootPage.SelectedBleDeviceId);
if (bluetoothLeDevice == null)
{
rootPage.NotifyUser("Failed to connect to device.", NotifyType.ErrorMessage);
}
}
catch (Exception ex) when(ex.HResult == E_DEVICE_NOT_AVAILABLE)
{
rootPage.NotifyUser("Bluetooth radio is not on.", NotifyType.ErrorMessage);
}
if (bluetoothLeDevice != null)
{
// Note: BluetoothLEDevice.GattServices property will return an empty list for unpaired devices. For all uses we recommend using the GetGattServicesAsync method.
// BT_Code: GetGattServicesAsync returns a list of all the supported services of the device (even if it's not paired to the system).
GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync(BluetoothCacheMode.Uncached);
if (result.Status == GattCommunicationStatus.Success)
{
var services = result.Services;
rootPage.NotifyUser(String.Format("Found {0} services", services.Count), NotifyType.StatusMessage);
foreach (var service in services)
{
ServiceCollection.Add(new BluetoothLEAttributeDisplay(service));
}
ConnectButton.Visibility = Visibility.Collapsed;
ServiceList.Visibility = Visibility.Visible;
}
else
{
rootPage.NotifyUser("Device unreachable", NotifyType.ErrorMessage);
}
}
ConnectButton.IsEnabled = true;
}
/// <summary>
/// Connect to paired device
/// </summary>
/// <returns></returns>
public async Task <bool> ConnectAsync()
{
Identity auth = new Identity();
DeviceInformation device = await auth.GetPairedBand();
if (device != null)
{
Gatt.bluetoothLEDevice = await BluetoothLEDevice.FromIdAsync(device.Id);
return(Gatt.bluetoothLEDevice != null);
}
return(false);
}
/// <summary>
/// Attempts to pair to a BLE device, by ID
/// </summary>
/// <param name="deviceId">The BLE device ID</param>
/// <returns></returns>
public async Task PairToDeviceAsync(string deviceId)
{
// Get bluetooth device info
using var device = await BluetoothLEDevice.FromIdAsync(deviceId).AsTask();
// Null guard
if (device == null)
{
// TODO: Localize
throw new ArgumentNullException("Failed to get information about the Bluetooth device");
}
// If we are already paired...
if (device.DeviceInformation.Pairing.IsPaired)
{
// Do nothing
return;
}
// Listen out for pairing request
device.DeviceInformation.Pairing.Custom.PairingRequested += (sender, args) =>
{
// Log it
// TODO: Remove
Console.WriteLine("Accepting pairing request...");
// Accept all attempts
args.Accept(); // <-- Could enter a pin in here to accept
};
// Try and pair to the device
var result = await device.DeviceInformation.Pairing.Custom.PairAsync(
// For Contour we should try Provide Pin
// TODO: Try different types to see if any work
DevicePairingKinds.ProvidePin
).AsTask();
// Log the result
if (result.Status == DevicePairingResultStatus.Paired)
{
// TODO: Remove
Console.WriteLine("Pairing successful");
}
else
{
// TODO: Remove
Console.WriteLine($"Pairing failed: {result.Status}");
}
}
/// <summary>
/// Connects to the device.
/// </summary>
public async Task ConnectAsync()
{
Console.WriteLine("Connecting to LOGITOW device: " + deviceInfo.Id);
try
{
bluetoothLEDevice = await BluetoothLEDevice.FromIdAsync(deviceInfo.Id);
OnConnectionStatusUpdate(bluetoothLEDevice, BluetoothConnectionStatus.Connected);
await RegisterNotificationsAsync();
}
catch (Exception e)
{
OnConnectionError(e);
}
}
protected async override void OnNavigatedTo(NavigationEventArgs args)
{
var di = args.Parameter as DeviceInformation;
uiProgress.IsActive = true;
var ble = await BluetoothLEDevice.FromIdAsync(di.Id);
Sensything.ble = ble;
Sensything.Status.OnBluetoothStatus += Status_OnBluetoothStatus;
Sensything.PropertyChanged += Sensything_PropertyChanged;
await Sensything.StartDataNotifications();
uiProgress.IsActive = false;
}
public static async Task <MiDeviceData> Do()
{
IEnumerable <DeviceInformation> devices = await DiscoverDevices();
foreach (DeviceInformation device in devices)
{
using (var mi_device = await BluetoothLEDevice.FromIdAsync(device.Id))
{
MiDeviceData datas = await GetData(mi_device);
Console.WriteLine($"device : {device.Id} : {datas.Moisture}/{datas.Temperature}");
}
}
return(null);
}
/// <summary>
/// Static method to make it easier to create this class form a DeviceInformation object or any other
/// object containing the devide ID.
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public static async Task <NotificationConsumer> FromDeviceIdAsync(string deviceId)
{
BluetoothLEDevice device;
try
{
device = await BluetoothLEDevice.FromIdAsync(deviceId);
}
catch (Exception e)
{
throw e;
}
return(new NotificationConsumer(device));
}
async void ConnectDevice(DeviceInformation deviceInfo)
{
// Note: BluetoothLEDevice.FromIdAsync must be called from a UI thread because it may prompt for consent.
BluetoothLEDevice bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(deviceInfo.Id);
// ...
GattDeviceServicesResult result = await bluetoothLeDevice.GetGattServicesAsync();
if (result.Status == GattCommunicationStatus.Success)
{
var services = result.Services;
// ...
}
}
public async void StartReceivingData()
{
leDevice = await BluetoothLEDevice.FromIdAsync(device.Id);
string selector = "(System.DeviceInterface.Bluetooth.DeviceAddress:=\"" + leDevice.BluetoothAddress.ToString("X") + "\")";
watcher = DeviceInformation.CreateWatcher(selector);
watcher.Added += Watcher_Added;
watcher.Removed += Watcher_Removed;
watcher.Start();
timer.Interval = new TimeSpan(0, 0, 1);
timer.Tick += Timer_Tick;
timer.Start();
}
public async Task EnterBootloader()
{
var bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(options.DeviceId);
var svc = (await bluetoothLeDevice.GetGattServicesForUuidAsync(new Guid("0000fe59-0000-1000-8000-00805f9b34fb")))
.Services.Single();
var chars = (await svc.GetCharacteristicsForUuidAsync(new Guid("8ec90003-f315-4f60-9fb8-838830daea50"))).Characteristics.Single();
await chars.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Indicate);
byte[] data = { 0x01 };
//chars.ValueChanged += Chars_ValueChanged;
await chars.WriteValueAsync(data.AsBuffer());
return;
}
// Pairs device with Sensortag
public async Task PairSensorTagAsync()
{
device = await BluetoothLEDevice.FromBluetoothAddressAsync(bleadress);
bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(device.DeviceId);
var status = await device.DeviceInformation.Pairing.PairAsync();
await GetGATTServicesDataAsync(device);
}
public async Task Connect(DeviceInfo deviceInfo)
{
Disconnect();
ConnectedDevice = await BluetoothLEDevice.FromIdAsync(deviceInfo.DeviceId);
if (ConnectedDevice == null)
{
return;
}
deviceInfo.MacAddress = ConnectedDevice.BluetoothAddress.ToMacAddressString();
deviceInfo.Name = ConnectedDevice.Name;
_infoManager.SaveDevice(deviceInfo);
}
async void MDevice_ConnectionStatusChanged(BluetoothLEDevice sender, object args)
{
mDevice = sender;
Deregister();
if (sender.ConnectionStatus == BluetoothConnectionStatus.Disconnected)
{
Debug.WriteLine("Reconnecting...");
await BluetoothLEDevice.FromIdAsync(sender.DeviceId).AsTask().ContinueWith((obj) => { ConnectionComplete(obj.Result); });
}
else
{
ConnectionComplete(sender);
}
Debug.WriteLine("MDevice_ConnectionStatusChanged end.");
}
/// <summary>
/// Connect to the desired device.
/// </summary>
/// <param name="deviceName"></param>
public async void selectDevice(string deviceName)
{
foreach (DeviceInformation di in await DeviceInformation.FindAllAsync(BluetoothLEDevice.GetDeviceSelector()))
{
BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromIdAsync(di.Id);
// Check if the name of the device founded is EMU Bridge.
if (bleDevice.Name == deviceName)
{
// Save detected device in the current device variable.
currentDevice = bleDevice;
break;
}
}
}
private async Task <bool> ConnectDeviceAsync(BleDevice device)
{
try
{
var bleDevice = await BluetoothLEDevice.FromIdAsync(device.Guid);
_Connected.Add(bleDevice);
return(true);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("BleClient.ConnectDeviceAsync - Exception: {0}", ex);
return(false);
}
}
protected async override void OnNavigatedTo(NavigationEventArgs args)
{
SetStatusActive(true);
var di = args.Parameter as DeviceInformationWrapper;
if (di.SerialPortPreferences == null)
{
// Make sure we set up good defaults.
const string DefaultShortcutId = "CraftyRobot-Smartibot";
di.SerialPortPreferences = new UserSerialPortPreferences()
{
LineEnd = UserSerialPortPreferences.TerminalLineEnd.CR,
SavePrefix = "CraftyRobot_Smartibot_",
ShortcutId = DefaultShortcutId, // must match the Id value in CraftyRobot_Smartibot_Commands.json
};
di.SerialPortPreferences.ReadFromLocalSettings();
if (di.SerialPortPreferences.ShortcutId == "(name)")
{
di.SerialPortPreferences.ShortcutId = DefaultShortcutId;
}
}
var ble = await BluetoothLEDevice.FromIdAsync(di.di.Id);
SetStatusActive(false);
// // // bleDevice.ble = ble;
// // // bleDevice.Status.OnBluetoothStatus += bleDevice_OnBluetoothStatus;
Uart = new Nordic_Uart(ble);
await Uart.EnsureCharacteristicAsync();
Uart.Status.OnBluetoothStatus += bleDevice_OnBluetoothStatus;
// NOTE: check for status?
// Set up the terminal adapter, connecting the terminal control and the bluetooth device.
TerminalAdapter = new nRFUartTerminalAdapter(uiTerminalControl, Uart);
uiTerminalControl.ParentTerminal = this;
uiTerminalControl.UserCanSetSerialLineEndings = false;
// the adapter tells the terminal control to display the status.
// The terminal control would rather we display the status.
await TerminalAdapter.InitAsync();
uiTerminalControl.DI = di;
// Get the buttons to show!
uiTerminalControl.UpdateShortcutButtons();
}
public async Task ConnectAsync()
{
if (!await IsBluetoothEnabledAsync())
{
throw new Exception("Bluetooth is not enabled.");
}
if (!await IsBluetoothSupportedAsync())
{
throw new Exception("Bluetooth is not supportet.");
}
bluetoothLeDevice = await BluetoothLEDevice.FromIdAsync(deviceId);
if (bluetoothLeDevice == null)
{
throw new Exception("iGrill not found");
}
// Event for connection status changed
bluetoothLeDevice.ConnectionStatusChanged += (BluetoothLEDevice device, object obj) =>
{
Debug.WriteLine("Connection status changed to: " + device.ConnectionStatus);
ConnectionStatusChanged?.Invoke(device, device.ConnectionStatus);
};
// Read basic device information like name, etc.
this.DeviceName = await genericService.GetDeviceNameAsync(bluetoothLeDevice);
this.FirmwareVersion = await genericService.GetFirmwareVersionAsync(bluetoothLeDevice);
// Read battery level and register for updates
batteryService.BatteryLevelChanged += (sender, level) =>
{
this.BatteryLevelChanges?.Invoke(sender, level);
};
await batteryService.RegisterForBatteryChanges(bluetoothLeDevice);
// Authenticate iGrill to read probes
await authenticationService.Authenticate(bluetoothLeDevice);
// Read probes and register for updates
temperatureService.TemperatureChanged += (sender, args) =>
{
this.TemperatureChanged?.Invoke(sender, args);
};
await temperatureService.RegisterForTemperatureChanges(bluetoothLeDevice);
}
/// <summary>
/// Asynchronous call to re-populate the ListBox of paired devices.
/// </summary>
private async void RefreshPairedDevicesList()
{
FindPairedDevices.IsEnabled = false;
ConnectingIndicator.Visibility = Windows.UI.Xaml.Visibility.Visible;
try
{
// Search for all paired devices
string genericUUID = GattDeviceService.GetDeviceSelectorFromUuid(Guid.Parse(BLEDeviceConstants.HM_10_CONF));
//string genericUUID = GattDeviceService.GetDeviceSelectorFromUuid(GattServiceUuids.GenericAccess);
var peers = await DeviceInformation.FindAllAsync(genericUUID);
// By clearing the backing data, we are effectively clearing the ListBox
_pairedDevices.Clear();
if (peers.Count == 0)
{
await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings-bluetooth:", UriKind.RelativeOrAbsolute));
}
else
{
// Found paired devices.
foreach (var peer in peers)
{
try
{
BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromIdAsync(peer.Id);
if (bleDevice.Name == "MyTeletouch")
{
_pairedDevices.Add(new PairedDeviceInfo(bleDevice));
}
}
catch (Exception)
{
}
}
}
}
catch /*(Exception ex)*/
{
}
finally
{
FindPairedDevices.IsEnabled = true;
ConnectingIndicator.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
EmptyIndicator.Visibility = _pairedDevices.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
}
}