Accéder à des capteurs et des appareils à partir d’une tâche en arrière-plan

Article
07/05/2024

DeviceUseTrigger permet à votre application Windows universelle d’accéder aux capteurs et aux appareils en arrière-plan, même si votre application d’avant-plan est interrompue. Par exemple, selon l’emplacement d’exécution de votre application, elle peut utiliser une tâche en arrière-plan pour synchroniser des données avec des appareils ou surveiller des capteurs. Pour préserver la durée de vie de la batterie et garantir le consentement de l’utilisateur approprié, l’utilisation de DeviceUseTrigger est soumise à des stratégies décrites dans cette rubrique.

Pour accéder aux capteurs ou périphériques en arrière-plan, créez une tâche en arrière-plan qui utilise DeviceUseTrigger. Pour obtenir un exemple montrant comment cela est effectué sur un PC, consultez l’exemple d’appareil USB personnalisé. Pour obtenir un exemple sur un téléphone, consultez l’exemple Capteurs d’arrière-plan.

Important

DeviceUseTrigger ne peut pas être utilisé avec des tâches en arrière-plan in-process. Les informations de cette rubrique s’appliquent uniquement aux tâches en arrière-plan qui s’exécutent hors processus.

Vue d’ensemble des tâches d’arrière-plan de périphérique

Lorsque votre application n’est plus visible par l’utilisateur, Windows suspend ou met fin à votre application pour récupérer de la mémoire et des ressources processeur. Cela permet à d’autres applications de s’exécuter au premier plan et de réduire la consommation de batterie. Lorsque cela se produit, sans l’aide d’une tâche en arrière-plan, tous les événements de données en cours seront perdus. Windows fournit le déclencheur de tâche en arrière-plan, DeviceUseTrigger, pour permettre à votre application d’effectuer des opérations de synchronisation et de surveillance longues sur des appareils et des capteurs en toute sécurité en arrière-plan, même si votre application est suspendue. Pour plus d’informations sur le cycle de vie des applications, consultez Lancement, reprise et tâches en arrière-plan. Pour plus d’informations sur les tâches en arrière-plan, consultez Prendre en charge votre application avec des tâches en arrière-plan.

Remarque Dans une application Windows universelle, la synchronisation d’un appareil en arrière-plan nécessite que votre utilisateur ait approuvé la synchronisation en arrière-plan par votre application. L’appareil doit également être connecté ou associé au PC, avec des E/S actives et est autorisé à un maximum de 10 minutes d’activité en arrière-plan. Plus de détails sur l’application des politiques sont décrits plus loin dans ce sujet.

Limitation : opérations critiques sur les appareils

Certaines opérations critiques sur les appareils, telles que les mises à jour de microprogramme longues, ne peuvent pas être effectuées avec DeviceUseTrigger. Ces opérations peuvent être effectuées uniquement sur le PC, et uniquement par une application privilégiée qui utilise DeviceServicingTrigger. Une application privilégiée est une application que le fabricant de l’appareil a autorisée à effectuer ces opérations. Les métadonnées de l’appareil sont utilisées pour spécifier l’application, le cas échéant, qui a été désignée comme application privilégiée pour un appareil. Pour plus d’informations, consultez Synchronisation et mise à jour des appareils du Microsoft Store.

Protocoles/API pris en charge dans une tâche en arrière-plan DeviceUseTrigger

Les tâches en arrière-plan qui utilisent DeviceUseTrigger permettent à votre application de communiquer sur de nombreux protocoles/API, dont la plupart ne sont pas pris en charge par les tâches en arrière-plan déclenchées par le système. Les éléments suivants sont pris en charge sur une application Windows universelle.

Protocol	DeviceUseTrigger dans une application Windows universelle
USB
HID
Bluetooth RFCOMM
Bluetooth GATT
MTP
Réseau câblé
Réseau Wi-Fi
IDeviceIOControl
API Capteurs	(limité aux capteurs de la famille d’appareils universels)

Enregistrement des tâches d’arrière-plan dans le manifeste de package d’application

Votre application effectuera des opérations de synchronisation et de mise à jour dans le code qui s’exécute dans le cadre d’une tâche d’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 DeviceUseTrigger , 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 est le point d’entrée d’une tâche en arrière-plan qui utilise DeviceUseTrigger.

<Extensions>
  <Extension Category="windows.backgroundTasks" EntryPoint="DeviceLibrary.SyncContent">
    <BackgroundTasks>
      <m2:Task Type="deviceUse" />
    </BackgroundTasks>
  </Extension>
</Extensions>

Présentation de l’utilisation de DeviceUseTrigger

Pour utiliser DeviceUseTrigger, suivez ces étapes de base. Pour plus d’informations sur les tâches en arrière-plan, consultez Prendre en charge votre application avec des tâches en arrière-plan.

