Selectwireless USB Devices Driver

Posted By admin On 13/10/21

This topic summarizes the new features and improvements for Universal Serial Bus (USB) client drivers in Windows 8.

New Driver Stack for USB 3.0 Devices. Windows 8 provides a new USB driver stack to support USB 3.0 devices. The new stack includes drivers that are loaded by Windows when a USB 3.0 device is attached to an xHCI host controller. The new drivers are based on Kernel Mode Driver Framework (KMDF) and implement features defined in the USB 3.0. The USB mouse client driver supports the attachment of multiple USB mouse devices. Each device is enumerated in the Object Data Manager (ODM) and marked available. The client driver treats all the mouse devices as a single logical device. Input events from all the devices are sent to a single input ring. Original title: Slow Device Installation I am using Win7-Ultimate (32-bit) on my compaq laptop. Whenever I connect a device/USB drive through USB port or a Bluetooth device, device driver installation takes a very long time. USB Mass Storage Device - Driver Download. Vendor:. Product: USB Mass Storage Device. Hardware Class: hdc. Search For More Drivers.: Go!

For information about new features in USB in general, see New for USB Drivers.

New Driver Stack for USB 3.0 Devices

Windows 8 provides a new USB driver stack to support USB 3.0 devices. The new stack includes drivers that are loaded by Windows when a USB 3.0 device is attached to an xHCI host controller. The new drivers are based on Kernel Mode Driver Framework (KMDF) and implement features defined in the USB 3.0 specification. The new drivers are as follows:

  • Usbxhci.sys
  • Ucx01000.sys
  • Usbhub3.sys
Select wireless usb devices driver windows 10

The new driver stack maintains compatibility with the existing client drivers that were built and tested on earlier versions of the Windows operating system.

To see an architectural block diagram of the USB driver stack and a brief description of the new drivers, see USB 3.0 Driver Stack Architecture.

Features Supported by the New Stack

The USB driver stack for USB 3.0 devices supports many new features. Some of features are configurable by the client driver. Those features are as follows:

  • Static streams for bulk endpoints.

    Streams provide the client driver with the ability to perform multiple data transfers to a single bulk endpoint. The Windows Driver Kit (WDK) for Windows 8 provides new device driver interfaces (DDIs) that allow a client driver to can open up to 255 streams in a bulk endpoint. After streams have been opened, the client driver can perform data transfers to and from specific streams. For more information, see How to Open and Close Static Streams in a USB Bulk Endpoint.

  • Chained MDLs

    A client driver can specify the payload in a chain of MDLs instead of a contiguous buffer. This allows the transfer buffer to be segmented in physical memory hence removing restrictions on the number, size, and alignment of buffers. Using chained MDLs can boost performance during data transfers because it avoids double buffering. For more information, see How to Send Chained MDL.

  • Function suspend and remote wake-up for composite devices.

    The feature enables a function of a composite device to enter and exit a low-power state, independently of other functions. The function driver can also request a device-initiated remote wake-up. Such a request must be handled by the parent driver of the composite device. The Microsoft-provided parent driver (Usbccgp.sys) supports function suspend and remote wake-up features. The WDK for Windows 8 provides DDIs that allow replacement parent drivers to implement those features. For more information, see How to Implement Function Suspend in a Composite Driver.

Client contract version for USB client drivers

A client contract version identifies a set of rules that the client driver when sending requests to the USB driver stack. Failure to do so might result in an unexpected behavior. For information about those rules, see Best Practices: Using URBs.


A client driver that intends to use the capabilities of the USB driver stack for 3.0 devices, must identify itself with the client contract version of USBD_CLIENT_CONTRACT_VERSION_602. Such a client driver is required to register with the USB driver stack. After registration, the client driver must query the underlying USB driver stack to determine whether the stack supports the required capability. To facilitate those operations, the following KMDF-specific methods and WDM routines have been included in the WDK for Windows 8:

Use caseA KMDF-based driver should ...A WDM driver must ...
To specify a client contract version and with the USB driver stackCall the WdfUsbTargetDeviceCreateWithParameters method.Call the USBD_CreateHandle routine.
To query for a particular capabilityCall WdfUsbTargetDeviceQueryUsbCapability and specify the GUID of the capability to query.Call USBD_QueryUsbCapability and specify the GUID of the capability to query.

