Schnellstart: Erstellen und Registrieren einer Hintergrundaufgabe (HTML)

Artikel
12/12/2015

[ Dieser Artikel richtet sich an Windows 8.x- und Windows Phone 8.x-Entwickler, die Windows-Runtime-Apps schreiben. Wenn Sie für Windows 10 entwickeln, finden Sie weitere Informationen unter neueste Dokumentation]

In diesem Thema wird das Erstellen und Registrieren von Hintergrundaufgaben-Workern für Apps beschrieben.

Voraussetzungen

Sie benötigen eine App, für die Sie eine Hintergrundaufgabe bereitstellen möchten.

Erstellen der Hintergrundaufgabenklasse

Erstellen Sie mit dem Code, der im Hintergrund ausgeführt wird, eine eigene Methode. Dieser Code wird ausgeführt, wenn ein bestimmtes Ereignis ausgelöst wird. In den Themen SystemTrigger und MaintenanceTrigger finden Sie eine Liste mit Triggertypen, die von allen Apps verwendet werden können.

Die folgenden Schritte zeigen, wie Sie einen Hintergrundaufgaben-Worker erstellen, der Windows.UI.WebUI.WebUIBackgroundTaskInstance verwendet. Zunächst müssen Sie eine neue leere JavaScript-Datei in Microsoft Visual Studio erstellen.

Erstellen Sie eine neue JavaScript-Datei in Ihrem Projekt. Die Funktionen und der Code in dieser Datei stellen die Aufgabe dar, die im Hintergrund ausgeführt wird.

Das folgende Codegerüst kann Ihnen den Einstieg erleichtern:


//
// A JavaScript background task is specified in a .js file. The name of the file is used to
// launch the background task.
//
(function () {
    "use strict";

    //
    // This var is used to get information about the current instance of the background task.
    //
    var backgroundTaskInstance = Windows.UI.WebUI.WebUIBackgroundTaskInstance.current;


    //
    // This function will do the work of your background task.
    //
    function doWork() {
        var key = null,
            settings = Windows.Storage.ApplicationData.current.localSettings;

        // Write JavaScript code here to do work in the background.


        //
        // Record information in LocalSettings to communicate with the app.
        //
        key = backgroundTaskInstance.task.taskId.toString();
        settings.values[key] = "Succeeded";

        //
        // A JavaScript background task must call close when it is done.
        //
        close();
    }

    doWork();

})();

Eine Hintergrundaufgabe sollte es erkennen, wenn sie den Befehl erhält, die Arbeit einzustellen. Fügen Sie dem Ereignis „canceled“ zunächst einen Ereignislistener hinzu, und fügen Sie dann eine Variable mit dem Namen „canceled“ hinzu, um der Hintergrundaufgabe ein Signal zu geben.

Im Beispiel für eine Hintergrundaufgabe wartet die Hintergrundaufgabe auf das Ereignis „canceled“ mit den „onCanceled“-Funktionen:

    var cancel = false;

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

Ändern Sie anschließend Ihren Code so, dass die Arbeit beendet und die Hintergrundaufgabe geschlossen wird, wenn „canceled“ auf „true“ gesetzt wird.

Im Beispiel für eine Hintergrundaufgabe wird eine Aufgabe namens „SampleBackgroundTask“ erstellt:


//
// A JavaScript background task is specified in a .js file. The name of the file is used to
// launch the background task.
//
(function () {
    "use strict";

    //
    // This var is used to get information about the current instance of the background task.
    //
    var backgroundTaskInstance = Windows.UI.WebUI.WebUIBackgroundTaskInstance.current;


    //
    // This function will do the work of your background task.
    //
    function doWork() {
        var key = null,
            settings = Windows.Storage.ApplicationData.current.localSettings;

        //
        // TODO: Write your JavaScript code here to do work in the background.
        // If you write a loop or callback, remember  have it check for canceled==false.
        //

        //
        // Record information in LocalSettings to communicate with the app.
        //
        key = backgroundTaskInstance.task.taskId.toString();
        settings.values[key] = "Succeeded";

        //
        // A JavaScript background task must call close when it is done.
        //
        close();
    }

    if (!canceled) {
        doWork();
    } else {
        //
        // Record information in LocalSettings to communicate with the app.
        //
        key = backgroundTaskInstance.task.taskId.toString();
        settings.values[key] = "Canceled";

        //
        // A JavaScript background task must call close when it is done.
        //
        close();
    }

})();

Stellen Sie sicher, dass Ihre Hintergrundaufgabe die integrierte close()-Methode jedes Mal aufruft, wenn sie ihre Arbeit abgeschlossen hat oder abgebrochen wird. Wenn die Hintergrundaufgabe nicht von selbst geschlossen wird, kann der Prozess der Hintergrundaufgabe weiterlaufen, wodurch Speicher- und Energieressourcen verbraucht werden, auch wenn die Hintergrundaufgabe abgeschlossen wurde.

