Partager via

Déclencher une tâche en arrière-plan à partir de votre application

Découvrez comment utiliser le ApplicationTrigger pour activer une tâche en arrière-plan à partir de votre application.

Pour obtenir un exemple de création d’un déclencheur d’application, consultez cet exemple.

Cette rubrique suppose que vous disposez d’une tâche en arrière-plan que vous souhaitez activer à partir de votre application. Si vous n’avez pas encore de tâche en arrière-plan, il existe un exemple de tâche en arrière-plan à BackgroundActivity.cs. Vous pouvez également suivre les étapes décrites dans Créer et inscrire une tâche en arrière-plan hors processus pour en créer une.

Pourquoi utiliser un déclencheur d’application

Utilisez une ApplicationTrigger pour exécuter du code dans un processus distinct de l’application de premier plan. ApplicationTrigger convient si votre application a du travail à effectuer en arrière-plan, même si l’utilisateur ferme l’application de premier plan. Si le travail en arrière-plan doit s'arrêter lorsque l'application est fermée ou être lié à l'état du processus de premier plan, Exécution Étendue devrait plutôt être utilisée.

Créer un déclencheur d’application

Créez un nouvel ApplicationTrigger. Vous pouvez le stocker dans un champ tel qu’il est fait dans l’extrait de code ci-dessous. Cela est pratique afin que nous n’ayez pas à créer une instance ultérieurement lorsque nous voulons signaler le déclencheur. Toutefois, vous pouvez utiliser n’importe quelle instance ApplicationTrigger pour signaler le déclencheur.

// _AppTrigger is an ApplicationTrigger field defined at a scope that will keep it alive
// as long as you need to trigger the background task.
// Or, you could create a new ApplicationTrigger instance and use that when you want to
// trigger the background task.
_AppTrigger = new ApplicationTrigger();

// _AppTrigger is an ApplicationTrigger field defined at a scope that will keep it alive
// as long as you need to trigger the background task.
// Or, you could create a new ApplicationTrigger instance and use that when you want to
// trigger the background task.
Windows::ApplicationModel::Background::ApplicationTrigger _AppTrigger;

// _AppTrigger is an ApplicationTrigger field defined at a scope that will keep it alive
// as long as you need to trigger the background task.
// Or, you could create a new ApplicationTrigger instance and use that when you want to
// trigger the background task.
ApplicationTrigger ^ _AppTrigger = ref new ApplicationTrigger();

(Facultatif) Ajouter une condition

Vous pouvez créer une condition de tâche en arrière-plan pour contrôler quand la tâche s’exécute. Une condition empêche l’exécution de la tâche en arrière-plan jusqu’à ce que la condition soit remplie. Pour plus d’informations, consultez Définir les conditions d’exécution d’une tâche en arrière-plan.

Dans cet exemple, la condition est définie sur InternetAvailable afin que, une fois déclenchée, la tâche s’exécute uniquement une fois que l’accès à Internet est disponible. Pour obtenir la liste des conditions possibles, consultez SystemConditionType.

SystemCondition internetCondition = new SystemCondition(SystemConditionType.InternetAvailable);

Windows::ApplicationModel::Background::SystemCondition internetCondition{
    Windows::ApplicationModel::Background::SystemConditionType::InternetAvailable };

SystemCondition ^ internetCondition = ref new SystemCondition(SystemConditionType::InternetAvailable)

Pour plus d’informations détaillées sur les conditions et les types de déclencheurs en arrière-plan, consultez Soutenez votre application avec des tâches en arrière-plan.

Appeler la fonction RequestAccessAsync()

Avant d’inscrire la tâche en arrière-plan ApplicationTrigger, appelez RequestAccessAsync pour déterminer le niveau d’activité en arrière-plan que l’utilisateur autorise, car l’utilisateur peut avoir désactivé l’activité en arrière-plan pour votre application. Pour plus d’informations sur la façon dont les utilisateurs peuvent contrôler les paramètres de l’activité en arrière-plan, consultez Optimiser l’activité en arrière-plan .

var requestStatus = await Windows.ApplicationModel.Background.BackgroundExecutionManager.RequestAccessAsync();
if (requestStatus != BackgroundAccessStatus.AlwaysAllowed)
{
   // Depending on the value of requestStatus, provide an appropriate response
   // such as notifying the user which functionality won't work as expected
}

Enregistrer la tâche d'arrière-plan

Inscrivez la tâche en arrière-plan en appelant votre fonction d’inscription de tâche en arrière-plan. Pour plus d’informations sur l’inscription des tâches en arrière-plan et pour voir la définition de la méthode RegisterBackgroundTask() dans l’exemple de code ci-dessous, consultez Inscrire une tâche en arrière-plan.