New Routines for Allocating and Building URBs

Windows 8 provides new routines for allocating, formatting, and releasing URBs. The URB structure is allocated by the USB driver stack. If the underlying stack is the new USB driver stack, the URB is paired with an opaque URB context. The USB driver stack uses the URB context to improve URB tracking and processing. For more information about the routines, see Allocating and Building URBs.

The new routines are as follows:

  • USBD_AssignUrbToIoStackLocation routine to associate an URB with an IRP. This routine only applies to WDM client drivers.

In addition to the routines in the preceding list, there are new KMDF-specific methods for URB allocation. For KMDF-based client drivers, we recommend that you call,

  • The WdfUsbTargetDeviceCreateUrb method (instead of USBD_UrbAllocate) to allocate an URB.
  • The WdfUsbTargetDeviceCreateIsochUrb method (instead of USBD_IsochUrbAllocate)to allocate an URB for an isochronous transfer. Those calls allocate a variable-sized URB that is based on the number of isochronous packets required for the transfer. For more information about isochronous transfers, see How to Transfer Data to USB Isochronous Endpoints.

New User Mode I/O Control Requests for USB 3.0 Hubs

Windows 8 provides the new IOCTLs that applications can use to retrieve information about USB 3.0 hubs and their ports. The new IOCTLs are as follows:

By sending the preceding I/O requests to the USB driver stack an application retrieve the following set of information:

  • Hub descriptors
  • Properties of all ports and companion ports
  • Operating speed of a device that is attached to a port

New Compatible ID for WinUSB

Device manufacturers can add 'WINUSB' in the firmware (Microsoft OS feature descriptor) so that Windows recognizes the device as a WinUSB device. In Windows 8, Winusb.inf has been modified to include USBMS_COMP_WINUSB as a device identifier string. That modification enables Windows to automatically load Winusb.sys, as the function driver for the device, as soon as the device is detected. For more information, see WinUSB Device.

New Visual Studio templates for USB client drivers (*New for Beta)

Microsoft Visual Studio 2012 includes USB User-Mode Driver and USB Kernel-Mode Driver templates that generate starter code for a UMDF and KMDF USB client driver, respectively. The template code initializes the USB target device object to enable communication with the hardware. For more information, see the following topics:

Selectwireless USB Devices Driver

For more information, see Getting started with USB client driver development. Extend your driver by performing Common tasks for USB client drivers.

For information about how to implement UMDF and KMDF drivers, see the Microsoft Press book Developing Drivers with the Windows Driver Foundation.

UASP driver

Windows 8 includes a new USB storage driver that implements the USB Attached SCSI Protocol (UASP). The new driver uses static streams for bulk endpoints, as per the official USB 3.0 specification.

Boot support

The Windows to Go feature allows Windows to boot from a flash drive or an external drive. You can boot with your copy of Windows from those drives on various machines.

Enhanced debugging and diagnostic capabilities

Windows 8 provides new USB 3.0 debugging tools to improve diagnosing USB issues faster. There are new USB 3.0 kernel debugger extensions that examine USB 3.0 host controller and device states. You can use USB WPP and event tracing to analyze USB interactions and troubleshoot USB device issues more easily. Windows 8 supports debugging over USB 3.0. For more information, see Setting Up a USB 3.0 Connection Manually.

New USB-specific failure messages in Device Manager

At times, Windows can fail to enumerate an attached USB device. Typically, enumeration failures occur when requests sent to the USB device fail or the device returns incorrect descriptors.

In Windows 8, when such failures occur, the General tab in Device Manager displays a USB-specific error message that indicates the reason for failure.

Selectwireless USB Devices Driver

Selectwireless USB Devices Driver

