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

  • Article

Découvrez comment utiliser 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 sur 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 un ApplicationTrigger pour exécuter du code dans un processus distinct de l’application de premier plan. Un ApplicationTrigger est approprié 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 doit être lié à l’état du processus de premier plan, l’exécution étendue doit être utilisée à la place.

Créer un déclencheur d’application

Créez un objet ApplicationTrigger. Vous pouvez le stocker dans un champ, comme cela est fait dans l’extrait de code ci-dessous. C’est par commodité que nous n’avons pas besoin de créer un nouveau instance plus tard lorsque nous voulons signaler le déclencheur. Toutefois, vous pouvez utiliser n’importe quel 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 l’exécution de la tâche. 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 des conditions pour l’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 ne s’exécute qu’une fois l’accès Internet 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 obtenir des informations plus détaillées sur les conditions et les types de déclencheurs en arrière-plan, consultez Prise en charge de votre application avec des tâches en arrière-plan.

Appeler 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
}

Inscrire la tâche en arrière-plan

Inscrivez la tâche en arrière-plan en appelant la fonction qui vous permet de le faire. 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 plutôt d’utiliser l’exécution étendue . Le déclencheur d’application est conçu pour créer un processus hébergé séparément dans lequel travailler. L’extrait de code suivant inscrit 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 de la tâche en arrière-plan sont validés au moment de l’inscription. Si l’un des paramètres d’inscription n’est pas valide, une erreur est renvoyée. Vérifiez que votre application gère de manière fluide les scénarios dans lesquels l’inscription de la tâche en arrière-plan échoue. En revanche, si votre application dépend d’un objet d’inscription valide après la tentative d’inscription d’une tâche, elle 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. Le 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. N’importe quel instance ApplicationTrigger le fera.

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 à l’état d’exécution en arrière-plan (pour plus d’informations sur l’état de l’application, consultez Cycle de vie de l’application). Il peut renvoyer DisabledByPolicy si l’utilisateur a défini des stratégies d’énergie ou de confidentialité qui empêchent l’application d’effectuer une activité 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 Actuellementrunning.

var result = await _AppTrigger.RequestAsync();

Gérer les ressources pour votre tâche en arrière-plan

Utilisez la méthode BackgroundExecutionManager.RequestAccessAsync pour déterminer si l’utilisateur a opté pour une activité limitée de votre application en arrière-plan. Tenez compte du taux d’utilisation de la batterie ; exécutez l’application en arrière-plan uniquement lorsqu’elle est nécessaire dans le cadre d’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 la consommation d’énergie de votre application est essentiel pour garantir que le système d’exploitation permettra à votre tâche en arrière-plan de s’exécuter. Utilisez les API gestion de la mémoire pour voir la quantité de mémoire utilisée par votre tâche en arrière-plan. Plus votre tâche en arrière-plan utilise de mémoire, plus il est difficile pour le système d’exploitation de la maintenir en cours d’exécution lorsqu’une autre application est au premier plan. L’utilisateur dispose d’un contrôle étroit sur l’ensemble des activités en arrière-plan que votre application peut exécuter, et bénéficie d’une visibilité étendue sur l’impact de cette dernière sur le taux d’utilisation de la batterie.
  • Temps processeur : les tâches en arrière-plan sont limitées par le 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.

Pour plus d’informations sur les contraintes de ressource appliquées aux tâches en arrière-plan, consultez Prendre en charge votre application avec des 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 ne s’exécute à l’aide d’un ApplicationTrigger que si vous avez d’abord appelé RequestAccessAsync .