Comment gérer une tâche en arrière-plan annulée (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 faire en sorte qu’une tâche en arrière-plan reconnaisse les demandes d’annulation et arrête le travail, tout en signalant l’annulation à l’application qui utilise l’instance de tâche en arrière-plan et le dispositif de stockage persistant.

Remarque Pour les applications Windows Phone Store, si l’appareil commence à manquer de mémoire, les tâches en arrière-plan peuvent être arrêtées sans avertissement et sans que l’événement OnCanceled ne soit déclenché. Cela permet de garantir l’expérience utilisateur de l’application au premier plan. Votre tâche en arrière-plan doit être conçue de manière à gérer ce scénario.

Ce que vous devez savoir

Technologies

Prérequis

Cette rubrique part du principe que vous avez déjà créé une tâche en arrière-plan JavaScript. 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: Utiliser un gestionnaire d’événements pour reconnaître les demandes d’annulation

Écrivez une méthode permettant de gérer l’événement d’annulation.

Créez une méthode nommée OnCanceled qui possède l’empreinte suivante. Cette méthode est le point d’entrée appelé par Windows Runtime chaque fois qu’une demande d’annulation est formulée pour votre tâche en arrière-plan.

La fonction OnCanceled doit avoir l’empreinte suivante :
```
function onCanceled(cancelSender, cancelReason)
{
    // TODO: Add code to notify the background task that it is cancelled.
}
```
Ajoutez une variable appelée cancel à la tâche en arrière-plan. Cette variable servira à indiquer lorsqu’une demande d’annulation a été reçue.

Par exemple, placez cette ligne de code au-dessus de votre classe IBackgroundTask avec les autres définitions de variable :
```
var cancel = false;
```
Dans la méthode OnCanceled que vous avez créée à l’étape 1, définissez cancel sur true.

La méthode OnCanceled de l’exemple de tâche en arrière-plan complet définit cancel sur true :
```
function onCanceled(cancelSender, cancelReason) {
    cancel = true;
}
```
Inscrivez la méthode OnCanceled avec l’écouteur d’événements « canceled » avant de commencer à travailler dans la tâche en arrière-plan.

Par exemple, utilisez la ligne de code suivante :
```
backgroundTaskInstance.addEventListener("canceled", onCanceled);
```

Étape 2: Gérer l’annulation et quitter

La méthode Run a besoin de surveiller la variable cancel pour pouvoir quitter lorsque la variable est définie sur true.

Modifiez le code de votre classe de tâche en arrière-plan pour arrêter tout travail si cancel a la valeur True.

L’exemple de tâche en arrière-plan comprend une vérification qui arrête le rappel de minuteur périodique en cas d’annulation de la tâche en arrière-plan :
```
if (!cancel) {
    // Do work.
}
else
{
    // Cancel.
}
```

Une fois le travail terminé, nettoyez en définissant la propriété succeeded de l’instance de tâche de travail sur False et confirmez que la tâche a été annulée en l’enregistrant. Appelez ensuite close() pour quitter la fonction.

L’exemple de tâche en arrière-plan enregistre l’état dans LocalSettings :


if ((_cancelRequested == false) && (_progress < 100))
{
    // See the background task sample for this code.
}
else
{
    //
    // If the cancellation handler indicated that the task was canceled, stop the background task.
    //
    console.log("Background " + backgroundTaskInstance.task.name + " Canceled");
    backgroundTaskInstance.succeeded = false;

    key = backgroundTaskInstance.task.taskId.toString();
    settings.values[key] = "Canceled";

    close();
}

Remarques

Vous pouvez télécharger l’exemple de tâche en arrière-plan pour voir ces exemples de code dans le contexte des méthodes.

À des fins d’illustration, l’exemple de code présente uniquement des portions de la méthode Run (et du minuteur de rappel) extraites de l’exemple de tâche en arrière-plan.

Exemple de méthode Run

La tâche en arrière-plan JavaScript de l’exemple de tâche en arrière-plan est présentée ci-dessous en intégralité à des fins contextuelles :

//
// A JavaScript background task runs a specified JavaScript file.
//
(function () {
    "use strict";

    //
    // The background task instance's activation parameters are available via Windows.UI.WebUI.WebUIBackgroundTaskInstance.current
    //
    var cancel = false,
        progress = 0,
        backgroundTaskInstance = Windows.UI.WebUI.WebUIBackgroundTaskInstance.current;

    console.log("Background " + backgroundTaskInstance.task.name + " Starting...");

    //
    // Associate a cancellation handler with the background task.
    //
    function onCanceled(cancelSender, cancelReason) {
        cancel = true;
    }
    backgroundTaskInstance.addEventListener("canceled", onCanceled);

    //
    // This function is set to run every 1000 milliseconds ten times and perform background task activity.
    //
    function onTimer() {
        var key = null,
            settings = Windows.Storage.ApplicationData.current.localSettings;

        if (!cancel) {
            if (progress < 100) {
                //
                // Simulate work being done.
                //
                setTimeout(onTimer, 1000);

                //
                // Indicate progress to the foreground application.
                //
                backgroundTaskInstance.progress = progress;
                progress += 10;
            } else {
                //
                // Use the succeeded property to indicate that this background task completed successfully.
                //
                backgroundTaskInstance.succeeded = true;
                backgroundTaskInstance.progress = progress;
                console.log("Background " + backgroundTaskInstance.task.name + " Completed");

                //
                // Write to localSettings to indicate that this background task completed.
                //
                key = backgroundTaskInstance.task.name;
                settings.values[key] = "Completed";

                //
                // A JavaScript background task must call close when it is done.
                //
                close();
            }
        } else {
            //
            // If the cancellation handler indicated that the task was canceled, stop the background task.
            //
            console.log("Background " + backgroundTaskInstance.task.name + " Canceled");
            backgroundTaskInstance.succeeded = false;

            key = backgroundTaskInstance.task.taskId.toString();
            settings.values[key] = "Canceled";

            close();
        }
    }

    //
    // Start the timer function to simulate background task work.
    //
    setTimeout(onTimer, 1000);
})();