The error strings are as follows:

  • A request for the USB device descriptor failed.
  • The USB set address request failed.
  • A USB port reset request failed.
  • A previous instance of the USB device was not removed.
  • The USB device returned an invalid USB configuration descriptor.
  • The USB device returned an invalid USB device descriptor.
  • Unable to access the registry.
  • A request for the USB configuration descriptor failed.
  • A request for the USB device's port status failed.
  • The USB device returned an invalid serial number string.
  • The USB set SEL request failed.
  • A request for the USB BOS descriptor failed.
  • A request for the USB device qualifier descriptor failed.
  • A request for the USB serial number string descriptor failed.
  • A request for the USB language ID string descriptor failed.
  • A request for the USB product description string descriptor failed.
  • A request for the Microsoft OS extended configuration descriptor failed.
  • A request for the Microsoft OS container ID descriptor failed.
  • The USB device returned an invalid USB BOS descriptor.
  • The USB device returned an invalid USB device qualifier descriptor.
  • The USB device returned an invalid USB language ID string descriptor.
  • The USB device returned an invalid Microsoft OS container ID descriptor.
  • The USB device returned an invalid Microsoft OS extended configuration descriptor.
  • The USB device returned an invalid product description string descriptor.
  • The USB device returned an invalid serial number string descriptor.

Related topics

New for USB Drivers
Universal Serial Bus (USB) Drivers


Select Wireless Usb Devices Drivers


  • End-to-end walkthrough for creating a UWP app that talks to a USB device
  • Companion sample: Custom USB device access sample

Important APIs

Use the Windows Runtime APIs, introduced in Windows 8.1, to write UWP apps that gives users access to their peripheral USB device. Such apps can connect to a device based on user-specified criteria, get information about the device, send data to the device and conversely get data streams from the device, and poll the device for interrupt data.

Here we describe, how your UWP app using C++, C#, or Visual Basic app can implement those tasks, and link to examples that demonstrate the use of classes included in Windows.Devices.Usb. We'll go over the device capabilities required in the app manifest and how to launching the app when the device is connected. And we'll show how to run a data transfer task in the background even when the app is suspended to conserve battery life.

Follow the steps in this section or, skip directly to the Custom USB device access sample. The companion sample implements all the steps here, but to keep things moving we won't walk through the code. Certain steps have a Find it in the sample section to help you find the code quickly. The structure of the sample's source files is simple and flat so you can easily find code without having to drill down through multiple layers of source files. But you may prefer to break up and organize your own project differently.

In this section

Walkthrough—Writing UWP app for USB devices


Step 1—Install the Microsoft-provided WinUSB driver as function driver for your device.

QuickStart:WinUSB (Winusb.sys) Installation

You can install Winusb.sys in these ways:

  • When you connect your device, you might notice that Windows loads Winusb.sys automatically because the device is a WinUSB Device.
  • Install the driver by specifying the system-provided device class in Device Manager.
  • Install the driver by using a custom INF. You can get the INF in either of these two ways:
    • Get the INF from the hardware vendor.
    • Write a custom INF that references the Microsoft-provided Winusb.inf file. For more information, see WinUSB (Winusb.sys) Installation.

Step 2—Get the device interface GUID, hardware ID, and device class information about your device.

You can obtain that information from the device manufacturer.

  • Vendor and product identifiers

    In Device Manager, view the device properties. On the Details tab, view the Hardware Id property value. That value is a combination of those two identifiers. For example, for the SuperMUTT device, the Hardware Id is 'USBVID_045E&PID_F001'; vendor ID is '0x045E' and product ID is '0xF001'.

  • Device class, subclass, and protocol codes
  • Device interface GUID
Alternatively, you can view information the registry. For more information, see USB Device Registry Entries.

Step 3—Determine whether the device class, subclass, and protocol allowed by the Windows Runtime USB API set.

You can write a UWP app, if device class, subclass, and protocol code of the device is one of the following:

  • name:cdcControl, classId:02 * *
  • name:physical, classId:05 * *
  • name:personalHealthcare, classId:0f 00 00
  • name:activeSync, classId:ef 01 01
  • name:palmSync, classId:ef 01 02
  • name:deviceFirmwareUpdate, classId:fe 01 01
  • name:irda, classId:fe 02 00
  • name:measurement, classId:fe 03 *
  • name:vendorSpecific, classId:ff * *