Votre application enregistre sa tâche d’arrière-plan dans le manifeste de package de l’application et intègre le code de la tâche d’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 déclencheur de type DeviceUseTrigger et 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é inscrite précédemment et, si ce n’est pas le cas, l’inscrit auprès du déclencheur. Notez que 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 doit d’abord appeler RequestAccessAsync pour vérifier si l’application est en mesure de demander une tâche en arrière-plan.
Si l’application peut demander 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.
Windows validera ensuite, en fonction du type de déclencheur, que les politiques nécessaires ont été respectées, notamment en demandant le consentement de l’utilisateur pour l’opération avant de démarrer la tâche d’arrière-plan.
Windows surveille les conditions du système et le temps d’exécution des tâches, et, si nécessaire, annule la tâche si les conditions requises ne sont plus remplies.
Lorsque les tâches d’arrière-plan signalent des progrès ou des achèvements, votre application recevra ces événements via les événements de progression et d’achèvement de la tâche enregistrée.

Prenez en compte ces points importants lors de l’utilisation de DeviceUseTrigger :

La possibilité de déclencher par programmation des tâches en arrière-plan qui utilisent DeviceUseTrigger a été introduite pour la première fois dans Windows 8.1 et Windows Phone 8.1.
Certaines stratégies sont appliquées par Windows pour garantir le consentement de l’utilisateur lors de la mise à jour des périphériques sur le PC.
Des politiques supplémentaires 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.
Les tâches en arrière-plan qui utilisent DeviceUseTrigger peuvent être annulées par Windows lorsque certaines exigences de stratégie ne sont plus remplies, y compris une durée maximale d’arrière-plan (heure de l’horloge mur). Il est important de prendre en compte ces exigences de politique lors de l’utilisation de ces tâches d’arrière-plan pour interagir avec votre périphérique.

Conseil Pour voir comment fonctionnent ces tâches en arrière-plan, téléchargez un exemple. Pour obtenir un exemple montrant comment cela est effectué sur un PC, consultez l’exemple d’appareil USB personnalisé. Pour obtenir un exemple sur un téléphone, consultez l’exemple Capteurs d’arrière-plan.

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 de tâche en arrière-plan DeviceUseTrigger à 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. Votre application ne peut pas lancer une deuxième tâche en arrière-plan DeviceUseTrigger avant la fin de la première tâche en arrière-plan.

Restrictions de l’appareil

Bien que chaque application soit limitée à l’inscription et à l’exécution d’une seule tâche en arrière-plan DeviceUseTrigger, l’appareil (sur lequel votre application est en cours d’exécution) peut autoriser plusieurs applications à inscrire et exécuter des tâches en arrière-plan DeviceUseTrigger. Selon l’appareil, il peut y avoir une limite sur le nombre total de tâches en arrière-plan DeviceUseTrigger de toutes les applications. Cela permet de préserver la batterie sur les appareils limités aux ressources. Pour plus d’informations, consultez le tableau suivant.

À partir d’une tâche en arrière-plan DeviceUseTrigger unique, votre application peut accéder à un nombre illimité d’appareils périphériques ou de capteurs , limité uniquement par les API et protocoles pris en charge répertoriés dans le tableau précédent.

Stratégies de tâche en arrière-plan

Windows applique des stratégies lorsque votre application utilise une tâche en arrière-plan DeviceUseTrigger. Si ces stratégies ne sont pas remplies, la tâche en arrière-plan peut être annulée. Il est important de prendre en compte ces exigences de stratégie lors de l’utilisation de ce type de tâche en arrière-plan pour interagir avec des appareils ou des capteurs.

Politiques d’initiation des tâches

Ce tableau indique quelles stratégies d’initiation de tâche s’appliquent à une application Windows universelle.

Stratégie	DeviceUseTrigger dans une application Windows universelle
Votre application est au premier plan lors du déclenchement de la tâche en arrière-plan.
L’appareil est attaché au système (ou dans la plage d’un appareil sans fil).
L’appareil est accessible à l’application à l’aide des API périphériques d’appareil prises en charge (API Windows Runtime pour USB, HID, Bluetooth, Capteurs, etc.). Si votre application ne peut pas accéder à l’appareil ou au capteur, l’accès à la tâche en arrière-plan est refusé.
Le point d’entrée de la tâche d’arrière-plan fourni par l’application est enregistré dans le manifeste de package de l’application.
Une seule tâche en arrière-plan DeviceUseTrigger est en cours d’exécution par application.
Le nombre maximal de tâches en arrière-plan DeviceUseTrigger n’a pas encore été atteint sur l’appareil (sur lequel votre application est en cours d’exécution).	Famille d’appareils de bureau : un nombre illimité de tâches peut être inscrit et exécuté en parallèle. Famille d’appareils mobiles : 1 tâche sur un appareil de 512 Mo ; sinon, 2 tâches peuvent être inscrites et exécutées en parallèle.
Nombre maximal d’appareils périphériques ou de capteurs auxquels votre application peut accéder à partir d’une tâche en arrière-plan DeviceUseTrigger unique, lors de l’utilisation des API/protocoles pris en charge.	illimité
Votre tâche d’arrière-plan consomme 400 ms de temps CPU (en supposant un CPU à 1 GHz) toutes les minutes lorsque l’écran est verrouillé, ou toutes les 5 minutes lorsque l’écran n’est pas verrouillé. Le non-respect de cette politique peut entraîner l’annulation de votre tâche.