Rufen Sie immer „close()“ auf, wenn eine JavaScript-Hintergrundaufgabe ihre Arbeit abgeschlossen hat oder abgebrochen wird:
```
close();
```

Bei den folgenden Schritten wird Ihrer bestehenden App (zum Beispiel "default.js") Code hinzugefügt.

Hinweis Sie können auch eine Funktion erstellen, die sich nur um das Registrieren von Hintergrundaufgaben kümmert. Weitere Informationen finden Sie in Registrieren einer Hintergrundaufgabe. In einem solchen Fall können Sie die nächsten drei Schritte überspringen, einfach den Auslöser konstruieren und der Registrierungsfunktion zur Verfügung stellen, zusammen mit dem Aufgabennamen, dem entsprechenden Einstiegspunkt und, optional, einer Bedingung.

Registrieren der Hintergrundaufgabe

Finden Sie heraus, ob die Hintergrundaufgabe bereits registriert ist, indem Sie die BackgroundTaskRegistration.allTasks-Eigenschaft durchlaufen lassen. Dieser Schritt ist sehr wichtig. Sollte Ihre App nicht überprüfen, ob Hintergrundaufgaberegistrierungen vorhanden sind, könnte es passieren, dass sie die Aufgabe mehrere Male registriert, was zu Leistungseinbrüchen führt und die verfügbare CPU-Zeit der Aufgabe maximiert, bevor die Arbeit abgeschlossen werden kann.

Das folgende Beispiel wiederholt die allTasks-Eigenschaft und legt eine Kennzeichenvariable auf "true" fest, wenn die Aufgabe bereits registriert ist:
```
var taskRegistered = false;
var exampleTaskName = "Example background task worker name";

var background = Windows.ApplicationModel.Background;
var iter = background.BackgroundTaskRegistration.allTasks.first();

while (iter.hasCurrent) {

    var task = iter.current.value;

    if (task.name === exampleTaskName) {

        taskRegistered = true;
        break;
    }

    iter.moveNext();
}
```

Wenn sie noch nicht registriert ist, registrieren Sie die Hintergrundaufgabe, indem Sie die register-Funktion aufrufen und damit den Dateinamen der Hintergrundaufgabe und einen SystemTrigger bereitstellen.

Der Hintergrundaufgabenauslöser bestimmt, ob die Hintergrundaufgabe ausgeführt wird. Siehe SystemTrigger für eine Liste möglicher Systemauslöser.


if (taskRegistered != true) {

    var builder = new Windows.ApplicationModel.Background.BackgroundTaskBuilder();

    var trigger = new Windows.ApplicationModel.Background.SystemTrigger(Windows.ApplicationModel.Background.SystemTriggerType.timeZoneChange, false);

    builder.name = exampleTaskName;
    builder.taskEntryPoint = "js\\ExampleBackgroundTask.js";
    builder.setTrigger(trigger);

    var task = builder.register();
}

Sie können eine Bedingung hinzufügen, die bestimmt, wann Ihre Aufgabe ausgeführt wird, nachdem das Auslöseereignis auftritt (optional). Wenn Sie zum Beispiel möchten, dass die Aufgabe erst ausgeführt wird, wenn der Benutzer anwesend ist, verwenden Sie die Bedingung UserPresent. Eine Liste mit möglichen Bedingungen finden Sie unter SystemConditionType.

Hinweis

Ab Windows 8.1 werden Parameter für die Registrierung von Hintergrundaufgaben zum Zeitpunkt der Registrierung überprüft. Bei ungültigen Registrierungsparametern wird ein Fehler zurückgegeben. Ihre App muss Szenarios, in denen die Registrierung von Hintergrundaufgaben fehlschlägt, problemlos verarbeiten können. Verwenden Sie beispielsweise eine Bedingungsanweisung, um die App auf Registrierungsfehler zu prüfen, und führen Sie die fehlgeschlagene Registrierung mit anderen Parameterwerten erneut durch.
```
if (taskRegistered != true) {

    var builder = new Windows.ApplicationModel.Background.BackgroundTaskBuilder();

    var trigger = new Windows.ApplicationModel.Background.SystemTrigger(Windows.ApplicationModel.Background.SystemTriggerType.timeZoneChange, false);

    builder.name = exampleTaskName;
    builder.taskEntryPoint = "js\\ExampleBackgroundTask.js";
    builder.setTrigger(trigger);

    builder.addCondition(new Windows.ApplicationModel.Background.SystemCondition(Windows.ApplicationModel.Background.SystemConditionType.userPresent));

    var task = builder.register();
}
```
Hinweis

Für Windows Phone Store-Apps müssen Sie RequestAccessAsync aufrufen, bevor Sie versuchen, Hintergrundaufgaben zu registrieren. Unter Windows ist dieser Aufruf nur für die Hintergrundaufgaben erforderlich, die nur ausgeführt werden können, wenn sich Ihre App auf dem Sperrbildschirm befindet. Auf dem Telefon müssen Sie diese Methode vor dem Registrieren einer Hintergrundaufgabe einmal aufrufen.