Si vous envisagez d’utiliser un déclencheur d’application pour prolonger la durée de vie de votre processus de premier plan, envisagez d’utiliser exécution étendue à la place. Le déclencheur d’application est conçu pour créer un processus hébergé séparément pour effectuer des tâches. L’extrait de code suivant enregistre un déclencheur d'arrière-plan hors processus.

string entryPoint = "Tasks.ExampleBackgroundTaskClass";
string taskName   = "Example application trigger";

BackgroundTaskRegistration task = RegisterBackgroundTask(entryPoint, taskName, appTrigger, internetCondition);

std::wstring entryPoint{ L"Tasks.ExampleBackgroundTaskClass" };
std::wstring taskName{ L"Example application trigger" };

Windows::ApplicationModel::Background::BackgroundTaskRegistration task{
    RegisterBackgroundTask(entryPoint, taskName, appTrigger, internetCondition) };

String ^ entryPoint = "Tasks.ExampleBackgroundTaskClass";
String ^ taskName   = "Example application trigger";

BackgroundTaskRegistration ^ task = RegisterBackgroundTask(entryPoint, taskName, appTrigger, internetCondition);

Les paramètres d’inscription des tâches en arrière-plan sont validés au moment de l’inscription. Une erreur est retournée si l’un des paramètres d’inscription n’est pas valide. Assurez-vous que votre application gère correctement les scénarios où l’inscription des tâches en arrière-plan échoue. Si votre application dépend plutôt d’avoir un objet d’inscription valide après avoir tenté d’inscrire une tâche, il peut se bloquer.

Déclencher la tâche en arrière-plan

Avant de déclencher la tâche en arrière-plan, utilisez BackgroundTaskRegistration pour vérifier que la tâche en arrière-plan est inscrite. Un bon moment pour vérifier que toutes vos tâches en arrière-plan sont inscrites est pendant le lancement de l’application.

Déclenchez la tâche en arrière-plan en appelant ApplicationTrigger.RequestAsync. Toute instance ApplicationTrigger fera l'affaire.

Notez que ApplicationTrigger.RequestAsync ne peut pas être appelé à partir de la tâche en arrière-plan elle-même, ou lorsque l’application est dans l’état d’exécution en arrière-plan (consultez cycle de vie de l’application pour plus d’informations sur les états d’application). Il se peut qu’il renvoie DisabledByPolicy si l’utilisateur a défini des politiques d’énergie ou de confidentialité qui empêchent l’application de réaliser des activités en arrière-plan. En outre, un seul AppTrigger peut s’exécuter à la fois. Si vous tentez d’exécuter un AppTrigger alors qu'un autre est déjà en cours d’exécution, la fonction retourne ActuellementEnCours.

var result = await _AppTrigger.RequestAsync();

Gérer les ressources de votre tâche d'arrière-plan

Utilisez BackgroundExecutionManager.RequestAccessAsync pour déterminer si l’utilisateur a décidé que l’activité en arrière-plan de votre application doit être limitée. N’oubliez pas l’utilisation de votre batterie et exécutez uniquement en arrière-plan quand il est nécessaire d’effectuer une action souhaitée par l’utilisateur. Pour plus d’informations sur la façon dont les utilisateurs peuvent contrôler les paramètres de l’activité en arrière-plan, consultez Optimiser l’activité en arrière-plan .

  • Mémoire : le réglage de la mémoire et de l’énergie de votre application est essentiel pour vous assurer que le système d’exploitation permettra à votre tâche en arrière-plan de s’exécuter. Utilisez les API de gestion de la mémoire pour voir la quantité de mémoire utilisée par votre tâche en arrière-plan. Plus la mémoire utilisée par votre tâche en arrière-plan est élevée, plus il est difficile pour le système d’exploitation de le maintenir en cours d’exécution lorsqu’une autre application est au premier plan. L’utilisateur contrôle finalement toutes les activités en arrière-plan que votre application peut effectuer et a une visibilité sur l’impact que votre application a sur l’utilisation de la batterie.
  • Temps processeur : les tâches en arrière-plan sont limitées par la quantité de temps d’utilisation de l’horloge murale qu’elles obtiennent en fonction du type de déclencheur. Les tâches en arrière-plan déclenchées par le déclencheur d’application sont limitées à environ 10 minutes.

Consultez Soutenez votre application avec des tâches en arrière-plan pour connaître les contraintes de ressources appliquées aux tâches en arrière-plan.

Remarques

À compter de Windows 10, il n’est plus nécessaire pour l’utilisateur d’ajouter votre application à l’écran de verrouillage afin d’utiliser des tâches en arrière-plan.

Une tâche en arrière-plan s’exécute uniquement à l’aide d’une ApplicationTrigger si vous avez appelé RequestAccessAsync en premier.

  • Last updated on