Freigeben über

Vom Assistenten für Pushbenachrichtigungen generierter Code

  • Artikel

Mithilfe eines Assistenten in Visual Studio können Sie Pushbenachrichtigungen über einen mobilen Dienst generieren, der unter Verwendung von Azure Mobile Services erstellt wurde. Mit dem Visual Studio-Assistenten wird Code als Starthilfe generiert. In diesem Thema wird erläutert, wie der Assistent Ihr Projekt modifiziert, welche Schritte mit dem generierten Code ausgeführt werden, wie der Code verwendet wird und was Sie als Nächstes tun können, um Pushbenachrichtigungen optimal einzusetzen. Weitere Informationen finden Sie unter Übersicht über die Windows-Pushbenachrichtigungsdienste (Windows Push Notification Services, WNS).

Wie der Assistent Ihr Projekt ändert

Der Assistent für Pushbenachrichtigungen ändert Ihr Projekt wie folgt:

  • Fügt einen Verweis auf den verwalteten Client für mobile Dienste (MobileServicesManagedClient.dll) hinzu. Gilt nicht für JavaScript-Projekte.
  • Fügt eine Datei in einem Unterordner unter "Dienste" hinzu und benennt die Datei push.register.cs, push.register.vb, push.register.cpp oder push.register.js.
  • Erstellt eine Kanaltabelle auf dem Datenbankserver für den mobilen Dienst. Die Tabelle enthält Informationen, die zum Senden von Pushbenachrichtigungen an App-Instanzen erforderlich sind.
  • Erstellt Skripts für vier Funktionen: Löschen, Einfügen, Lesen und Aktualisieren.
  • Erstellt ein Skript mit einer benutzerdefinierten API, notifyallusers.js, die eine Pushbenachrichtigung an alle Clients sendet.
  • Fügt ihrer App.xaml.cs, App.xaml.vb oder App.xaml.cpp Datei eine Deklaration hinzu, oder fügt eine Deklaration zu einer neuen Datei, service.js, für JavaScript-Projekte hinzu. Die Deklaration deklariert ein MobileServiceClient -Objekt, das die Informationen enthält, die zum Herstellen einer Verbindung mit dem mobilen Dienst erforderlich sind. Sie können auf dieses MobileServiceClient-Objekt, das "MyServiceNameClient" heißt, über eine beliebige Seite in Ihrer App mithilfe des Namens "App" zugreifen.MyServiceName-Client.

Die datei services.js enthält den folgenden Code:

var <mobile-service-name>Client = new Microsoft.WindowsAzure.MobileServices.MobileServiceClient(
                "https://<mobile-service-name>.azure-mobile.net/",
                "<your client secret>");

Registrierung für Pushbenachrichtigungen

In push.register.*registriert die UploadChannel-Methode das Gerät für den Empfang von Pushbenachrichtigungen. Der Store verfolgt installierte Instanzen Ihrer App und stellt den Pushbenachrichtigungskanal bereit. Siehe PushNotificationChannelManager.

Der Clientcode ist sowohl für das JavaScript-Back-End als auch für das .NET-Back-End ähnlich. Wenn Sie Pushbenachrichtigungen für einen JavaScript-Back-End-Dienst hinzufügen, wird standardmäßig ein Beispielaufruf zur benutzerdefinierten API notifyAllUsers in die UploadChannel-Methode eingefügt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;

namespace App2
{
    internal class mymobileservice1234Push
    {
        public async static void UploadChannel()
        {
            var channel = await Windows.Networking.PushNotifications.PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

            try
            {
                await App.mymobileservice1234Client.GetPush().RegisterNativeAsync(channel.Uri);
                await App.mymobileservice1234Client.InvokeApiAsync("notifyAllUsers");
            }
            catch (Exception exception)
            {
                HandleRegisterException(exception);
            }
        }

        private static void HandleRegisterException(Exception exception)
        {
            
        }
    }
}

Imports Microsoft.WindowsAzure.MobileServices
Imports Newtonsoft.Json.Linq

Friend Class mymobileservice1234Push
    Public Shared Async Sub UploadChannel()
        Dim channel = Await Windows.Networking.PushNotifications.PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync()

        Try
            Await App.mymobileservice1234Client.GetPush().RegisterNativeAsync(channel.Uri)
            Await App.mymobileservice1234Client.GetPush().RegisterNativeAsync(channel.Uri, New String() {"tag1", "tag2"})
            Await App.mymobileservice1234Client.InvokeApiAsync("notifyAllUsers")
        Catch exception As Exception
            HandleRegisterException(exception)
        End Try
    End Sub

    Private Shared Sub HandleRegisterException(exception As Exception)

    End Sub
End Class