Step 4—Create a basic Visual Studio 2013 project that you can extend in this tutorial.

For more information, see Getting started with UWP apps.

Step 5—Add USB device capabilities to the app manifest.

QuickStart:How to add USB device capabilities to the app manifest

Open your Package.appxmanifest file in a text editor and add the DeviceCapability](/uwp/schemas/appxpackage/appxmanifestschema/element-devicecapability)'>DeviceCapability element with Name attribute set to 'usb' as shown in this example.

Note You cannot modify the USB device capability in Visual Studio 2013. You must select and hold (or right-click) the Package.appxmanifest file in Solution Explorer and select Open With..., and then XML (Text) Editor. The file opens in plain XML.

Find it in the sample: The USB device capabilities are added in the Package.appxmanifest file.

Step 6— Extend the app to open the device for communication.

Quickstart:How to connect to a USB device (UWP app)

  1. Find the device by building an Advanced Query Syntax (AQS) string that contains search criteria for finding the device in the enumerated device collection.
  2. Open the device in one of two ways:
    • Passing the AQS to FindAllAsync](/uwp/api/Windows.Devices.Enumeration.DeviceInformation#Windows_Devices_Enumeration_DeviceInformation_FindAllAsync_System_String_)'>FindAllAsync and get the DeviceInformation](/uwp/api/Windows.Devices.Enumeration.DeviceInformation)'>DeviceInformation object for the device.

      For more information, see Quickstart: enumerating commonly used devices.

    • By using a DeviceWatcher](/uwp/api/Windows.Devices.Enumeration.DeviceWatcher)'>DeviceWatcher object to detect when the device is added to or removed from the system.
      1. Pass the AQS to CreateWatcher](/uwp/api/Windows.Devices.Enumeration.DeviceInformation#Windows_Devices_Enumeration_DeviceInformation_CreateWatcher)'>CreateWatcher and get a DeviceWatcher](/uwp/api/Windows.Devices.Enumeration.DeviceWatcher)'>DeviceWatcher object.
      2. Register event handlers on the DeviceWatcher](/uwp/api/Windows.Devices.Enumeration.DeviceWatcher)'>DeviceWatcher object.
      3. Get the DeviceInformation](/uwp/api/Windows.Devices.Enumeration.DeviceInformation)'>DeviceInformation object for the device in your Added](/uwp/api/Windows.Devices.Enumeration.DeviceWatcher#Windows_Devices_Enumeration_DeviceWatcher_Added)'>Added event handler.
      4. Start and stop the DeviceWatcher](/uwp/api/Windows.Devices.Enumeration.DeviceWatcher)'>DeviceWatcher object.
      For more information, see How to get notifications if devices are added, removed, or changed.
  3. Get the device instance from the DeviceInformation.Id](/uwp/api/Windows.Devices.Enumeration.DeviceInformation#Windows_Devices_Enumeration_DeviceInformation_Id)'>DeviceInformation.Id property.
  4. Call FromIdAsync](/uwp/api/Windows.Devices.Usb.UsbDevice#Windows_Devices_Usb_UsbDevice_FromIdAsync_System_String_)'>FromIdAsync by passing the device instance string and get the UsbDevice](/uwp/api/Windows.Devices.Usb.UsbDevice)'>UsbDevice object.

Find it in the sample: See files named Scenario1_DeviceConnect.

Step 7(Recommended)—Study your USB device layout.

Review basic USB concepts about configuring the device and performing data transfers: Concepts for all USB developers.

View the device configuration descriptor, interface descriptors for each supported alternate settings, and their endpoint descriptors. By using USBView, you can browse all USB controllers and the USB devices connected to them, and also inspect the device configuration.

Step 8— Extend the app to get and show USB descriptors in the UI.

Quickstart:How to get USB descriptors (UWP app)

  • Get the device descriptor by getting the UsbDevice.DeviceDescriptor](/uwp/api/Windows.Devices.Usb.UsbDevice#Windows_Devices_Usb_UsbDevice_DeviceDescriptor)'>UsbDevice.DeviceDescriptor value.
  • Get the configuration descriptor by getting the UsbConfiguration.ConfigurationDescriptor](/uwp/api/Windows.Devices.Usb.UsbConfiguration#Windows_Devices_Usb_UsbConfiguration_ConfigurationDescriptor)'>UsbConfiguration.ConfigurationDescriptor value.
    • Get the full configuration descriptor set by getting the UsbConfiguration.Descriptors](/uwp/api/Windows.Devices.Usb.UsbConfiguration#Windows_Devices_Usb_UsbConfiguration_Descriptors)'>UsbConfiguration.Descriptors property.
  • Get the array of interfaces within the configuration by getting the UsbConfiguration.UsbInterfaces](/uwp/api/Windows.Devices.Usb.UsbConfiguration#Windows_Devices_Usb_UsbConfiguration_UsbInterfaces)'>UsbConfiguration.UsbInterfaces property.
  • Get the array of alternate settings by getting UsbInterface.InterfaceSettings](/uwp/api/Windows.Devices.Usb.UsbInterface#Windows_Devices_Usb_UsbInterface_InterfaceSettings)'>UsbInterface.InterfaceSettings.
  • Within the active alternate setting enumerate pipes and get the associated endpoints.

    Endpoint descriptors are represented by these objects:

Find it in the sample: See files named Scenario5_UsbDescriptors.

Step 9— Extend the app to send vendor-defined USB control transfers.

Quickstart:How to send a USB control transfer request (UWP app)

  1. Get the vendor command from the hardware specification of the device.
  2. Create a UsbSetupPacket](/uwp/api/Windows.Devices.Usb.UsbSetupPacket)'>UsbSetupPacket object and populate the setup packet by setting various properties.
  3. Start an asynchronous operation to send the control transfer by these methods depending on the direction of the transfer:

