private async void Watcher_DeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { // Since we have the collection databound to a UI element, we need to update the collection on the UI thread. await dispatcher.RunAsync(CoreDispatcherPriority.Low, () => { // Watcher may have stopped while we were waiting for our chance to run. if (IsWatcherStarted(sender)) { // Find the corresponding DeviceInformation in the collection and remove it foreach (DeviceInformationDisplay deviceInfoDisp in resultCollection) { if (deviceInfoDisp.Id == deviceInfoUpdate.Id) { resultCollection.Remove(deviceInfoDisp); break; } } RaiseDeviceChanged(sender, deviceInfoUpdate.Id); } }); }
private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfo) { await Task.Run(() => { lock (this) { Console.WriteLine(string.Format("Removed {0}{1}", deviceInfo.Id, "")); // Protect against race condition if the task runs after the app stopped the deviceWatcher. if (sender == deviceWatcher) { // 更新 var blueDisp = FindBluetoothLEDeviceDisplay(deviceInfo.Id); if (blueDisp != null) { Devices.Remove(blueDisp); DevicesDisplay.Renew(Devices); } } } }); }
async void watcher_Updated(Windows.Devices.Enumeration.DeviceWatcher sender, DeviceInformationUpdate devUpdate) { int count2 = 0; foreach (DeviceInformation deviceInterface in interfaces) { if (count2 < count) { if (interfaces[count2].Id == devUpdate.Id) { //Update the element. interfaces[count2].Update(devUpdate); } } count2 += 1; } await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { OutputText.Text = "Enumeration updated: Device added "; DisplayDeviceInterfaceArray(); }); }
private void OnBleDeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate deviceInformationUpdate) { var ignoreContinuation = this.dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (sender == this.bleDeviceWatcher && this.allBleDevices.ContainsKey(deviceInformationUpdate.Id)) { bool removeDevice = true; for (int i = 0; i < this.model.AllSupportedBleDevices.Count; ++i) { if (this.model.AllSupportedBleDevices[i].Id == deviceInformationUpdate.Id) { if (this.model.AllSupportedBleDevices[i].CanBeDeletedByWatcher) { if (this.model.WirelessLineSensorDeviceModel.Id == deviceInformationUpdate.Id) { this.model.WirelessLineSensorDeviceModel.DisconnectCommand.Execute(this.model.WirelessLineSensorDeviceModel); } this.model.AllSupportedBleDevices.RemoveAt(i); if (this.model.SelectedBleDevice == null || this.model.SelectedBleDevice.Id == deviceInformationUpdate.Id) { this.model.SelectedBleDevice = this.model.AllSupportedBleDevices.Count <= 0 ? null : this.model.AllSupportedBleDevices[0]; } } else { removeDevice = false; } break; } } if (removeDevice) { this.allBleDevices.Remove(deviceInformationUpdate.Id); } } }); }
private async void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { await Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() => { lock (this) { 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) { dict.Add(deviceInfo.Name, deviceInfo); DeviceList.Items.Add(new System.Windows.Controls.ListViewItem { Content = deviceInfo.Name }); KnownDevices.Add(new BluetoothLEDeviceDisplay(deviceInfo)); deviceQueue.Enqueue(deviceInfo.Name); UnknownDevices.Remove(deviceInfo); ConnectDevice(); } } Update_DeviceList(); } } })); }
private async void Watcher_DeviceUpdated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { // Since we have the collection databound to a UI element, we need to update the collection on the UI thread. await dispatcher.RunAsync(CoreDispatcherPriority.Low, () => { // Watcher may have stopped while we were waiting for our chance to run. if (IsWatcherStarted(sender)) { // Find the corresponding updated DeviceInformation in the collection and pass the update object // to the Update method of the existing DeviceInformation. This automatically updates the object // for us. foreach (DeviceInformationDisplay deviceInfoDisp in resultCollection) { if (deviceInfoDisp.Id == deviceInfoUpdate.Id) { deviceInfoDisp.Update(deviceInfoUpdate); RaiseDeviceChanged(sender, deviceInfoUpdate.Id); break; } } } }); }
private async void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate deviceInfo) { if (!deviceInfo.Properties.ContainsKey("System.Devices.Aep.SignalStrength") || deviceInfo.Properties["System.Devices.Aep.SignalStrength"] == null) { return; } // 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) { int rssi = Math.Abs((int)deviceInfo.Properties["System.Devices.Aep.SignalStrength"]); if (deviceInfo.Id == DeviceIdToTrack3) { Track3(deviceInfo.Id, rssi); } if (deviceInfo.Id == DeviceIdToTrack5) { Track5(deviceInfo.Id, rssi); } } }); }
private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { // Collections bound to the UI are updated in the UI thread. await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { // Find the device for the given id and remove it from the list. foreach (DeviceInformation device in this.devices) { if (device.Id == deviceInfoUpdate.Id) { this.devices.Remove(device); break; } } if (audioPlaybackConnections.ContainsKey(deviceInfoUpdate.Id)) { AudioPlaybackConnection connectionToRemove = audioPlaybackConnections[deviceInfoUpdate.Id]; connectionToRemove.Dispose(); this.audioPlaybackConnections.Remove(deviceInfoUpdate.Id); } }); }
private void OnDeviceUpdated(DeviceWatcher sender, DeviceInformationUpdate update) { object value; if (!update.Properties.TryGetValue("System.Devices.InterfaceEnabled", out value)) { return; } lock (this.devices) { if ((bool)value) { this.devices.Add(update.Id); } else { this.devices.Remove(update.Id); } this.isCameraAvailable = this.devices.Count > 0; } }
/// <summary>Fired when the device is changed</summary> /// <param name="sender"></param> /// <param name="updateInfo"></param> private void DevWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate updateInfo) { this.log.Info("DevWatcher_Updated", "------------------------------ START -----------------------------------------------------"); this.log.Info("DevWatcher_Updated", () => string.Format("***** {0}", updateInfo.Id)); WrapErr.ToErrReport(9999, () => { BLE_PropertiesUpdateDataModel dm = updateInfo.CreatePropertiesUpdateData(); this.DeviceUpdated?.Invoke(this, dm); //this.devic //if (updateInfo.Properties != null) { // foreach (var p in updateInfo.Properties) { // string value = "Unhandled"; // switch (p.Key) { // case "System.Devices.Aep.ContainerId": // case "Id": // case "System.ItemNameDisplay": // * // case "System.Devices.Icon": // case "System.Devices.GlyphIcon": // value = (string)p.Value; // break; // case "System.Devices.Aep.IsPaired": // * // case "System.Devices.Aep.IsConnected": // case "System.Devices.Aep.IsConnectable": // case "System.Devices.Aep.CanPair": // * // value = string.Format("{0}", (bool)p.Value); // break; // // "System.Devices.Icon" // // "System.Devices.GlyphIcon" // } // this.log.Info("DevWatcher_Updated", () => string.Format(" Property:{0} Value:{1}", p.Key, value)); // } //} }); this.log.Info("DevWatcher_Updated", "------------------------------ END -----------------------------------------------------"); }
private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { await Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(() => { lock (this) { if (sender == deviceWatcher) { // Find the corresponding DeviceInformation in the collection and remove it. BluetoothLEDeviceDisplay bleDeviceDisplay = FindBluetoothLEDeviceDisplay(deviceInfoUpdate.Id); DeviceInformation deviceInfo = FindUnknownDevices(deviceInfoUpdate.Id); if (bleDeviceDisplay != null) { KnownDevices.Remove(bleDeviceDisplay); dict.Remove(bleDeviceDisplay.Name); if (deviceQueue.Count > 0) { while (deviceQueue.Contains(bleDeviceDisplay.Name)) { var ck = deviceQueue.Dequeue(); if (!ck.Equals(bleDeviceDisplay.Name)) { deviceQueue.Enqueue(ck); } } } } if (deviceInfo != null) { UnknownDevices.Remove(deviceInfo); } Update_DeviceList(); } } })); }
private async void BluetoothWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate args) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { lock (Locker) { try { if (BluetoothDeviceCollection != null) { foreach (var Bluetooth in from BluetoothList Bluetooth in BluetoothDeviceCollection where Bluetooth.Id == args.Id select Bluetooth) { Bluetooth.Update(args); } } } catch (Exception) { } } }); }
private async void Watcher_Updated(DeviceWatcher sender, DeviceInformationUpdate args) { await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { //If enumeration completes, update UI and transition watcher to the stopped state rootPage.NotifyUser("Watcher received an update for a listed device", NotifyType.StatusMessage); //Go through our list of device until you find the DeviceInformation object that is updated. DeviceInformation updateDevice = null; foreach (DeviceInformation currentDevice in this.castingDevicesList.Items) { if (currentDevice.Id == args.Id) { updateDevice = currentDevice; break; } } //Update the DeviceInformation object. if (updateDevice != null) { updateDevice.Update(args); } }); }
private void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { if (sender != deviceWatcher) { return; } DeviceInformation di_torem = null; foreach (DeviceInformation di in devices) { if (di.Id == deviceInfoUpdate.Id) { di_torem = di; break; } } if (di_torem != null) { devices.Remove(di_torem); } VerboseDebug("Lost device " + deviceInfoUpdate.Id); }
private void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { if (sender == deviceWatcher) { this.Dispatcher.Invoke(async() => { BluetoothLEDeviceDisplay bleDeviceDisplay = FindBluetoothLEDeviceDisplay(deviceInfoUpdate.Id); if (bleDeviceDisplay != null) { bleDeviceDisplay.Update(deviceInfoUpdate); return; } else { var deviceInfo = await DeviceInformation.CreateFromIdAsync(deviceInfoUpdate.Id); if ((bool)deviceInfo.Properties["System.Devices.Aep.Bluetooth.Le.IsConnectable"]) { bleDeviceDisplay = new BluetoothLEDeviceDisplay(deviceInfo); KnownDevices.Add(bleDeviceDisplay); } } }); } }
private async void BluetoothDeviceWatcher_UpdatedAsync(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { // We must update the collection on the UI thread because the collection is databound to a UI element. // use Microsoft.Toolkit.Uwp.Helpers extensions await DispatcherHelper.ExecuteOnUIThreadAsync(() => { // Protect against race condition if the task runs after the app stopped the deviceWatcher. if (sender == bluetoothDeviceWatcher) { var bluetoothDevice = FindKnownBluetoothDevice(deviceInfoUpdate.Id); if (bluetoothDevice != null) { // Device is already being displayed - update UI. bluetoothDevice.Update(deviceInfoUpdate); if (!FilterBluetoothDevice(bluetoothDevice.DeviceInformation)) { KnownBluetoothDevices.Remove(bluetoothDevice); UnknownBluetoothDevices.Add(bluetoothDevice.DeviceInformation); } return; } DeviceInformation deviceInfo = FindUnknownBluetoothDevice(deviceInfoUpdate.Id); if (deviceInfo != null) { deviceInfo.Update(deviceInfoUpdate); // If device has been updated if (FilterBluetoothDevice(deviceInfo)) { KnownBluetoothDevices.Add(new BluetoothDeviceItem(deviceInfo)); UnknownBluetoothDevices.Remove(deviceInfo); } } } }); }
private async void HIDDeviceUpdated(DeviceWatcher sender, DeviceInformationUpdate args) { DeviceInformation device_info = await DeviceInformation.CreateFromIdAsync(args.Id); // Do not let the background task starve, check if we are paired then connect to the keyboard if (device_info.Name.Contains("ANNE")) { if (device_info.IsEnabled) { FindKeyboard(); } else { await Dispatcher.RunAsync(CoreDispatcherPriority.High, () => { KeyboardDeviceInformation = null; connectionStatusLabel.Text = "Not Connected"; connectionStatusLabel.Foreground = new SolidColorBrush(Colors.Red); LightSyncButton.IsEnabled = false; LayoutSyncButton.IsEnabled = false; }); } } }
private void Watcher_DeviceUpdated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { // Watcher may have stopped while we were waiting for our chance to run. if (IsWatcherStarted(sender)) { // Find the corresponding updated DeviceInformation in the collection and pass the update object // to the Update method of the existing DeviceInformation. This automatically updates the object // for us. foreach (DeviceInformation deviceInfo in resultCollection) { if (deviceInfo.Id.Equals(deviceInfoUpdate.Id)) { bool oldIsPaired = deviceInfo.Pairing.IsPaired; deviceInfo.Update(deviceInfoUpdate); bool newIsPaired = deviceInfo.Pairing.IsPaired; if (IsPairedOnly && (oldIsPaired != newIsPaired)) { if (newIsPaired) { RaiseDeviceChanged(sender, DeviceWatchEvent.Added, deviceInfo); } else { RaiseDeviceChanged(sender, DeviceWatchEvent.Removed, deviceInfo); } } else { RaiseDeviceChanged(sender, DeviceWatchEvent.Updated, deviceInfo); } break; } } } }
/// <summary> /// Executes when a device is updated /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="deviceInfoUpdate">The update device information.</param> private async void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { if (sender == _deviceWatcher) { ObservableBluetoothLEDevice device = null; device = BluetoothLeDevices.FirstOrDefault(i => i.DeviceInfo.Id == deviceInfoUpdate.Id); if (device != null) { await device.UpdateAsync(deviceInfoUpdate); } if (device == null) { if (_readerWriterLockSlim.TryEnterWriteLock(TimeSpan.FromSeconds(2))) { var unusedDevice = _unusedDevices.FirstOrDefault(i => i.Id == deviceInfoUpdate.Id); if (unusedDevice != null) { _unusedDevices.Remove(unusedDevice); unusedDevice.Update(deviceInfoUpdate); } _readerWriterLockSlim.ExitWriteLock(); // The update to the unknown device means we should move it to the Bluetooth LE Device collection. if (unusedDevice != null) { await AddDeviceToList(unusedDevice); } } } } }
/// <summary> /// Called when a BLE device is removed from the system. /// </summary> /// <param name="sender"></param> /// <param name="deviceInfoUpdate"></param> private void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate deviceInfoUpdate) { lock (this) { Console.WriteLine(System.String.Format("Removed {0}, {1}", deviceInfoUpdate.Id, "")); //Making sure that we are processing device from the current device watcher. if (sender == deviceWatcher) { //Find the corresponding DeviceInformation in the collection and remove it. LogitowDevice logitowDevice = GetDiscoveredLogitowDevice(deviceInfoUpdate.Id); if (logitowDevice != null) { discoveredDevices.Remove(logitowDevice); eventListener.OnDeviceLost(logitowDevice.deviceInfo.Id); } DeviceInformation unknownDevice = GetUnknownDevice(deviceInfoUpdate.Id); if (unknownDevice != null) { unknownDevices.Remove(unknownDevice); } } } }
private async void DeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate args) { var drives = DriveInfo.GetDrives().Select(x => x.Name); foreach (var drive in Drives) { if (drive.Type == DriveType.VirtualDrive || drives.Contains(drive.tag)) { continue; } // Update the collection on the ui-thread. try { CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => { Drives.Remove(drive); }); } catch (Exception e) { // Ui-Thread not yet created. Drives.Remove(drive); } return; } }
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) { // log(String.Format("Updated {0}{1}", deviceInfoUpdate.Id, "")); // Protect against race condition if the task runs after the app stopped the deviceWatcher. if (sender == deviceWatcher) { foreach (BLEDevice b in KnownDevices) { if (b.id == deviceInfoUpdate.Id) { b.di.Update(deviceInfoUpdate); b.Name = b.di.Name; } } } } }); }
private async void BluetoothWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { lock (SyncRootProvider.SyncRoot) { try { if (BluetoothDeviceCollection != null) { for (int i = 0; i < BluetoothDeviceCollection.Count; i++) { if (BluetoothDeviceCollection[i].Id == args.Id) { BluetoothDeviceCollection.RemoveAt(i); i--; } } } } catch (Exception) { } } }); }
private void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate args) { }
private void Watcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args) { //throw new NotImplementedException(); }
private void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args) { Removed?.Invoke(sender, args); }
private void DeviceWatcher_Updated(DeviceWatcher sender, DeviceInformationUpdate args) { System.Diagnostics.Debug.WriteLine("Update:" + args.Id); }
private void Watcher_Removed(DeviceWatcher sender, DeviceInformationUpdate info) { Log("Removed: " + info.Id); }
public void Update(DeviceInformationUpdate deviceInfoUpdate) { deviceInfo.Update(deviceInfoUpdate); UpdateGlyphBitmapImage(); }
private void DeviceUpdated(DeviceWatcher sender, DeviceInformationUpdate args) { Debug.WriteLine("Devices updated"); }