#include "pch.h"
#include "services\mobile services\mymobileservice1234\mymobileservice1234Push.h"

using namespace AzureMobileHelper;

using namespace web;
using namespace concurrency;

using namespace Windows::Networking::PushNotifications;

void mymobileservice1234Push::UploadChannel()
{
    create_task(PushNotificationChannelManager::CreatePushNotificationChannelForApplicationAsync()).
    then([] (PushNotificationChannel^ newChannel) 
    {
        return mymobileservice1234MobileService::GetClient().get_push().register_native(newChannel->Uri->Data());
    }).then([]()
    {
        return mymobileservice1234MobileService::GetClient().invoke_api(L"notifyAllUsers");
    }).then([](task<json::value> result)
    {
        try
        {
            result.wait();
        }
        catch(...)
        {
            HandleExceptionsComingFromTheServer();
        }
    });
}

void mymobileservice1234Push::HandleExceptionsComingFromTheServer()
{
}

(function () {
    "use strict";

    var app = WinJS.Application;
    var activation = Windows.ApplicationModel.Activation;

    app.addEventListener("activated", function (args) {
        if (args.detail.kind == activation.ActivationKind.launch) {
            Windows.Networking.PushNotifications.PushNotificationChannelManager.createPushNotificationChannelForApplicationAsync()
                .then(function (channel) {
                    mymobileserviceclient1234Client.push.registerNative(channel.Uri, new Array("tag1", "tag2"))
                    return mymobileservice1234Client.push.registerNative(channel.uri);
                })
                .done(function (registration) {
                    return mymobileservice1234Client.invokeApi("notifyAllUsers");
                }, function (error) {
                    // Error

                });
        }
    });
})();

Pushbenachrichtigungstags bieten eine Möglichkeit, Benachrichtigungen auf eine Teilmenge von Clients einzuschränken. Sie können die RegisterNative-Methode (oder RegisterNativeAsync)-Methode verwenden, um entweder für alle Pushbenachrichtigungen zu registrieren, ohne Tags anzugeben, oder Sie können sich mit Tags registrieren, indem Sie das zweite Argument, ein Array von Tags, angeben. Wenn Sie sich mit einem oder mehreren Tags registrieren, erhalten Sie nur Benachrichtigungen, die diesen Tags entsprechen.

Serverseitige Skripts (nur JavaScript-Back-End)

Bei mobilen Diensten, die das JavaScript-Back-End verwenden, werden die serverseitigen Skripts beim Löschen, Einfügen, Lesen oder Aktualisieren ausgeführt. Die Skripts implementieren diese Vorgänge nicht, aber sie werden ausgeführt, wenn ein Aufruf vom Client an die Windows Mobile-REST-API diese Ereignisse auslöst. Die Skripts übergeben dann die Steuerung an die Vorgänge selbst, indem sie "request.execute" oder "request.respond" aufrufen, um eine Antwort auf den aufrufenden Kontext auszugeben. Weitere Informationen finden Sie in der REST-API-Referenz zu Azure Mobile Services.

Eine Vielzahl von Funktionen ist im serverseitigen Skript verfügbar. Siehe Registrieren von Tabellenvorgängen in Azure Mobile Services. Einen Verweis auf alle verfügbaren Funktionen finden Sie unter Mobile Services-Serverskriptreferenz.

Der folgende benutzerdefinierte API-Code in Notifyallusers.js wird ebenfalls erstellt:

exports.post = function(request, response) {
    response.send(statusCodes.OK,{ message : 'Hello World!' })
    
    // The following call is for illustration purpose only
    // The call and function body should be moved to a script in your app
    // where you want to send a notification
    sendNotifications(request);
};

// The following code should be moved to appropriate script in your app where notification is sent
function sendNotifications(request) {
    var payload = '<?xml version="1.0" encoding="utf-8"?><toast><visual><binding template="ToastText01">' +
        '<text id="1">Sample Toast</text></binding></visual></toast>';
    var push = request.service.push; 
    push.wns.send(null,
        payload,
        'wns/toast', {
            success: function (pushResponse) {
                console.log("Sent push:", pushResponse);
            }
        });
}

Die SendNotifications-Funktion sendet eine einzelne Benachrichtigung als Popupbenachrichtigung. Sie können auch andere Arten von Pushbenachrichtigungen verwenden.

Tipp : Informationen zum Abrufen von Hilfe beim Bearbeiten von Skripts finden Sie unter Aktivieren von IntelliSense für serverseitiges JavaScript.

 

Pushbenachrichtigungstypen

Windows unterstützt Benachrichtigungen, die keine Pushbenachrichtigungen sind. Allgemeine Informationen zu Benachrichtigungen finden Sie unter Auswählen einer Methode zur Zustellung von Benachrichtigungen.