Find it in the sample: See files named Scenario2_ControlTransfer.

Step 10— Extend the app to read or write bulk data.

Quickstart:How to send a USB bulk transfer request (UWP app)

  1. Get the bulk pipe object (UsbBulkOutPipe](/uwp/api/Windows.Devices.Usb.UsbBulkOutPipe)'>UsbBulkOutPipe or UsbBulkInPipe](/uwp/api/Windows.Devices.Usb.UsbBulkInPipe)'>UsbBulkInPipe).
  2. Configure the bulk pipe to set policy parameters.
  3. Set up the data stream by using the DataReader](/uwp/api/Windows.Storage.Streams.DataReader)'>DataReader or DataWriter](/uwp/api/Windows.Storage.Streams.DataWriter)'>DataWriter object.
  4. Start an asynchronous transfer operation by calling DataReader.LoadAsync](/uwp/api/Windows.Storage.Streams.DataReader#Windows_Storage_Streams_DataReader_LoadAsync_System_UInt32_)'>DataReader.LoadAsync or DataWriter.StoreAsync](/uwp/api/Windows.Storage.Streams.DataWriter#Windows_Storage_Streams_DataWriter_StoreAsync)'>DataWriter.StoreAsync.
  5. Get results of the transfer operation.

Find it in the sample: See files named Scenario4_BulkPipes.

Step 11— Extend the app to get hardware interrupt data.

Quickstart:How to send a USB interrupt transfer request (UWP app)

  1. Get the interrupt pipe object (UsbInterruptInPipe](/uwp/api/Windows.Devices.Usb.UsbInterruptInPipe)'>UsbInterruptInPipe or UsbInterruptOutPipe](/uwp/api/Windows.Devices.Usb.UsbInterruptOutPipe)'>UsbInterruptOutPipe).
  2. Implement the interrupt handler for the DataReceived](/uwp/api/Windows.Devices.Usb.UsbInterruptInPipe#Windows_Devices_Usb_UsbInterruptInPipe_DataReceived)'>DataReceived event.
  3. Register the event handler to start receiving data.
  4. Unregister the event handler to stop receiving data.

Find it in the sample: See files named Scenario3_InterruptPipes.

Step 12— Extend the app to select an interface setting that is not currently active.

Quickstart:How to select a USB interface setting (UWP app)

When the device is opened for communication, the default interface and its first setting is selected. If you want to change that setting, follow these steps:

  1. Get the active setting of a USB interface by using the UsbInterfaceSetting.Selected](/uwp/api/Windows.Devices.Usb.UsbInterfaceSetting#Windows_Devices_Usb_UsbInterfaceSetting_Selected)'>UsbInterfaceSetting.Selected value.
  2. Set a USB interface setting by starting an asynchronous operation by calling UsbInterfaceSetting.SelectSettingAsync](/uwp/api/Windows.Devices.Usb.UsbInterfaceSetting#Windows_Devices_Usb_UsbInterfaceSetting_SelectSettingAsync)'>UsbInterfaceSetting.SelectSettingAsync.

Step 13— Close the device.

Quickstart:How to connect to a USB device (UWP app)

After you are finished using the UsbDevice object, close the device.

C++ apps must release the reference by using the delete keyword. C#/VB apps must call the UsbDevice.Dispose](/uwp/api/Windows.Devices.Usb.UsbDevice#Windows_Devices_Usb_UsbDevice_Dispose)'>UsbDevice.Dispose method. JavaScript apps must call UsbDevice.Close](/uwp/api/Windows.Devices.Usb.UsbDevice#Windows_Devices_Usb_UsbDevice_Close)'>UsbDevice.Close.

Find it in the sample: See files named Scenario1_DeviceConnect.

Step 14—Create a device metadata package for the app.

Tool:Device Metadata Authoring Wizard
  • If you have the Windows Driver Kit (WDK) installed, open Driver > Device Metadata > Authoring.
  • If you have the Standalone SDK installed, the tool is located at <install_path>binx86DeviceMetadataWizardexe.

Associate your app with the device by following the steps in the wizard. Enter this information about your device:

  • On the Device Info page, enter Model Name, Manufacturer, and Description.
  • On the Hardware Info page, enter the hardware ID of your device.

To declare the app as a privileged app for your device, follow these instructions:

  1. On the App Info page, in the Privileged application group, enter the Package name, Publisher name, and UWP app ID.

    Note Do not check the Access custom driver option.
  2. Open the Finish tab. Select the Copy packages to your system's local metadata store check box.
  3. Connect the device, in Control Panel, open View devices and printers and verify that the icon of the device is correct.

Find it in the sample: See the DeviceMetadata folder.

Step 15—Extend the app to implement AutoPlay activation so that the app is launched when the device is connected to the system.

Quickstart:Register an app for an AutoPlay device

You can add AutoPlay capabilities so that app is launched when the device is connected to the system. You can enable Autoplay for all UWP apps (privileged or otherwise).

  1. In your device metadata package, you must specify how the device should respond to an AutoPlay notification. On the Windows Info tab, select the UWP device app option and enter app information as shown here:
  2. In the app manifest, add AutoPlay Device declaration and launch information as shown here:

  3. In the OnActivated method of the App class, check if the app is activated by the device. If it is, then the method receives a DeviceEventArgs parameter value that contains the DeviceInformation.Id](/uwp/api/Windows.Devices.Enumeration.DeviceInformation#Windows_Devices_Enumeration_DeviceInformation_Id)'>DeviceInformation.Id property value. This is the same value described in Step 6—Extend the app to open the device for communication](#step6)'>Step 6—Extend the app to open the device for communication.

Find it in the sample: See files named Autoplay. For JavaScript, see default.js.

Step 16—Extend the app to implement a background task that can perform length transfers to the device, such as firmware update without the app getting suspended.

To implement background task, you need two classes.

The background task class implements the IBackgroundTask](/uwp/api/Windows.ApplicationModel.Background.IBackgroundTask)'>IBackgroundTask interface and contains the actual code you create to either sync or update your peripheral device. The background task class is executed when the background task is triggered and from the entry point provided in your app’s application manifest.

