private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
lock (this)
{
//Debug.WriteLine(String.Format("Removed {0}{1}", deviceInfoUpdate.Id, ""));
if (sender == deviceWatcher)
{
BluetoothLEDeviceDisplay bleDeviceDisplay = FindBluetoothLEDeviceDisplay(deviceInfoUpdate.Id);
if (bleDeviceDisplay != null)
{
KnownDevices.Remove(bleDeviceDisplay);
}
DeviceInformation deviceInfo = FindUnknownDevices(deviceInfoUpdate.Id);
if (deviceInfo != null)
{
UnknownDevices.Remove(deviceInfo);
}
}
}
});
}
private async void StartGattServiceWatcher()
{
//Get the Bluetooth address for filtering the watcher
BluetoothLEDeviceDisplay deviceInfoDisp = resultsListView.SelectedItem as BluetoothLEDeviceDisplay;
BluetoothLEDevice bleDevice = await BluetoothLEDevice.FromIdAsync(deviceInfoDisp.Id);
string selector = "(" + GattDeviceService.GetDeviceSelectorFromUuid(IoServiceUuid) + ")"
+ " AND (System.DeviceInterface.Bluetooth.DeviceAddress:=\""
+ bleDevice.BluetoothAddress.ToString("X") + "\")";
gattServiceWatcher = DeviceInformation.CreateWatcher(selector);
// Hook up handlers for the watcher events before starting the watcher
gattServiceWatcher.Added += new TypedEventHandler <DeviceWatcher, DeviceInformation>(async(watcher, deviceInfo) =>
{
// If the selected device is a WeDo device, enable the controls
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
weDoIoService = await GattDeviceService.FromIdAsync(deviceInfo.Id);
outputCommandCharacteristic = weDoIoService.GetCharacteristics(OutputCommandCharacteristicGuid)[0];
ForwardButton.IsEnabled = true;
StopButton.IsEnabled = true;
BackwardButton.IsEnabled = true;
});
});
gattServiceWatcher.Updated += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.EnumerationCompleted += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.Removed += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.Stopped += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
//Do nothing
});
});
gattServiceWatcher.Start();
}
private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate)
{
// We must update the collection on the UI thread because the collection is databound to a UI element.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
lock (this)
{
Debug.WriteLine(String.Format("Removed {0}{1}", deviceInfoUpdate.Id, ""));
// Protect against race condition if the task runs after the app stopped the deviceWatcher.
if (sender == deviceWatcher)
{
// Find the corresponding DeviceInformation in the collection and remove it.
BluetoothLEDeviceDisplay bleDeviceDisplay = FindBluetoothLEDeviceDisplay(deviceInfoUpdate.Id);
if (bleDeviceDisplay != null)
{
KnownDevices.Remove(bleDeviceDisplay);
}
DeviceInformation deviceInfo = FindUnknownDevices(deviceInfoUpdate.Id);
if (deviceInfo != null)
{
UnknownDevices.Remove(deviceInfo);
}
}
}
});
}
private async void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate)
{
// We must update the collection on the UI thread because the collection is databound to a UI element.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
lock (this)
{
Debug.WriteLine(String.Format("Updated {0}{1}", deviceInfoUpdate.Id, ""));
// Protect against race condition if the task runs after the app stopped the deviceWatcher.
if (sender == deviceWatcher)
{
BluetoothLEDeviceDisplay bleDeviceDisplay = FindBluetoothLEDeviceDisplay(deviceInfoUpdate.Id);
if (bleDeviceDisplay != null)
{
// Device is already being displayed - update UX.
bleDeviceDisplay.Update(deviceInfoUpdate);
return;
}
DeviceInformation deviceInfo = FindUnknownDevices(deviceInfoUpdate.Id);
if (deviceInfo != null)
{
deviceInfo.Update(deviceInfoUpdate);
// If device has been updated with a friendly name it's no longer unknown.
if (deviceInfo.Name != String.Empty)
{
KnownDevices.Add(new BluetoothLEDeviceDisplay(deviceInfo));
UnknownDevices.Remove(deviceInfo);
}
}
}
}
});
}
private async void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate)
{
// We must update the collection on the UI thread because the collection is databound to a UI element.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Protect against race condition if the task runs after the app stopped the deviceWatcher.
if (sender == deviceWatcher)
{
BluetoothLEDeviceDisplay bleDeviceDisplay = FindBluetoothLEDeviceDisplay(deviceInfoUpdate.Id);
if (bleDeviceDisplay != null)
{
bleDeviceDisplay.Update(deviceInfoUpdate);
}
}
});
}
private async void UnpairButton_Click(object sender, RoutedEventArgs e)
{
// Gray out the unpair button and results view while unpairing is in progress.
resultsListView.IsEnabled = false;
UnpairButton.IsEnabled = false;
rootPage.NotifyUser("Unpairing started. Please wait...", NotifyType.StatusMessage);
BluetoothLEDeviceDisplay deviceInfoDisp = resultsListView.SelectedItem as BluetoothLEDeviceDisplay;
DeviceUnpairingResult dupr = await deviceInfoDisp.DeviceInformation.Pairing.UnpairAsync();
rootPage.NotifyUser(
"Unpairing result = " + dupr.Status.ToString(),
dupr.Status == DeviceUnpairingResultStatus.Unpaired ? NotifyType.StatusMessage : NotifyType.ErrorMessage);
UpdateButtons();
resultsListView.IsEnabled = true;
}
private void UpdateButtons()
{
BluetoothLEDeviceDisplay deviceInfoDisp = (BluetoothLEDeviceDisplay)resultsListView.SelectedItem;
//Reset the device control buttons to disabled
ForwardButton.IsEnabled = false;
StopButton.IsEnabled = false;
BackwardButton.IsEnabled = false;
//Update pairing buttons based on IsPaired state
if (null != deviceInfoDisp && !deviceInfoDisp.DeviceInformation.Pairing.IsPaired)
{
PairButton.IsEnabled = true;
}
else
{
PairButton.IsEnabled = false;
}
if (null != deviceInfoDisp &&
deviceInfoDisp.DeviceInformation.Pairing.IsPaired)
{
UnpairButton.IsEnabled = true;
}
else
{
UnpairButton.IsEnabled = false;
}
//Stop any existing service watcher
if (gattServiceWatcher != null)
{
StopGattServiceWatcher();
}
//If there is a paired device selected, look for the WeDo service and enable controls if found
if (deviceInfoDisp != null)
{
if (deviceInfoDisp.IsPaired == true)
{
StartGattServiceWatcher();
}
}
}
private void StartBleDeviceWatcher()
{
//Reset displayed results
ResultCollection.Clear();
// Request additional properties
string[] requestedProperties = new string[] { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
deviceWatcher = DeviceInformation.CreateWatcher("(System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\")",
requestedProperties,
DeviceInformationKind.AssociationEndpoint);
// Hook up handlers for the watcher events before starting the watcher
deviceWatcher.Added += new TypedEventHandler <DeviceWatcher, DeviceInformation>(async(watcher, deviceInfo) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ResultCollection.Add(new BluetoothLEDeviceDisplay(deviceInfo));
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Updated += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
foreach (BluetoothLEDeviceDisplay bleInfoDisp in ResultCollection)
{
if (bleInfoDisp.Id == deviceInfoUpdate.Id)
{
bleInfoDisp.Update(deviceInfoUpdate);
// If the item being updated is currently "selected", then update the pairing buttons
BluetoothLEDeviceDisplay selectedDeviceInfoDisp = (BluetoothLEDeviceDisplay)resultsListView.SelectedItem;
if (bleInfoDisp == selectedDeviceInfoDisp)
{
UpdateButtons();
}
break;
}
}
});
});
deviceWatcher.EnumerationCompleted += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Enumeration completed. Watching for updates...", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Removed += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Find the corresponding DeviceInformation in the collection and remove it
foreach (BluetoothLEDeviceDisplay bleInfoDisp in ResultCollection)
{
if (bleInfoDisp.Id == deviceInfoUpdate.Id)
{
ResultCollection.Remove(bleInfoDisp);
break;
}
}
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Stopped += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Watcher {1}.",
ResultCollection.Count,
DeviceWatcherStatus.Aborted == watcher.Status ? "aborted" : "stopped"),
NotifyType.StatusMessage);
});
});
deviceWatcher.Start();
}