Popupbenachrichtigungen sind einfach zu verwenden, und Sie können ein Beispiel im Insert.js Code in der Tabelle des Kanals überprüfen, die für Sie generiert wird. Wenn Sie Kachel- oder Signalbenachrichtigungen verwenden möchten, müssen Sie eine XML-Vorlage für die Kachel und das Signal erstellen und die Codierung von verpackten Informationen in der Vorlage angeben. Siehe Arbeiten mit Kacheln, Signalen und Popupbenachrichtigungen.

Da Windows auf Pushbenachrichtigungen reagiert, kann er die meisten dieser Benachrichtigungen verarbeiten, wenn die App nicht ausgeführt wird. Beispielsweise könnte eine Pushbenachrichtigung dem Benutzer mitteilen, wann eine neue E-Mail-Nachricht verfügbar ist, auch wenn die lokale Mail-App nicht ausgeführt wird. Windows behandelt eine Popupbenachrichtigung, indem eine Nachricht angezeigt wird, z. B. die erste Zeile einer Sms. Windows behandelt eine Kachel- oder Signalbenachrichtigung, indem die Live-Kachel einer App aktualisiert wird, um die Anzahl neuer E-Mail-Nachrichten widerzuspiegeln. Auf diese Weise können Sie Benutzer Ihrer App auffordern, sie auf neue Informationen zu überprüfen. Ihre App kann unformatierte Benachrichtigungen empfangen, wenn sie ausgeführt wird, und Sie können sie verwenden, um Daten an Ihre App zu senden. Wenn Ihre App nicht ausgeführt wird, können Sie eine Hintergrundaufgabe einrichten, um Pushbenachrichtigungen zu überwachen.

Sie sollten Pushbenachrichtigungen gemäß den Richtlinien für Windows-Apps verwenden, da diese Benachrichtigungen die Ressourcen eines Benutzers verwenden und bei überlasteten Benachrichtigungen ablenken können. Siehe Richtlinien und Prüfliste für Pushbenachrichtigungen.

Wenn Sie Live-Kacheln mit Pushbenachrichtigungen aktualisieren, sollten Sie auch die Richtlinien in Richtlinien und Prüfliste für Kacheln und Signale befolgen.

Nächste Schritte

Verwenden der Windows-Pushbenachrichtigungsdienste (Windows Push Notification Services, WNS)

Sie können Windows-Pushbenachrichtigungsdienste (Windows Push Notification Services, WNS) direkt aufrufen, wenn Mobile Services nicht genügend Flexibilität bietet, wenn Sie Ihren Servercode in C# oder Visual Basic schreiben möchten oder wenn Sie bereits über einen Clouddienst verfügen und Pushbenachrichtigungen daraus senden möchten. Durch direktes Aufrufen von WNS können Sie Pushbenachrichtigungen von Ihrem eigenen Clouddienst senden, z. B. eine Workerrolle, die Daten aus einer Datenbank oder einem anderen Webdienst überwacht. Ihr Clouddienst muss sich bei WNS authentifizieren, um Pushbenachrichtigungen an Ihre Apps zu senden. Erfahren Sie, wie Sie sich beim Windows-Pushbenachrichtigungsdienst (JavaScript) oder (C#/C++/VB) authentifizieren.

Sie können Pushbenachrichtigungen auch senden, indem Sie eine geplante Aufgabe in Ihrem mobilen Dienst ausführen. Siehe Terminserienaufträge in Mobile Services.

Warnung , nachdem Sie den Assistenten für Pushbenachrichtigungen einmal ausgeführt haben, führen Sie den Assistenten nicht ein zweites Mal aus, um Registrierungscode für einen anderen mobilen Dienst hinzuzufügen. Das Ausführen des Assistenten pro Projekt generiert mehr als einmal Code, der zu überlappenden Aufrufen der CreatePushNotificationChannelForApplicationAsync-Methode führt, was zu einer Laufzeit-Ausnahme führt. Wenn Sie sich für Pushbenachrichtigungen für mehrere mobile Dienste registrieren möchten, führen Sie den Assistenten einmal aus, und schreiben Sie dann den Registrierungscode um, um sicherzustellen, dass Aufrufe von CreatePushNotificationChannelForApplicationAsync nicht gleichzeitig ausgeführt werden. Sie können dies z. B. erreichen, indem Sie den vom Assistenten generierten Code in push.register.* (einschließlich des Aufrufs von CreatePushNotificationChannelForApplicationAsync) außerhalb des OnLaunched-Ereignisses verschieben, aber die Besonderheiten dieses Codes hängen von der Architektur Ihrer App ab.