Note The device background tasks infrastructure provided by Windows 8.1. For more information about Windows background tasks see Supporting your app with background tasks.

Background task class

  1. Implements the IBackgroundTask](/uwp/api/Windows.ApplicationModel.Background.IBackgroundTask)'>IBackgroundTask interface required by the Windows background task infrastructure.
  2. Obtains the DeviceUseDetails instance passed to the class in the Run method and uses this instance to report progress back to the Microsoft Store app and to register for cancellation events.
  3. The Run method also calls the private OpenDevice and WriteToDeviceAsync methods that implement the background device sync code.

The UWP app registers and triggers a DeviceUseTrigger background task. The app register, trigger, and handle progress on a background task.

Note The example code that follows can be applied to the DeviceServicingTrigger background task by use the corresponding objects. The only difference between the two trigger objects and their corresponding APIs are the policy checks made by Windows.
  1. Creates DeviceUseTrigger and BackgroundTaskRegistration objects.
  2. Checks to see if any background tasks were previously registered by this sample application and cancels them by calling the Unregister method on the task.
  3. Registers the background task that will sync with the device. The SetupBackgroundTask method is called from the SyncWithDeviceAsync method in the next step.
    1. Initializes the DeviceUseTrigger and saves it for later use.
    2. Creates a BackgroundTaskBuilder object and uses its Name, TaskEntryPoint and SetTrigger properties and method to register the app’s DeviceUseTrigger object and background task name. The BackgroundTaskBuilder object’s TaskEntryPoint property is set to the full name of the background task class that will be run when the background task is triggered.
    3. Registers for completion and progress events from the background task so the Microsoft Store app can provide completion and progress updates to the user.
  4. The private SyncWithDeviceAsync method registers the background task that will sync with the device and starts the background sync.
    1. Calls the SetupBackgroundTask method from the previous step and registers the background task that will sync with the device.
    2. Calls the private StartSyncBackgroundTaskAsync method which starts the background task.
    3. Closes the app’s handle to the device to ensure that the background task is able to open the device when it starts.
      Note The background task will need to open the device to perform the update so the Microsoft Store app must close its connections to the device before calling RequestAsync
    4. Calls the DeviceUseTrigger object’s RequestAsync method which starts triggers the background task and returns the DeviceTriggerResults object from RequestAsync used to determine if the background task started successfully.
      Note Windows checks to ensure that all necessary task initiation policy checks have been completed. If all policy checks are completed the update operation is now running as a background task outside of the Microsoft Store app, allowing the app to be safely suspended while the operation is in progress. Windows will also enforce any runtime requirements and cancel the background task if those requirements are no longer met.
    5. Uses the DeviceTriggerResults object returned from StartSyncBackgroundTaskAsync to determine if the background task started successfully. A switch statement is used to inspect the result from DeviceTriggerResults.
  5. Implements a private OnSyncWithDeviceProgress event handler that will update the app UI with progress from the background task.
  6. Implements a private OnSyncWithDeviceCompleted event handler to handle the transition from background tasks to foreground app when the background task has completed.
    1. Uses the CheckResults method of the BackgroundTaskCompletedEventArgs object to determine if any exceptions were thrown by the background task.
    2. The app reopens the device for use by the foreground app now that the background task is complete and updates the UI to notify the user.
  7. Implements private button click event handlers from the UI to start and cancel the background task.
    1. The private Sync_Click event handler calls the SyncWithDeviceAsync method described in the previous steps.
    2. The private CancelSync_Click event handler calls the private CancelSyncWithDevice method to cancel the background task.
  8. The private CancelSyncWithDevice method unregisters and cancels any active device syncs so the device can be reopened by using the Unregister method on the BackgroundTaskRegistration object.

Find it in the sample: See files named Scenario7_Sync files. Background class is implemented in IoSyncBackgroundTask.

Step 17—Run Windows App Certification Kit.

Recommended. Running Windows App Certification Kit helps you make sure your app fulfills Microsoft Store requirements, so you should do this when you've added major functionality to your app.

Want to know more?

Learn more from related samples.

Related Samples

Learn more about designing UWP app UI.

Roadmap for UWP apps using C# and Visual Basic and Roadmap for UWP apps using C++

Learn more about creating UWP apps using C++, C#, or Visual Basic in general.

Learn about how to make your apps stay responsive when they do work that might take an extended amount of time.