public void Dispose() { _UsbDeviceConnection?.Dispose(); _UsbDevice?.Dispose(); _ReadEndpoint?.Dispose(); _WriteEndpoint?.Dispose(); }
/// <summary> /// This method demonstrates how to close the device properly using the WinRT Usb API. /// /// When the UsbDevice is closing, it will cancel all IO operations that are still pending (not complete). /// The close will not wait for any IO completion callbacks to be called, so the close call may complete before any of /// the IO completion callbacks are called. /// The pending IO operations will still call their respective completion callbacks with either a task /// cancelled error or the operation completed. /// </summary> private async void CloseCurrentlyConnectedDevice() { if (device != null) { // Notify callback that we're about to close the device if (deviceCloseCallback != null) { deviceCloseCallback(this, deviceInformation); } // This closes the handle to the device device.Dispose(); device = null; // Save the deviceInformation.Id in case deviceInformation is set to null when closing the // device String deviceId = deviceInformation.Id; await rootPage.Dispatcher.RunAsync( CoreDispatcherPriority.Normal, new DispatchedHandler(() => { MainPage.Current.NotifyUser(deviceId + " is closed", NotifyType.StatusMessage); })); } }
void Dispose(bool disposing) { if (disposing) { device?.Dispose(); } }
public void Dispose() { if (NativeDevice != null) { NativeDevice.Dispose(); NativeDevice = null; } if (Connection != null) { Connection.Dispose(); Connection = null; } if (Endpoint != null) { Endpoint.Dispose(); Endpoint = null; } if (EndpointWrite != null) { EndpointWrite.Dispose(); EndpointWrite = null; } if (Manager != null) { Manager.Dispose(); Manager = null; } }
public void CloseCameraHandle() { if (_targetDevice != null) { _targetDevice.Dispose(); _targetDevice = null; } }
public async void Run(IBackgroundTaskInstance taskInstance) { backgroundTaskInstance = taskInstance; // Trigger details contain device id and arguments that are provided by the caller in the main app // The taskInstance can always be casted to DeviceUseDetails if this background task was started using a DeviceUseTrigger deviceSyncDetails = (DeviceUseDetails)taskInstance.TriggerDetails; deferral = taskInstance.GetDeferral(); try { backgroundTaskInstance.Progress = 0; cancellationTokenSource = new CancellationTokenSource(); taskInstance.Canceled += new BackgroundTaskCanceledEventHandler(OnCanceled); // For simplicity, no error checking will be done after opening the device. Ideally, one should always // check if the device was successfully opened and respond accordingly. For an example on how to do this, // please see Scenario 1 of this sample. // // The user may also block the device via the settings charm while we are syncing (in background task). In order to deal with // the user changing permissions, we have to listen for DeviceAccessInformation->AccessChanged events. See EventHandlerForDevice // for how to handle DeviceAccessInformation.AccessChanged event. OpenDevice(); // The sample only demonstrates a bulk write for simplicity. // IO operations can be done after opening the device. // For more information on BackgroundTasks, please see the BackgroundTask sample on MSDN. UInt32 bytesWritten = await Task.Run(() => { return(WriteToDeviceAsync()); }, cancellationTokenSource.Token); ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskResult] = bytesWritten; ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskStatus] = BackgroundTaskInformation.TaskCompleted; } catch (OperationCanceledException /*ex*/) { ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskResult] = 0; ApplicationData.Current.LocalSettings.Values[LocalSettingKeys.SyncBackgroundTaskStatus] = BackgroundTaskInformation.TaskCanceled; } finally { // Close the device because we are finished syncing and so that the app may reopen the device device.Dispose(); device = null; } // Complete the background task (this raises the OnCompleted event on the corresponding BackgroundTaskRegistration) deferral.Complete(); }
public void Close() { if (!IsOpen) { return; } cts.Cancel(); usbDevice.Dispose(); usbDevice = null; Debug.WriteLine("Connection closed"); IsOpen = false; }
protected virtual void Dispose(bool disposing) { if (!disposeValue) { if (disposing) { this.disposing = true; _dispatcher.Invoke(() => { _usbDevice.Dispose(); _context.Dispose(); }); } disposeValue = true; } }
public static void Close() { if (usbDevice == null) { return; } RefreshThreadWanted = false; while (RefreshThreadRunning) { Thread.Sleep(40); } Thread.Sleep(40); WriteText("Goodbye"); RefreshDisplayAsync().Wait(); Thread.Sleep(200); usbDevice.Close(); usbDevice.Dispose(); usbDevice = null; }
public void Dispose() { UsbDevice.Dispose(); }
private void OnAppExiting(object sender, SuspendingEventArgs e) { _targetDevice?.Dispose(); }
/// <summary> /// Closes the device and sets the device member variable to null /// </summary> private void CloseDevice() { device.Dispose(); device = null; }
public void Dispose() { _UsbDeviceConnection?.Dispose(); _UsbDevice?.Dispose(); }
public void Dispose() { device?.Dispose(); }