Comment surveiller la progression et l’achèvement des tâches en arrière-plan (HTML)

Article
12/11/2015

[ Cet article est destiné aux développeurs de Windows 8.x et Windows Phone 8.x qui créent des applications Windows Runtime. Si vous développez une application pour Windows 10, voir la Documentation ]

Découvrez comment votre application peut reconnaître la progression et l’achèvement signalés par une tâche en arrière-plan. Les tâches en arrière-plan sont découplées de l’application et sont exécutées séparément. Toutefois, la progression et l’achèvement des tâches en arrière-plan peuvent être surveillés par le code de l’application. Pour ce faire, l’application s’abonne aux événements des tâches en arrière-plan qu’elle a inscrites auprès du système.

Ce que vous devez savoir

Technologies

Windows.ApplicationModel.Background

Prérequis

Cette rubrique suppose que vous disposez d’une application qui inscrit les tâches en arrière-plan. Pour vous lancer rapidement dans la génération d’une tâche en arrière-plan, voir Démarrage rapide : créer et inscrire une tâche en arrière-plan. Pour des informations plus détaillées sur les conditions et les déclencheurs, voir Définition de tâches en arrière-plan pour les besoins de votre application.

Instructions

Étape 1:

Créez une fonction qui sera annexée au gestionnaire d’événements pour l’exécution à terme de la tâche en arrière-plan. Cette fonction doit adopter un objet BackgroundTaskCompletedEventArgs et aucun autre paramètre.

Si vous inscrivez localement une fonction, vous pouvez vous servir de l’empreinte suivante :
```
function OnCompleted(args)
{
    // TODO: Add code that deals with background task completion.
}
```
Vous pouvez ensuite l’inscrire en l’état avec votre objet BackgroundTaskRegistration (obtenu par un appel à terme de la fonction Register) :
```
backgroundTaskRegistration.addEventListener("completed", onCompleted);
```
Vous devrez ajouter votre code chargé de mener la tâche en arrière-plan à terme.

Ainsi, l’exemple de tâche en arrière-plan met à jour l’interface utilisateur conformément à l’état d’achèvement enregistré dans LocalSettings :
```
function OnCompleted(args)
{
    // 
    // 
    // 
    backgroundTaskName = this.name;

    // 
    // Call a method to update the UI (beyond the scope of this example).
    // 
    UpdateUI();
}
```

Une application robuste peut rechercher la présence d’exceptions levées par la tâche en arrière-plan en appelant CheckResult.

La méthode de l’exemple de tâche en arrière-plan peut être modifiée de la façon suivante pour gérer les exceptions levées par la tâche en arrière-plan :

function OnCompleted(task, args)
{
    var settings = ApplicationData.Current.LocalSettings;
    var key = task.TaskId.ToString();

    try
    {
        args.CheckResult();
        BackgroundTaskSample.SampleBackgroundTaskStatus = settings.Values[key].ToString();
    }
    catch (Exception ex)
    {
        BackgroundTaskSample.SampleBackgroundTaskStatus = "Error: " + ex.Message;
    }

    UpdateUI();
}

Étape 2:

Créez une fonction de gestionnaire des événements pour gérer les tâches en arrière-plan achevées. Ce code doit suivre une empreinte spécifique, qui accepte un objet IBackgroundTaskRegistration et un objet BackgroundTaskProgressEventArgs.

Utilisez l’empreinte suivante pour la méthode de gestionnaire des événements de tâche en arrière-plan OnProgress :
```
function OnProgress(task, args)
{
    // TODO: Add code that deals with background task progress.
}
```
Ajoutez du code au gestionnaire des événements qui traite l’achèvement des tâches en arrière-plan.

Ainsi, l’exemple de tâche en arrière-plan met à jour l’interface utilisateur conformément à l’état de progression transmis via le paramètre args :
```
function OnProgress(task, args)
{
    var progress = "Progress: " + args.Progress + "%";
    BackgroundTaskSample.SampleBackgroundTaskProgress = progress;
    UpdateUI();
}
```

Étape 3:

Inscrivez les fonctions de gestionnaire des événements auprès des tâches en arrière-plan nouvelles et existantes.

Lorsque l’application inscrit une tâche en arrière-plan pour la première fois, elle doit s’inscrire pour recevoir les mises à jour de progression et d’achèvement de la tâche au cas où celle-ci s’exécuterait pendant que l’application est toujours active au premier plan.

Ainsi, l’exemple de tâche en arrière-plan appelle la fonction suivante pour chaque tâche en arrière-plan qu’il inscrit :
```
function AttachProgressAndCompletedHandlers(IBackgroundTaskRegistration task)
{
    task.Progress += new BackgroundTaskProgressEventHandler(OnProgress);
    task.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted);
}
```
Lorsque l’application se lance ou accède à une nouvelle page dans laquelle l’état des tâches en arrière-plan est important, elle doit obtenir la liste des tâches en arrière-plan actuellement inscrites et les associer aux fonctions de gestionnaire des événements de progression et d’achèvement. La liste des tâches en arrière-plan actuellement inscrites par l’application est conservée dans la propriété BackgroundTaskRegistration.AllTasks.

Ainsi, l’exemple de tâche en arrière-plan utilise le code suivant pour joindre les gestionnaires d’événements lorsque vous accédez à la page SampleBackgroundTask :
```
function OnNavigatedTo(NavigationEventArgs e)
{
    foreach (var task in BackgroundTaskRegistration.AllTasks)
    {
        if (task.Value.Name == BackgroundTaskSample.SampleBackgroundTaskName)
        {
            AttachProgressAndCompletedHandlers(task.Value);
            BackgroundTaskSample.UpdateBackgroundTaskStatus(BackgroundTaskSample.SampleBackgroundTaskName, true);
        }
    }

    UpdateUI();
}
```