Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Important
Les métadonnées de l’appareil sont déconseillées et seront supprimées dans une version ultérieure de Windows. Pour plus d’informations sur le remplacement de cette fonctionnalité, consultez Métadonnées du conteneur de package de pilotes.
Votre application UWP peut utiliser une tâche en arrière-plan d’appareil pour synchroniser les données sur votre appareil périphérique. Si votre application est associée aux métadonnées de l’appareil, cette application d’appareil UWP peut également utiliser un agent d’arrière-plan d’appareil pour effectuer des mises à jour d’appareil, telles que les mises à jour du microprogramme. Les agents en arrière-plan de l’appareil sont soumis à des stratégies qui garantissent le consentement de l’utilisateur et aident à préserver la durée de vie de la batterie pendant la synchronisation et la mise à jour des appareils.
Pour effectuer des opérations de synchronisation et de mise à jour d’appareil, créez une tâche en arrière-plan d’appareil qui utilise deviceUseTrigger et DeviceServicingTrigger, respectivement. Pour savoir comment créer une tâche en arrière-plan d’appareil avec l’exemple d’appareil USB personnalisé, consultez Création d’une tâche en arrière-plan d’appareil.
Les API d’appareil Windows Runtime ne nécessitent pas de métadonnées d’appareil. Cela signifie que votre application n’a pas besoin d’être une application d’appareil UWP pour les utiliser. Les applications UWP peuvent utiliser ces API pour accéder à USB, appareils HID (Human Interface Devices), Bluetooth, etc. Pour plus d’informations, consultez Intégration d’appareils.
Vue d'ensemble de la tâche en arrière-plan de l'appareil
Lorsque les utilisateurs déplacent votre application UWP hors écran, Windows suspend votre application en mémoire, ce qui permet à une autre application d’avoir le premier plan. Lorsqu’une application est suspendue, elle réside dans la mémoire, mais Windows l’a arrêtée de s’exécuter.
Toutes les opérations d’appareil en cours telles que la synchronisation et la mise à jour sont interrompues sans l’aide d’une tâche en arrière-plan de l’appareil. Windows fournit deux déclencheurs de tâche en arrière-plan pour résoudre ce problème : DeviceUseTrigger et DeviceServicingTrigger. Ces déclencheurs permettent à votre application d’effectuer des opérations de synchronisation et de mise à jour longues sur votre appareil périphérique en toute sécurité en arrière-plan, même si votre application est suspendue. Pour plus d’informations sur la suspension de l’application, consultez Lancement, reprise et multitâche.
| Déclencheur de tâche en arrière-plan | Nécessite des métadonnées d’appareil | Descriptif |
|---|---|---|
| DeviceUseTrigger | Non | Active les opérations de synchronisation longues vers ou depuis votre appareil périphérique pendant la suspension de votre application. La synchronisation de votre appareil en arrière-plan nécessite que votre utilisateur approuve la synchronisation en arrière-plan par votre application. Votre appareil doit également être connecté ou associé au PC, avec des E/S actives et un maximum de 10 minutes d’activité en arrière-plan autorisée. Vous trouverez plus de détails sur l’application des stratégies plus loin dans cet article. |
| DeviceServicingTrigger | Oui | Active les mises à jour prolongées des appareils, par exemple les transferts de paramètres ou les mises à jour du firmware, pendant que votre application est suspendue. La mise à jour de votre appareil en arrière-plan nécessite l’approbation de l’utilisateur chaque fois que la tâche en arrière-plan est utilisée. Contrairement à la tâche en arrière-plan DeviceUseTrigger, la tâche en arrière-plan DeviceServicingTrigger permet le redémarrage et la déconnexion de l’appareil et autorise un maximum de 30 minutes d’activité en arrière-plan. Vous trouverez plus de détails sur l’application des stratégies plus loin dans cet article. |
DeviceServicingTrigger nécessite des métadonnées d’appareil, car l’application doit être spécifiée en tant qu’application privilégiée afin d’effectuer des opérations de mise à jour d’appareil.
Privilège d’application
Une application privilégiée peut effectuer certaines opérations critiques sur les appareils, telles que les mises à jour longues des appareils. Une application privilégiée est l’application que le fabricant de l’appareil autorise à effectuer ces opérations. Les métadonnées de l’appareil spécifient quelle application, le cas échéant, est désignée comme application privilégiée pour un appareil.
Lorsque vous créez vos métadonnées d’appareil avec l’Assistant Métadonnées de l’appareil, spécifiez votre application dans la page Spécifier les informations de l’application d’appareil UWP . Pour plus d’informations, consultez l’étape 2 : Créer des métadonnées d’appareil pour votre application d’appareil UWP.
Protocoles pris en charge
Les tâches en arrière-plan d’appareil qui utilisent DeviceUseTrigger et DeviceServicingTrigger permettent à votre application de communiquer avec des appareils périphériques via des protocoles spécifiques. Les tâches déclenchées par le système généralement utilisées par les applications UWP ne prennent pas en charge ces protocoles.
| Protocole | DeviceServicingTrigger | DeviceUseTrigger | Déclencheurs du système |
|---|---|---|---|
| USB |
|
|
|
| CACHÉ |
|
|
|
| Bluetooth RFCOMM |
|
|
|
| Bluetooth GATT |
|
|
|
| MTP |
|
|
|
| Réseau câblé |
|
|
|
| Réseau Wi-Fi |
|
|
|
| IDeviceIOControl |
|
|
|
Inscription de tâches en arrière-plan dans le manifeste du package d’application
Votre application effectue des opérations de synchronisation et de mise à jour dans le code qui s’exécute dans le cadre d’une tâche en arrière-plan. Ce code est incorporé dans une classe Windows Runtime qui implémente IBackgroundTask (ou dans une page JavaScript dédiée pour les applications JavaScript). Pour utiliser une tâche en arrière-plan d’appareil, votre application doit la déclarer dans le fichier manifeste de l’application d’une application de premier plan, comme pour les tâches en arrière-plan déclenchées par le système.
Dans cet exemple de fichier manifeste de package d’application, DeviceLibrary.SyncContent et DeviceLibrary.UpdateFirmware sont des points d’entrée de l’application de premier plan. DeviceLibrary.SyncContent est le point d’entrée de la tâche en arrière-plan qui utilise DeviceUseTrigger. DeviceLibrary.UpdateFirmware est le point d’entrée de la tâche en arrière-plan qui utilise DeviceServicingTrigger.
<Extensions>
<Extension Category="windows.backgroundTasks" EntryPoint="DeviceLibrary.SyncContent">
<BackgroundTasks>
<m2:Task Type="deviceUse" />
</BackgroundTasks>
</Extension>
<Extension Category="windows.backgroundTasks" EntryPoint="DeviceLibrary.UpdateFirmware">
<BackgroundTasks>
<m2:Task Type="deviceServicing" />
</BackgroundTasks>
</Extension>
</Extensions>
Utilisation de votre appareil avec des tâches en arrière-plan de l’appareil
Pour développer votre application afin de tirer parti des tâches en arrière-plan DeviceUseTrigger et DeviceServicingTrigger, vous suivez cet ensemble d’étapes de base. Pour plus d’informations sur les tâches en arrière-plan, consultez Prise en charge de votre application avec des tâches en arrière-plan.
Votre application inscrit sa tâche en arrière-plan dans le manifeste de l’application et incorpore le code de tâche en arrière-plan dans une classe Windows Runtime qui implémente IBackgroundTask ou dans une page JavaScript dédiée pour les applications JavaScript.
Au démarrage de votre application, elle crée et configure un objet de déclencheur d’appareil du type approprié, DeviceUseTrigger ou DeviceServicingTrigger, puis stocke l’instance de déclencheur pour une utilisation ultérieure.
Votre application vérifie si la tâche en arrière-plan a été précédemment inscrite et, si ce n’est pas le cas, l’inscrit auprès du déclencheur de l’appareil. Votre application n’est pas autorisée à définir des conditions sur la tâche associée à ce déclencheur.
Lorsque votre application doit déclencher la tâche en arrière-plan, elle appelle la méthode d’activation RequestAsync sur l’objet déclencheur d’appareil.
Votre tâche en arrière-plan n’est pas limitée comme d’autres tâches en arrière-plan système (il n’existe aucun quota de temps processeur), mais s’exécute avec une priorité réduite pour maintenir la réactivité des applications de premier plan.
En fonction du type de déclencheur, Windows vérifie que les stratégies nécessaires sont remplies, notamment en demandant le consentement de l’utilisateur pour l’opération avant de démarrer la tâche en arrière-plan.
Windows surveille les conditions système et le runtime des tâches et, si nécessaire, annule la tâche si les conditions requises ne sont plus remplies.
Lorsque les tâches en arrière-plan indiquent la progression ou l’achèvement, votre application reçoit ces événements par le biais d’événements de progression et d’achèvement sur la tâche inscrite.
Points importants à prendre en compte lors de l’utilisation des tâches en arrière-plan de l’appareil
La possibilité de déclencher par programmation des tâches en arrière-plan qui utilisent DeviceUseTrigger et DeviceServicingTrigger est limitée aux tâches en arrière-plan de l’appareil uniquement.
Windows applique certaines stratégies pour garantir le consentement de l’utilisateur lors de la mise à jour de ses périphériques. D’autres stratégies sont appliquées pour préserver la durée de vie de la batterie de l’utilisateur lors de la synchronisation et de la mise à jour des périphériques.
Windows peut annuler des tâches d'arrière-plan qui utilisent DeviceUseTrigger et DeviceServicingTrigger lorsque certaines exigences de stratégie ne sont plus remplies, y compris une durée maximale d'arrière-plan (temps d'horloge). Il est important de prendre en compte ces exigences de stratégie lors de l’utilisation de ces tâches en arrière-plan pour interagir avec votre appareil périphérique.
Conseil / Astuce
Pour voir comment fonctionnent ces tâches en arrière-plan, téléchargez un exemple. L’exemple d’appareil USB personnalisé illustre une tâche en arrière-plan qui effectue la synchronisation de l’appareil avec DeviceUseTrigger.
Consentement de l’utilisateur
Lorsque votre application utilise DeviceUseTrigger ou DeviceServicingTrigger, Windows applique des stratégies pour s’assurer que l’utilisateur autorise votre application à accéder à leur appareil en arrière-plan pour synchroniser et mettre à jour du contenu. Les stratégies sont également appliquées pour préserver la durée de vie de la batterie des utilisateurs lors de la synchronisation et de la mise à jour des périphériques.
Consentement de l’utilisateur de synchronisation des appareils
Une tâche en arrière-plan qui utilise DeviceUseTrigger nécessite un consentement utilisateur unique permettant à votre application de se synchroniser en arrière-plan. Ce consentement est stocké par application et par modèle d’appareil. L’utilisateur consent à permettre à l’application d’accéder à l’appareil en arrière-plan, tout comme pour permettre à l’application d’accéder à l’appareil lorsque l’application est au premier plan.
Dans l’exemple suivant, une application nommée Tailspin Toys obtient l’autorisation utilisateur de se synchroniser en arrière-plan.
Si les utilisateurs changent d’avis ultérieurement, ils peuvent révoquer des autorisations dans Paramètres.
Consentement de mise à jour de l’appareil par l'utilisateur
Contrairement aux tâches en arrière-plan qui utilisent DeviceUseTrigger, celles qui utilisent la tâche en arrière-plan DeviceServicingTrigger nécessitent le consentement de l’utilisateur chaque fois que la tâche en arrière-plan est déclenchée. Ce consentement n’est pas stocké comme pour DeviceUseTrigger. Cela est dû au fait que les mises à jour du microprogramme d’appareil impliquent des opérations à risque plus élevé et ont besoin de plus de temps pour se terminer.
Windows fournit également aux utilisateurs des informations sur les mises à jour des appareils. Cela inclut des avertissements pour maintenir l’appareil connecté tout au long de la mise à jour et pour s’assurer que le PC est chargé. Windows affiche également l’heure d’exécution approximative de l’opération si votre application la fournit.
Restrictions de fréquence et de premier plan
Il n’existe aucune restriction sur la fréquence à laquelle votre application peut lancer des opérations, mais votre application ne peut exécuter qu’une seule opération deviceUseTrigger ou DeviceServicingTrigger en arrière-plan à la fois (cela n’affecte pas d’autres types de tâches en arrière-plan) et peut lancer une tâche en arrière-plan uniquement pendant que votre application est au premier plan. Lorsque votre application n’est pas au premier plan, elle ne peut pas lancer une tâche en arrière-plan avec DeviceUseTrigger ou DeviceServicingTrigger. Votre application ne peut pas lancer une deuxième tâche en arrière-plan d’appareil avant la fin de la première tâche en arrière-plan.
Stratégies de tâches d'arrière-plan de l’appareil
Windows applique des stratégies lorsque votre application utilise une tâche en arrière-plan d’appareil. Si ces stratégies ne sont pas remplies, la tâche en arrière-plan utilisant DeviceUseTrigger ou DeviceServicingTrigger peut être annulée. Il est important de prendre en compte ces exigences de stratégie lors de l’utilisation de tâches en arrière-plan d’appareil pour interagir avec votre appareil périphérique.
Stratégies d’initiation de tâche
Ce tableau indique quelles stratégies d’initiation de tâche s’appliquent à chaque déclencheur de tâche en arrière-plan.
| Stratégie | DeviceServicingTrigger | DeviceUseTrigger |
|---|---|---|
| Votre application UWP est au premier plan lors du déclenchement de la tâche en arrière-plan. |
|
|
| Votre appareil est connecté au système (ou à portée d’un appareil sans fil). |
|
|
| Votre tâche en arrière-plan consomme 400 ms de temps processeur (en supposant un processeur de 1 GHz) toutes les minutes lorsque l’écran est verrouillé ou toutes les 5 minutes lorsque l’écran n’est pas verrouillé. L’échec de la conformité à cette stratégie peut entraîner l’annulation de votre tâche. |
|
|
| Votre appareil est accessible à l’application à l’aide des API périphériques de l’appareil (API Windows Runtime pour USB, HID, Bluetooth, etc.). Si votre application ne peut pas accéder à l’appareil, l’accès aux tâches en arrière-plan est refusé. |
|
|
| Le point d’entrée de tâche en arrière-plan fourni par l’application est inscrit dans le manifeste du package d’application. |
|
|
| L’utilisateur a donné l’autorisation de poursuivre la tâche. | Toujours. | Première fois, puis géré par les autorisations de l'application. |
| L’estimation du temps fournie par l’application est inférieure à 30 minutes. |
|
|
| L’application est spécifiée en tant qu’application privilégiée pour l’appareil. (Il doit y avoir une correspondance complète de l'ID d'application par rapport à la liste des applications privilégiées dans les métadonnées du conteneur de périphériques.) |
|
|
| L’ordinateur a plus de 33% de charge de batterie restante ou est sur l’alimentation AC. |
|
|
| Une seule tâche en arrière-plan d’appareil s’exécute par type d’opération. |
|
|
Vérifications de politique d’exécution
Windows applique les exigences de stratégie d’exécution suivantes pendant l’exécution de votre tâche en arrière-plan. Si l’une des exigences du runtime cesse d’être vraie, Windows annule la tâche en arrière-plan de votre appareil.
Ce tableau indique quelles stratégies d’exécution s’appliquent à chaque déclencheur de tâche en arrière-plan.
| Vérification de la stratégie | DeviceServicingTrigger | DeviceUseTrigger |
|---|---|---|
| Limite de temps de l’horloge murale : durée totale pendant laquelle la tâche de votre application peut s’exécuter en arrière-plan. | 30 minutes | 10 minutes |
| Votre appareil est connecté au système (ou à portée d’un appareil sans fil). |
|
|
| La tâche effectue des E/S régulières sur le dispositif (1 E/S toutes les 5 secondes). |
|
|
| L’application n’a pas annulé la tâche. |
|
|
| L’application ne s’est pas fermée. |
|
|
Meilleures pratiques
Voici les meilleures pratiques pour les applications d’appareil UWP qui utilisent les tâches en arrière-plan de l’appareil.
Modèle de programmation de tâches en arrière-plan de l’appareil
L’utilisation des tâches en arrière-plan DeviceUseTrigger ou DeviceServicingTrigger à partir de votre application garantit que toutes les opérations de synchronisation ou de mise à jour d’appareil démarrées à partir de votre application de premier plan continuent de s’exécuter en arrière-plan si vos utilisateurs changent d’applications et que votre application de premier plan est suspendue par Windows. Nous vous recommandons de suivre ce modèle global pour l’inscription, le déclenchement et la désinscription de vos tâches en arrière-plan :
Inscrivez la tâche en arrière-plan avant de demander le déclencheur.
Connectez les gestionnaires d’événements de progression et d’achèvement à votre déclencheur. Lorsque votre application revient de suspension, Windows fournit à votre application les événements de progression ou d’achèvement mis en file d’attente qui peuvent être utilisés pour déterminer l’état de vos tâches en arrière-plan.
Fermez les objets d’appareil ouverts lorsque vous déclenchez vos tâches en arrière-plan DeviceUseTrigger ou DeviceServicingTrigger afin que ces appareils soient libres d’être ouverts et utilisés par votre tâche en arrière-plan.
Enregistrez le déclencheur.
Une fois la tâche terminée, désinscrivez la tâche d'arrière-plan. Une fois votre tâche en arrière-plan terminée, vous pouvez annuler l’inscription des tâches en arrière-plan et rouvrir l’appareil et l’utiliser régulièrement à partir de votre application UWP.
Inscrivez-vous aux événements d’annulation à partir de votre classe de tâches d’arrière-plan. L’inscription aux événements d’annulation permet à votre code de tâche en arrière-plan d’arrêter correctement votre tâche en arrière-plan en cours d’exécution lorsqu’elle est annulée par Windows ou votre application de premier plan.
Lors de la sortie de l’application (pas de suspension), annulez l’inscription et annulez les tâches en cours d’exécution.
Une fois votre application terminée, annulez l’inscription et annulez les tâches en cours d’exécution.
Une fois votre application terminée, vos tâches en arrière-plan sont annulées et tous les gestionnaires d’événements existants sont déconnectés de vos tâches en arrière-plan existantes. Cela vous empêche de déterminer l’état de vos tâches en arrière-plan. L’annulation de l’inscription et l’annulation de la tâche en arrière-plan permettent à votre code d’annulation d’arrêter correctement vos tâches en arrière-plan.
Conseil / Astuce
Pour obtenir une description détaillée de la façon dont cela est effectué avec l’exemple d’appareil USB personnalisé, consultez Création d’une tâche en arrière-plan d’appareil.
Annulation d’une tâche en arrière-plan
Pour annuler une tâche exécutée en arrière-plan à partir de votre application de premier plan, utilisez la méthode Unregister sur l’objet BackgroundTaskRegistration que vous utilisez dans votre application pour inscrire la tâche en arrière-plan DeviceUseTrigger ou DeviceServicingTrigger . La désinscription de votre tâche en arrière-plan à l'aide de la méthode Unregister sur BackgroundTaskRegistration entraîne l'infrastructure de tâches en arrière-plan à annuler votre tâche en arrière-plan.
La méthode Unregister prend également une valeur booléenne true ou false pour indiquer si les instances en cours d’exécution de votre tâche en arrière-plan doivent être annulées sans leur permettre de terminer. Pour plus d’informations, consultez la référence de l’API pour BackgroundTaskRegistration.Unregister.