Vérifications de politique d’exécution

Windows applique les exigences de politique d’exécution suivantes pendant que votre tâche s’exécute en arrière-plan. Si l’une des exigences d’exécution cesse d’être vraie, Windows annulera votre tâche d’arrière-plan de périphérique.

Ce tableau indique quelles stratégies d’exécution s’appliquent à une application Windows universelle.

Vérification de la politique	DeviceUseTrigger dans une application Windows universelle
L’appareil est attaché au système (ou dans la plage d’un appareil sans fil).
La tâche effectue des E/S régulières vers le périphérique (1 E/S toutes les 5 secondes).
L’application n’a pas annulé la tâche.
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.	Famille d’appareils de bureau : 10 minutes. Famille d’appareils mobiles : aucune limite de temps. Pour conserver des ressources, il n’y a pas plus de 1 ou 2 tâches qui peuvent s’exécuter simultanément.
L’application n’a pas quitté.

Bonnes pratiques

Voici les meilleures pratiques pour les applications qui utilisent les tâches en arrière-plan DeviceUseTrigger.

Programmation d’une tâche en arrière-plan

L’utilisation de la tâche en arrière-plan DeviceUseTrigger à partir de votre application garantit que toutes les opérations de synchronisation ou de surveillance démarrées à partir de votre application de premier plan continuent à 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 d’enregistrement, de déclenchement et de désenregistrement de vos tâches d’arrière-plan :

Appelez RequestAccessAsync pour vérifier si l’application est en mesure de demander une tâche en arrière-plan. Cette opération doit être effectuée avant d’inscrire une tâche en arrière-plan.
Enregistrez la tâche d’arrière-plan avant de demander le déclencheur.
Connectez des gestionnaires d’événements de progression et de terminaison à votre déclencheur. Lorsque votre application revient de la suspension, Windows fournira à votre application tous les événements de progression ou de terminaison mis en file d’attente qui peuvent être utilisés pour déterminer l’état de vos tâches d’arrière-plan.
Fermez tous les objets d’appareil ou de capteur ouverts lorsque vous déclenchez votre tâche en arrière-plan DeviceUseTrigger afin que ces appareils ou capteurs soient libres d’être ouverts et utilisés par votre tâche en arrière-plan.
Enregistrez le déclencheur.
Examinez attentivement l’impact de la batterie sur l’accès à un appareil ou à un senor à partir d’une tâche en arrière-plan. Par exemple, si l’intervalle de rapport d’un capteur s’exécute trop fréquemment peut entraîner l’exécution de la tâche si souvent qu’elle draine rapidement la batterie d’un téléphone.
Une fois votre tâche en arrière-plan terminée, annulez son inscription.
Enregistrez-vous pour les événements d’annulation à partir de la classe de votre tâche d’arrière-plan. L’enregistrement des événements d’annulation permet à votre code de tâche d’arrière-plan d’arrêter proprement votre tâche d’arrière-plan en cours d’exécution lorsqu’elle est annulée par Windows ou votre application en 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 si votre application n’en a plus besoin. Sur les systèmes limités aux ressources, tels que les téléphones à mémoire faible, cela permet à d’autres applications d’utiliser une tâche en arrière-plan DeviceUseTrigger.
- Lorsque votre application se ferme, désenregistrez et annulez toutes les tâches en cours d’exécution.
- Lorsque votre application se ferme, vos tâches d’arrière-plan seront annulées et tous les gestionnaires d’événements existants seront déconnectés de vos tâches d’arrière-plan existantes. Cela vous empêche de déterminer l’état de vos tâches d’arrière-plan. Le désenregistrement et l’annulation de la tâche d’arrière-plan garantissent que vos tâches d’arrière-plan se ferment proprement et que Windows nettoie tous les gestionnaires d’événements associés.

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. L’annulation de l’inscription de votre tâche en arrière-plan à l’aide de la méthode Unregister sur BackgroundTaskRegistration entraîne l’annulation de l’infrastructure des tâches en arrière-plan pour 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 annuler l’inscription.

En plus de annuler l’inscription, votre application doit également appeler BackgroundTaskDeferral.Complete. Cela informe le système que l’opération asynchrone associée à une tâche en arrière-plan est terminée.

Partager via