Um sicherzustellen, dass Ihre Windows Phone-App nach dem Freigeben eines Updates weiterhin ordnungsgemäß ausgeführt wird, rufen Sie RemoveAccess und RequestAccessAsync auf, wenn Ihre App nach dem Aktualisieren startet. Weitere Infos finden Sie unter Richtlinien für Hintergrundaufgaben (HTML).

Behandeln der Beendigung von Hintergrundaufgaben

Ihre App kann Fortschritt und Beendigung der Hintergrundaufgabe überwachen, indem sie den Listener für das "completed"-Ereignis jedes Mal registriert, wenn die App aktiviert wird.

Schreiben Sie eine Funktion, mit der Ihre App die Beendigung des Hintergrundaufgaben-Workers ermitteln kann.

Das Beispiel für eine Hintergrundaufgabe fügt hierzu die onCompleted-Funktion hinzu:


//
// Handle background task completion.
//
"completeHandler": function (task) {
    this.onCompleted = function (args) {
        try {
            var key = task.taskId;
            var settings = Windows.Storage.ApplicationData.current.localSettings;
            var status = settings.values[key];

            switch (task.name) {
                case BackgroundTaskSample.sampleBackgroundTaskName:
                    BackgroundTaskSample.sampleBackgroundTaskStatus = status;
                    SampleBackgroundTask.updateUI();
                    break;
                case BackgroundTaskSample.sampleBackgroundTaskWithConditionName:
                    BackgroundTaskSample.sampleBackgroundTaskWithConditionStatus = status;
                    SampleBackgroundTaskWithCondition.updateUI();
                    break;
                case BackgroundTaskSample.servicingCompleteTaskName:
                    BackgroundTaskSample.servicingCompleteTaskStatus = status;
                    ServicingComplete.updateUI();
                    break;
                case BackgroundTaskSample.javaScriptBackgroundTaskName:
                    BackgroundTaskSample.javaScriptBackgroundTaskStatus = status;
                    JavaScriptBackgroundTask.updateUI();
                    break;
                case BackgroundTaskSample.timeTriggerTaskName:
                    BackgroundTaskSample.timeTriggerTaskStatus = status;
                    TimeTriggerBackgroundTask.updateUI();
                    break;
            }
        } catch (ex) {
            //WinJS.log && WinJS.log(ex, "sample", "status");
        }
    };
}

Registrieren Sie Ihre App mit der Funktion für den Listener des "completed"-Ereignisses.

Das Beispiel für eine Hintergrundaufgabe fügt onCompleted dem "completed"-Ereignis hinzu:
```
task.addEventListener("completed", new BackgroundTaskSample.completeHandler(task).onCompleted);
```

Deklarieren im App-Manifest, dass die App Hintergrundaufgaben verwendet

Bevor Ihre App Hintergrundaufgaben registrieren kann, müssen Sie alle Hintergrundaufgaben (mit den verwendeten Triggern) im App-Manifest deklarieren.

Öffnen Sie das App-Manifest, und wechseln Sie zum Erweiterungselement. Fügen Sie ein Erweiterungselement hinzu, wobei die Kategorie für jede in der App verwendete Hintergrundaufgabenklasse auf "windows.backgroundTasks" festgelegt ist. Sie müssen jeden Auslösertyp aufführen, den die Hintergrundaufgabe verwendet. Ihre App kann die Hintergrundaufgabe ohne deklarierten Auslösertyp nicht registrieren.

Im Beispiel für eine Hintergrundaufgabe werden drei Hintergrundaufgaben-Worker registriert:


<Extension Category="windows.backgroundTasks" StartPage="js\backgroundtask.js">
  <BackgroundTasks>
    <Task Type="systemEvent" />
  </BackgroundTasks>
</Extension>
<Extension Category="windows.backgroundTasks" EntryPoint="Tasks.SampleBackgroundTask">
  <BackgroundTasks>
    <Task Type="systemEvent" />
    <Task Type="timer" />
  </BackgroundTasks>
</Extension>
<Extension Category="windows.backgroundTasks" EntryPoint="Tasks.ServicingComplete">
  <BackgroundTasks>
    <Task Type="systemEvent" />
  </BackgroundTasks>
</Extension>

Zusammenfassung

Sie sollten jetzt über die Grundlagen verfügen, um eine Hintergrundaufgabenklasse zu schreiben, die Hintergrundaufgabe in Ihrer App zu registrieren und Ihre App so zu konfigurieren, dass Sie den Abschluss der Hintergrundaufgabe erkennt. Sie sollten auch mit der Aktualisierung des Anwendungsmanifests vertraut sein, damit Ihre App unter dem jeweiligen Betriebssystem Hintergrundaufgaben registrieren kann.

Hinweis Sie können das Beispiel für eine Hintergrundaufgabe herunterladen, um sich diese (und noch weitere) Codebeispiele im Kontext einer funktionierenden JavaScript-App anzusehen, die Hintergrundaufgaben verwendet.