/// <summary> /// Invoked when the device watcher finds a matching custom sensor device /// </summary> /// <param name="watcher">device watcher</param> /// <param name="customSensorDevice">device information for the custom sensor that was found</param> public async void OnCustomSensorAdded(DeviceWatcher watcher, DeviceInformation customSensorDevice) { try { customSensor = await CustomSensor.FromIdAsync(customSensorDevice.Id); if (customSensor != null) { CustomSensorReading reading = customSensor.GetCurrentReading(); if (!reading.Properties.ContainsKey(CO2LevelKey)) { rootPage.NotifyUser("The found custom sensor doesn't provide CO2 reading", NotifyType.ErrorMessage); customSensor = null; } } else { rootPage.NotifyUser("No custom sensor found", NotifyType.ErrorMessage); } } catch (Exception e) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("The user may have denied access to the custom sensor. Error: " + e.Message, NotifyType.ErrorMessage); }); } }
private void StartWatcher() { DeviceWatcherEventKind[] triggerEventKinds = { DeviceWatcherEventKind.Add, DeviceWatcherEventKind.Remove, DeviceWatcherEventKind.Update }; switch (m_deviceType) { case AudioDeviceType.Input: { m_deviceClass = DeviceClass.AudioRender; break; } case AudioDeviceType.Output: { m_deviceClass = DeviceClass.AudioRender; break; } } m_deviceWatcher = DeviceInformation.CreateWatcher(m_deviceClass); // Get the background trigger for this watcher m_deviceWatcherTrigger = m_deviceWatcher.GetBackgroundTrigger(triggerEventKinds); // Register this trigger for our background task RegisterBackgroundTask(m_deviceWatcherTrigger); }
public async Task <bool> StartAsync() { // only one start allowed on the object lock (this) { if (_started) { return(false); } _started = true; } if (await WiFiAdapter.RequestAccessAsync() != WiFiAccessStatus.Allowed) { return(false); } _started = true; // enumerate and monitor WiFi devices in the system string deviceSelector = WiFiAdapter.GetDeviceSelector(); _watcher = Windows.Devices.Enumeration.DeviceInformation.CreateWatcher(deviceSelector); _watcher.Added += _watcher_Added; _watcher.Removed += _watcher_Removed; _watcher.Start(); return(true); }
private static void HandleDeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate args) { var gamepad = _gamepads[args.Id]; _gamepads.Remove(args.Id); GamepadRemoved?.Invoke(sender, gamepad); }
//public ObservableCollection<clsDevType> DevTypes = new ObservableCollection<clsDevType>(); async void WatchDevices_Click(object sender, RoutedEventArgs eventArgs) { if (watcher != null) { watcher = null; } count = 0; isEnumerationComplete = false; StopStatus = null; //DeviceInterfacesOutputList.Items.Clear(); try { dispatcher = Window.Current.CoreWindow.Dispatcher; watcher = DeviceInformation.CreateWatcher(); // Add event handlers watcher.Added += watcher_Added; watcher.Removed += watcher_Removed; watcher.Updated += watcher_Updated; watcher.EnumerationCompleted += watcher_EnumerationCompleted; watcher.Stopped += watcher_Stopped; watcher.Start(); OutputText.Text = "Enumeration started."; this.btnWatchDevices.IsEnabled = false; this.btnStop.IsEnabled = !(this.btnWatchDevices.IsEnabled); } catch (ArgumentException) { //The ArgumentException gets thrown by FindAllAsync when the GUID isn't formatted properly //The only reason we're catching it here is because the user is allowed to enter GUIDs without validation //In normal usage of the API, this exception handling probably wouldn't be necessary when using known-good GUIDs OutputText.Text = "Caught ArgumentException. Failed to create watcher."; } }
/// <summary> /// Invoked when the device watcher detects that the proximity sensor was added. /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="device">The device that was added.</param> private async void OnProximitySensorAddedAsync(DeviceWatcher sender, DeviceInformation device) { if (this.proximitySensor == null) { var addedSensor = ProximitySensor.FromId(device.Id); if (addedSensor != null) { var minimumDistanceSatisfied = true; //if we care about minimum distance if (this.MinimumDistanceInMillimeters > Int32.MinValue) { if ((this.MinimumDistanceInMillimeters > addedSensor.MaxDistanceInMillimeters) || (this.MinimumDistanceInMillimeters < addedSensor.MinDistanceInMillimeters)) { minimumDistanceSatisfied = false; } } if (minimumDistanceSatisfied) { this.proximitySensor = addedSensor; await SetActiveFromReadingAsync(this.proximitySensor.GetCurrentReading()); this.proximitySensor.ReadingChanged += ProximitySensor_ReadingChangedAsync; } } } }
private void OnDeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate deviceInformationUpdate) { if (Disconnected != null) { Disconnected(); } }
async void watcher_Removed(Windows.Devices.Enumeration.DeviceWatcher sender, DeviceInformationUpdate devUpdate) { ; int count2 = 0; //Convert interfaces array to a list (IList). List <DeviceInformation> interfaceList = new List <DeviceInformation>(interfaces); foreach (DeviceInformation deviceInterface in interfaces) { if (count2 < count) { if (interfaces[count2].Id == devUpdate.Id) { //Remove the element. interfaceList.RemoveAt(count2); } } count2 += 1; } //Convert the list back to the interfaces array. interfaces = interfaceList.ToArray(); count -= 1; await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { OutputText.Text = "Enumeration device was removed. "; DisplayDeviceInterfaceArray(); }); }
static public void StartSearch() { // Additional properties we would like about the device. // Property strings are documented here https://msdn.microsoft.com/en-us/library/windows/desktop/ff521659(v=vs.85).aspx string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected", "System.Devices.Aep.Bluetooth.Le.IsConnectable", "System.Devices.Aep.AepId", "System.Devices.Aep.Category" }; // BT_Code: Example showing paired and non-paired in a single query. string aqsAllBluetoothLEDevices = "(System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\")"; deviceWatcher = DeviceInformation.CreateWatcher( aqsAllBluetoothLEDevices, requestedProperties, DeviceInformationKind.AssociationEndpoint); // Register event handlers before starting the watcher. deviceWatcher.Added -= DeviceWatcher_Added; deviceWatcher.Updated -= DeviceWatcher_Updated; deviceWatcher.Removed -= DeviceWatcher_Removed; deviceWatcher.EnumerationCompleted -= DeviceWatcher_EnumerationCompleted; deviceWatcher.Stopped -= DeviceWatcher_Stopped; deviceWatcher.Added += DeviceWatcher_Added; deviceWatcher.Updated += DeviceWatcher_Updated; deviceWatcher.Removed += DeviceWatcher_Removed; deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted; deviceWatcher.Stopped += DeviceWatcher_Stopped; // Start the watcher. deviceWatcher.Start(); if (_searchMethod == 0) { _autoEvent.WaitOne(); } }
public ExternalDeviceService() { _deviceWatcher = DeviceInformation.CreateWatcher(DeviceClass.PortableStorageDevice); _deviceWatcher.Added += DeviceAdded; _deviceWatcher.Removed += DeviceRemoved; _deviceWatcher.Start(); }
private void DeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate args) { if (ExternalDeviceRemoved != null) { ExternalDeviceRemoved(this, args.Id); } }
public UsbScopeDevice() { var usbScopeSelector = HidDevice.GetDeviceSelector(UsagePage, UsageId, Vid, Pid); ScopeDeviceWatcher = DeviceInformation.CreateWatcher(usbScopeSelector); ScopeDeviceWatcher.Added += new TypedEventHandler<DeviceWatcher, DeviceInformation>(OnDeviceAdded); ScopeDeviceWatcher.Removed += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(OnDeviceRemoved); ScopeDeviceWatcher.Start(); }
public Scenario4_BackgroundProximitySensor() { this.InitializeComponent(); watcher = DeviceInformation.CreateWatcher(ProximitySensor.GetDeviceSelector()); watcher.Added += OnProximitySensorAdded; watcher.Start(); }
private static async void HandleDeviceAdded(DeviceWatcher sender, DeviceInformation args) { var device = await HidDevice.FromIdAsync(args.Id, FileAccessMode.Read); var gamepad = new HidGamepad(args, device); _gamepads.Add(args.Id, gamepad); GamepadAdded?.Invoke(sender, gamepad); }
public NetworkPresenter() { WiFiAdaptersWatcher = DeviceInformation.CreateWatcher(WiFiAdapter.GetDeviceSelector()); WiFiAdaptersWatcher.EnumerationCompleted += AdaptersEnumCompleted; WiFiAdaptersWatcher.Added += AdaptersAdded; WiFiAdaptersWatcher.Removed += AdaptersRemoved; WiFiAdaptersWatcher.Start(); }
protected async override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); watcher = DeviceInformation.CreateWatcher(ProximitySensor.GetDeviceSelector()); watcher.Added += OnProximitySensorAdded; watcher.Start(); timer = new Timer(TimerCallBack, null, Timeout.Infinite, 4000); await InitializeCameraAsync(); }
/// <summary> /// Invoked when the device watcher finds a proximity sensor /// </summary> /// <param name="sender">The device watcher</param> /// <param name="device">Device information for the proximity sensor that was found</param> private async void OnProximitySensorAdded(DeviceWatcher sender, DeviceInformation device) { if (null == sensor) { ProximitySensor foundSensor = ProximitySensor.FromId(device.Id); if (null != foundSensor) { if (null != foundSensor.MaxDistanceInMillimeters) { // Check if this is the sensor that matches our ranges. // TODO: Customize these values to your application's needs. // Here, we are looking for a sensor that can detect close objects // up to 3cm away, so we check the upper bound of the detection range. const uint distanceInMillimetersLValue = 30; // 3 cm const uint distanceInMillimetersRValue = 50; // 5 cm if (foundSensor.MaxDistanceInMillimeters >= distanceInMillimetersLValue && foundSensor.MaxDistanceInMillimeters <= distanceInMillimetersRValue) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Found a proximity sensor that meets the detection range", NotifyType.StatusMessage); }); } else { // We'll use the sensor anyway, to demonstrate how events work. // Your app may decide not to use the sensor. await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Proximity sensor does not meet the detection range, using it anyway", NotifyType.StatusMessage); }); } } else { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Proximity sensor does not report detection ranges, using it anyway", NotifyType.StatusMessage); }); } if (null != foundSensor) { sensor = foundSensor; } } else { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Could not get a proximity sensor from the device id", NotifyType.ErrorMessage); }); } } }
private async void DeviceWatcher_Added(DeviceWatcher sender, DeviceInformation args) { await coreDispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { FoundDeviceList.Add(args); }); }
private async void DevicesRemoved(DeviceWatcher sender, DeviceInformationUpdate args) { //Debug.WriteLine("Removed USB device: " + args.Id); await dispatcher.RunAsync(CoreDispatcherPriority.Low, () => { UpdateDevices(); }); }
private void watcher_Removed(Windows.Devices.Enumeration.DeviceWatcher sender, Windows.Devices.Enumeration.DeviceInformationUpdate args) { Debug.WriteLine(args.Id); this.BeginInvoke((Action)(() => { //perform on the UI thread PrintDrives(); })); }
private async void DevicesEnumCompleted(DeviceWatcher sender, object args) { //Debug.WriteLine("USB Devices Enumeration Completed"); await dispatcher.RunAsync(CoreDispatcherPriority.Low, () => { UpdateDevices(); }); }
public void Dispose() { if (_deviceWatcher != null) { _deviceWatcher.Stop(); _deviceWatcher.Added -= DeviceAdded; _deviceWatcher.Removed -= DeviceRemoved; _deviceWatcher = null; } }
static HidGamepad() { var deviceSelector = HidDevice.GetDeviceSelector(0x01, 0x05); _watcher = DeviceInformation.CreateWatcher(deviceSelector); _watcher.Added += HandleDeviceAdded; _watcher.Updated += HandleDeviceUpdated; _watcher.Removed += HandleDeviceRemoved; _watcher.EnumerationCompleted += HandleEnumerationCompleted; _watcher.Start(); }
async void watcher_EnumerationCompleted(Windows.Devices.Enumeration.DeviceWatcher sender, object args) { isEnumerationComplete = true; await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { OutputText.Text = "Enumeration complete. "; DisplayDeviceInterfaceArray(); tblLatest.Text = ""; }); }
/// <summary> /// Invoked when the device watcher detects that the proximity sensor was removed. /// </summary> /// <param name="sender">The device watcher.</param> /// <param name="device">The device that was removed.</param> private void OnProximitySensorRemoved(DeviceWatcher sender, DeviceInformationUpdate device) { if ((this.proximitySensor != null) && (this.proximitySensor.DeviceId == device.Id)) { this.proximitySensor.ReadingChanged -= ProximitySensor_ReadingChangedAsync; this.proximitySensor = null; SetActive(false); } }
public ConnectedDevicePresenter(CoreDispatcher dispatcher) { this.dispatcher = dispatcher; usbConnectedDevicesWatcher = DeviceInformation.CreateWatcher(usbDevicesSelector); usbConnectedDevicesWatcher.EnumerationCompleted += DevicesEnumCompleted; usbConnectedDevicesWatcher.Updated += DevicesAdded; usbConnectedDevicesWatcher.Removed += DevicesRemoved; usbConnectedDevicesWatcher.Start(); }
/// <summary> /// Create a PosDeviceWatcher. /// </summary> /// <param name="deviceSelector">Device Selector string to use with DeviceWatcher</param> /// <param name="dispatcher">Associated UI element's Dispatcher so that updates to this.FoundDeviceList are done safely.</param> public PosDeviceWatcher(string deviceSelector, CoreDispatcher dispatcher) { FoundDeviceList = new ObservableCollection<DeviceInformation>(); coreDispatcher = dispatcher; deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector); deviceWatcher.Added += DeviceWatcher_Added; deviceWatcher.Removed += DeviceWatcher_Removed; deviceWatcher.Updated += DeviceWatcher_Updated; }
private void StartListeningForSerialPortChanges() { serialPortWatcher = DeviceInformation.CreateWatcher(SerialDevice.GetDeviceSelector()); serialPortWatcher.Added += SerialPortWatcher_Added; serialPortWatcher.Removed += SerialPortWatcher_Removed; serialPortWatcher.Updated += SerialPortWatcher_Updated; serialPortWatcher.Start(); }
public MidiDeviceWatcher(DeviceWatcher watcher) { _watcher = watcher; // wire up events _watcher.Added += Watcher_Added; _watcher.Removed += Watcher_Removed; _watcher.Updated += Watcher_Updated; _watcher.EnumerationCompleted += Watcher_EnumerationCompleted; }
public DeviceWatcher() { subject = new Subject <IDevice>(); const string selector = "System.Devices.InterfaceClassGuid:= \"{4D1E55B2-F16F-11CF-88CB-001111000030}\" AND System.Devices.InterfaceEnabled:= System.StructuredQueryType.Boolean#True"; watcher = DeviceInformation.CreateWatcher(selector); watcher.Added += Watcher_Added; watcher.Removed += Watcher_Removed; watcher.Updated += Watcher_Updated; watcher.Stopped += Watcher_Stopped; }
public DeviceWatcher() { subject = new Subject <IDevice>(); const string selector = "System.Devices.InterfaceClassGuid:= \"{A5DCBF10-6530-11D2-901F-00C04FB951ED}\" AND System.Devices.InterfaceEnabled:= System.StructuredQueryType.Boolean#True"; watcher = DeviceInformation.CreateWatcher(selector); watcher.Added += Watcher_Added; watcher.Removed += Watcher_Removed; watcher.Updated += Watcher_Updated; watcher.Stopped += Watcher_Stopped; }
public Scenario2_Polling() { String customSensorSelector = ""; this.InitializeComponent(); customSensorSelector = CustomSensor.GetDeviceSelector(GUIDCustomSensorDeviceVendorDefinedTypeID); watcher = DeviceInformation.CreateWatcher(customSensorSelector); watcher.Added += OnCustomSensorAdded; watcher.Start(); }
static Blink1() { var selector = HidDevice.GetDeviceSelector(0xFF00, 0x0001, 0x27B8, 0x01ED); _watcher = DeviceInformation.CreateWatcher(selector); _watcher.Added += HandleDeviceAdded; _watcher.Updated += HandleDeviceUpdated; _watcher.Removed += HandleDeviceRemoved; _watcher.EnumerationCompleted += HandleEnumerationCompleted; _watcher.Start(); }
async void watcher_Stopped(Windows.Devices.Enumeration.DeviceWatcher sender, object args) { if (watcher.Status == Windows.Devices.Enumeration.DeviceWatcherStatus.Aborted) { StopStatus = "Enumeration stopped unexpectedly. Click Watch to restart enumeration."; } else if (watcher.Status == Windows.Devices.Enumeration.DeviceWatcherStatus.Stopped) { StopStatus = "You requested to stop the enumeration. Click Watch to restart enumeration."; } }
/// <summary> /// Constructor: Initialize and hook up Device Watcher events /// </summary> /// <param name="midiSelectorString">MIDI Device Selector</param> /// <param name="dispatcher">CoreDispatcher instance, to update UI thread</param> /// <param name="portListBox">The UI element to update with list of devices</param> internal MidiDeviceWatcher(string midiSelectorString, CoreDispatcher dispatcher, ListBox portListBox) { this.deviceWatcher = DeviceInformation.CreateWatcher(midiSelectorString); this.portList = portListBox; this.midiSelector = midiSelectorString; this.coreDispatcher = dispatcher; this.deviceWatcher.Added += DeviceWatcher_Added; this.deviceWatcher.Removed += DeviceWatcher_Removed; this.deviceWatcher.Updated += DeviceWatcher_Updated; this.deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted; }
private async void Watcher_Added(Windows.Devices.Enumeration.DeviceWatcher sender, DeviceInformation args) { // FIXME: async void - need to log error or something var device = await HidDevice.FromIdAsync(args.Id, FileAccessMode.ReadWrite); if (device == null) { // we probably don't have permission to use it return; } subject.OnNext(new Device(args, device)); }
async void watcher_Added(Windows.Devices.Enumeration.DeviceWatcher sender, DeviceInformation deviceInterface) { interfaces[count] = deviceInterface; count += 1; if (isEnumerationComplete) { await dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { DisplayDeviceInterfaceArray(); OutputText.Text = "Watcher added: Enumeration was already complete."; }); } }
public Scenario3() { this.InitializeComponent(); //Create our watcher and have it find casting devices capable of video casting watcher = DeviceInformation.CreateWatcher(CastingDevice.GetDeviceSelector(CastingPlaybackTypes.Video)); //Register for watcher events watcher.Added += Watcher_Added; watcher.Removed += Watcher_Removed; watcher.Stopped += Watcher_Stopped; watcher.EnumerationCompleted += Watcher_EnumerationCompleted; }
private void btnWatcher_Click(object sender, RoutedEventArgs e) { if (_fWatcherStarted == false) { _publisher.Start(); if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started) { rootPage.NotifyUser("Failed to start advertisement.", NotifyType.ErrorMessage); return; } DiscoveredDevices.Clear(); rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage); String deviceSelector = WiFiDirectDevice.GetDeviceSelector( Utils.GetSelectedItemTag<WiFiDirectDeviceSelectorType>(cmbDeviceSelector)); _deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" }); _deviceWatcher.Added += OnDeviceAdded; _deviceWatcher.Removed += OnDeviceRemoved; _deviceWatcher.Updated += OnDeviceUpdated; _deviceWatcher.EnumerationCompleted += OnEnumerationCompleted; _deviceWatcher.Stopped += OnStopped; _deviceWatcher.Start(); btnWatcher.Content = "Stop Watcher"; _fWatcherStarted = true; } else { _publisher.Stop(); btnWatcher.Content = "Start Watcher"; _fWatcherStarted = false; _deviceWatcher.Added -= OnDeviceAdded; _deviceWatcher.Removed -= OnDeviceRemoved; _deviceWatcher.Updated -= OnDeviceUpdated; _deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted; _deviceWatcher.Stopped -= OnStopped; _deviceWatcher.Stop(); rootPage.NotifyUser("Device watcher stopped.", NotifyType.StatusMessage); } }
private void watcher_Added(Windows.Devices.Enumeration.DeviceWatcher sender, Windows.Devices.Enumeration.DeviceInformation args) { string name = GetPortableDeviceName(args.Id); string type = GetPortableDeviceType(args.Id); if (!deviceTypeList.ContainsKey(name)) { deviceTypeList.Add(GetPortableDeviceName(args.Id), GetPortableDeviceType(args.Id)); } this.BeginInvoke((Action)(() => { //perform on the UI thread PrintDrives(); })); }
public Scenario2_Polling() { String customSensorSelector = ""; this.InitializeComponent(); customSensorSelector = CustomSensor.GetDeviceSelector(GUIDCustomSensorDeviceVendorDefinedTypeID); watcher = DeviceInformation.CreateWatcher(customSensorSelector); watcher.Added += OnCustomSensorAdded; watcher.Start(); // Register to be notified when the user disables access to the custom sensor through privacy settings. deviceAccessInformation = DeviceAccessInformation.CreateFromDeviceClassId(GUIDCustomSensorDeviceVendorDefinedTypeID); deviceAccessInformation.AccessChanged += new TypedEventHandler<DeviceAccessInformation, DeviceAccessChangedEventArgs>(OnAccessChanged); }
static public void Stop() { /// <summary> /// Stops watching for all nearby Bluetooth devices. /// </summary> if (deviceWatcher != null) { // Unregister the event handlers. deviceWatcher.Added -= DeviceWatcher_Added; // Stop the watcher. deviceWatcher.Stop(); deviceWatcher = null; } }
/// <summary> /// Invoked when the device watcher finds a proximity sensor /// </summary> /// <param name="sender">The device watcher</param> /// <param name="device">Device information for the proximity sensor that was found</param> private async void OnProximitySensorAdded(DeviceWatcher sender, DeviceInformation device) { if (null == sensor) { sensor = ProximitySensor.FromId(device.Id); if (null == sensor) { // failed to find the sensor corresponding to the id await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { rootPage.NotifyUser("Could not get a proximity sensor from the device id", NotifyType.ErrorMessage); }); } } }
private async void DeviceWatcher_Removed(DeviceWatcher sender, DeviceInformationUpdate args) { await coreDispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { for (int index = 0; index < FoundDeviceList.Count; ++index) { if (FoundDeviceList[index].Id == args.Id) { FoundDeviceList.RemoveAt(index); break; } } }); }
/// <summary> /// Initializes a new instance of the MainForm form class. /// </summary> public MainForm() { LocRM = new ResourceManager("win81FactoryTest.AppResources.Res", typeof(win81FactoryTest.TestForm).Assembly); InitializeComponent(); SetString(); this.FormBorderStyle = FormBorderStyle.None;//Full screen and no title this.WindowState = FormWindowState.Maximized; //Initialize device watcher watcher = Windows.Devices.Enumeration.DeviceInformation.CreateWatcher(Windows.Devices.Enumeration.DeviceClass.PortableStorageDevice); watcher.Added += watcher_Added; watcher.Removed += watcher_Removed; watcher.EnumerationCompleted += watcher_EnumerationCompleted; watcher.Start(); }
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 Watcher_Updated(Windows.Devices.Enumeration.DeviceWatcher sender, DeviceInformationUpdate args) { // TODO: notify devices }
private void Watcher_Updated(Windows.Devices.Enumeration.DeviceWatcher sender, Windows.Devices.Enumeration.DeviceInformationUpdate args) { }
private void Watcher_Stopped(Windows.Devices.Enumeration.DeviceWatcher sender, object args) { subject.OnCompleted(); }