Tutorial: Senden von Pushbenachrichtigungen an bestimmte Android-Anwendungsbenutzer mit Azure Notification Hubs und Google Cloud Messaging (veraltet)Tutorial: Push notification to specific Android application users by using Azure Notification Hubs and Google Cloud Messaging (deprecated)

Warnung

Seit dem 10. April 2018 wird Google Cloud Messaging (GCM) von Google nicht mehr unterstützt.As of April 10, 2018, Google has deprecated Google Cloud Messaging (GCM). Der GCM-Server und die Client-APIs sind veraltet und werden am 29. Mai 2019 entfernt.The GCM server and client APIs are deprecated and will be removed as soon as May 29, 2019. Weitere Informationen finden Sie unter GCM and FCM Frequently Asked Questions (Häufig gestellte Fragen zu GCM und FCM).For more information, see GCM and FCM Frequently Asked Questions.

Ein ASP.NET WebAPI-Back-End wird verwendet, um Clients zu authentifizieren.This tutorial shows you how to use Azure Notification Hubs to send push notifications to a specific app user on a specific device. Zum Authentifizieren von Clients und Generieren von Benachrichtigungen wird ein ASP.NET WebAPI-Back-End verwendet, wie im Artikel Registrierungsverwaltung über ein Back-End gezeigt.An ASP.NET WebAPI backend is used to authenticate clients and to generate notifications, as shown in the guidance article Registering from your app backend. Dieses Tutorial baut auf dem Benachrichtigungs-Hub auf, den Sie unter Tutorial: Senden von Pushbenachrichtigungen an Android-Geräte mit Azure Notification Hubs und Google Cloud Messaging erstellt haben.This tutorial builds on the notification hub that you created in the Tutorial: Push notifications to Android devices by using Azure Notification Hubs and Google Cloud Messaging.

In diesem Tutorial führen Sie die folgenden Schritte aus:In this tutorial, you take the following steps:

  • Erstellen des Back-End-Web-API-Projekts, das Benutzer authentifiziert.Create the backend Web API project that authenticates users.
  • Aktualisieren der Android-Anwendung.Update the Android application.
  • Testen der AppTest the app

VoraussetzungenPrerequisites

Absolvieren Sie Tutorial: Senden von Pushbenachrichtigungen an Android-Geräte mit Azure Notification Hubs und Google Cloud Messaging, bevor Sie mit diesem Tutorial beginnen.Complete the Tutorial: Push notifications to Android devices by using Azure Notification Hubs and Google Cloud Messaging before doing this tutorial.

Erstellen des WebAPI-ProjektsCreate the WebAPI project

In den folgenden Abschnitten wird die Erstellung eines neuen ASP.NET-WebAPI-Back-Ends erläutert.The following sections discuss the creation of a new ASP.NET WebAPI backend. Dieser Prozess hat drei Hauptfunktionen:This process has three main purposes:

  • Authentifizieren von Clients: Sie fügen einen Meldungshandler hinzu, um Clientanforderungen zu authentifizieren und den Benutzer der Anforderung zuzuordnen.Authenticate clients: You add a message handler to authenticate client requests and associate the user with the request.
  • Registrieren für Benachrichtigungen unter Verwendung des WebAPI-Back-Ends: Sie fügen einen Controller hinzu, um neue Registrierungen für ein Clientgerät zum Empfangen von Benachrichtigungen zu verarbeiten.Register for notifications by using the WebAPI backend: You add a controller to handle new registrations for a client device to receive notifications. Der authentifizierte Benutzername wird der Registrierung automatisch als Tag hinzugefügt.The authenticated username is automatically added to the registration as a tag.
  • Senden von Benachrichtigungen an Clients: Sie fügen einen Controller hinzu, um Benutzern die Möglichkeit zu geben, einen sicheren Pushvorgang an Geräte und Clients auszulösen, die dem Tag zugeordnet sind.Send notifications to clients: You add a controller to provide a way for users to trigger a secure push to devices and clients associated with the tag.

Gehen Sie zum Erstellen des neuen ASP.NET-WebAPI-Back-Ends wie folgt vor:Create the new ASP.NET WebAPI backend by doing the following actions:

Wichtig

Falls Sie Visual Studio 2015 oder eine ältere Version verwenden, vergewissern Sie sich vor Beginn dieses Tutorials, dass bei Ihnen die neueste Version des NuGet-Paket-Managers für Visual Studio installiert ist.If you are using Visual Studio 2015 or earlier, before starting this tutorial, ensure that you have installed the latest version of NuGet Package Manager for Visual Studio.

Um dies zu überprüfen, starten Sie Visual Studio.To check, start Visual Studio. Wählen Sie im Menü Extras die Option Erweiterungen und Updates aus.On the Tools menu, select Extensions and Updates. Suchen Sie in Ihrer Version von Visual Studio nach NuGet-Paket-Manager, und vergewissern Sie sich, dass Sie über die neueste Version verfügen.Search for NuGet Package Manager in your version of Visual Studio, and make sure you have the latest version. Deinstallieren Sie andernfalls Ihre Version, und installieren Sie den NuGet-Paket-Manager erneut.If your version is not the latest version, uninstall it, and then reinstall the NuGet Package Manager.

Hinweis

Stellen Sie sicher, dass Sie das Visual Studio Azure SDK für die Websitebereitstellung installiert haben.Make sure you have installed the Visual Studio Azure SDK for website deployment.

  1. Starten Sie Visual Studio oder Visual Studio Express.Start Visual Studio or Visual Studio Express.

  2. Wählen Sie Server-Explorer aus, und melden Sie sich bei Ihrem Azure-Konto an.Select Server Explorer, and sign in to your Azure account. Zur Erstellung der Websiteressourcen für Ihr Konto müssen Sie angemeldet sein.To create the web site resources on your account, you must be signed in.

  3. Klicken Sie in Visual Studio mit der rechten Maustaste auf die Visual Studio-Projektmappe, zeigen Sie auf Hinzufügen, und klicken Sie auf Neues Projekt.In Visual Studio, right-click Visual Studio solution, point to Add, and click New Project.

  4. Erweitern Sie Visual C# , wählen Sie Web aus, und klicken Sie auf ASP.NET-Webanwendung.Expand Visual C#, select Web, and click ASP.NET Web Application.

  5. Geben Sie im Feld Name die Zeichenfolge AppBackend ein, und wählen Sie dann OK aus.In the Name box, type AppBackend, and then select OK.

    Das Fenster „Neues Projekt“

  6. Aktivieren Sie im Fenster Neues ASP.NET-Projekt das Kontrollkästchen Web-API, und wählen Sie anschließend OK aus.In the New ASP.NET Project window, select the Web API check box, and then select OK.

    Das Fenster „Neues ASP.NET-Projekt“

  7. Wählen Sie im Fenster Microsoft Azure-Web-App konfigurieren ein Abonnement aus, und führen Sie anschließend in der Liste App Service-Plan eine der folgenden Aktionen aus:In the Configure Microsoft Azure Web App window, select a subscription and then, in the App Service plan list, do either of the following actions:

    • Wählen Sie einen bereits erstellten App Service-Plan aus.Select an app service plan that you've already created.
    • Wählen Sie Einen neuen App Services-Plan erstellen aus, und erstellen Sie einen neuen Plan.Select Create a new app service plan, and then create one.

    Sie benötigen für dieses Lernprogramm keine Datenbank.You do not need a database for this tutorial. Wählen Sie nach der Wahl Ihres App Service-Plans OK aus, um das Projekt zu erstellen.After you have selected your app service plan, select OK to create the project.

    Das Fenster „Microsoft Azure-Web-App konfigurieren“

    Wird diese Seite zum Konfigurieren des App Service-Plans nicht angezeigt, fahren Sie mit dem Tutorial fort.If you don't see this page for configure app service plan, continue with the tutorial. Sie können ihn später beim Veröffentlichen der App konfigurieren.You can configure it while publishing the app later.

Authentifizieren von Clients beim WebAPI-Back-EndAuthenticate clients to the WebAPI backend

In diesem Abschnitt erstellen Sie für das neue Back-End eine neue Meldungshandlerklasse namens AuthenticationTestHandler.In this section, you create a new message-handler class named AuthenticationTestHandler for the new backend. Diese Klasse wird von DelegatingHandler abgeleitet und als Meldungshandler hinzugefügt, damit alle beim Back-End eingehenden Anforderungen verarbeitet werden können.This class is derived from DelegatingHandler and added as a message handler so that it can process all requests that come into the backend.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie Hinzufügen und anschließend Klasse aus.In Solution Explorer, right-click the AppBackend project, select Add, and then select Class.

  2. Geben Sie der neuen Klasse den Namen AuthenticationTestHandler.cs, und wählen Sie Hinzufügen aus, um die Klasse zu generieren.Name the new class AuthenticationTestHandler.cs, and then select Add to generate the class. Mit dieser Klasse werden Benutzer der Einfachheit halber unter Verwendung der Standardauthentifizierung authentifiziert.This class authenticates users by using Basic Authentication for simplicity. Ihre App kann ein beliebiges Authentifizierungsschema verwenden.Your app can use any authentication scheme.

  3. Fügen Sie in der Datei "AuthenticationTestHandler.cs" die folgenden using -Anweisungen hinzu:In AuthenticationTestHandler.cs, add the following using statements:

    using System.Net.Http;
    using System.Threading;
    using System.Security.Principal;
    using System.Net;
    using System.Text;
    using System.Threading.Tasks;
    
  4. Ersetzen Sie in der Datei „AuthenticationTestHandler.cs“ die Definition der Klasse AuthenticationTestHandler durch den folgenden Code:In AuthenticationTestHandler.cs, replace the AuthenticationTestHandler class definition with the following code:

    Der Handler autorisiert die Anforderung, wenn die folgenden drei Bedingungen erfüllt sind:The handler authorizes the request when the following three conditions are true:

    • Die Anforderung enthält einen Autorisierungsheader.The request includes an Authorization header.
    • Für die Anforderung wird die Standardauthentifizierung verwendet.The request uses basic authentication.
    • Bei der Benutzernamen-Zeichenfolge und der Kennwortzeichenfolge handelt es sich um die gleiche Zeichenfolge.The user name string and the password string are the same string.

    Andernfalls wird die Anforderung abgelehnt.Otherwise, the request is rejected. Diese Authentifizierung ist keine echte Vorgehensweise zur Authentifizierung und Autorisierung.This authentication is not a true authentication and authorization approach. Hierbei handelt es sich lediglich um ein einfaches Beispiel für dieses Tutorial.It is only a simple example for this tutorial.

    Wenn die Anforderungsnachricht von AuthenticationTestHandler authentifiziert und autorisiert wurde, wird der Benutzer der Standardauthentifizierung an die aktuelle Anforderung in HttpContext angefügt.If the request message is authenticated and authorized by AuthenticationTestHandler, the basic authentication user is attached to the current request on HttpContext. Die Benutzerinformationen in „HttpContext“ werden später von einem anderen Controller (RegisterController) verwendet, um der Registrierungsanforderung für die Benachrichtigung ein Tag hinzuzufügen.User information in HttpContext will be used by another controller (RegisterController) later to add a tag to the notification registration request.

    public class AuthenticationTestHandler : DelegatingHandler
    {
        protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var authorizationHeader = request.Headers.GetValues("Authorization").First();
    
            if (authorizationHeader != null && authorizationHeader
                .StartsWith("Basic ", StringComparison.InvariantCultureIgnoreCase))
            {
                string authorizationUserAndPwdBase64 =
                    authorizationHeader.Substring("Basic ".Length);
                string authorizationUserAndPwd = Encoding.Default
                    .GetString(Convert.FromBase64String(authorizationUserAndPwdBase64));
                string user = authorizationUserAndPwd.Split(':')[0];
                string password = authorizationUserAndPwd.Split(':')[1];
    
                if (verifyUserAndPwd(user, password))
                {
                    // Attach the new principal object to the current HttpContext object
                    HttpContext.Current.User =
                        new GenericPrincipal(new GenericIdentity(user), new string[0]);
                    System.Threading.Thread.CurrentPrincipal =
                        System.Web.HttpContext.Current.User;
                }
                else return Unauthorized();
            }
            else return Unauthorized();
    
            return base.SendAsync(request, cancellationToken);
        }
    
        private bool verifyUserAndPwd(string user, string password)
        {
            // This is not a real authentication scheme.
            return user == password;
        }
    
        private Task<HttpResponseMessage> Unauthorized()
        {
            var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
            var tsc = new TaskCompletionSource<HttpResponseMessage>();
            tsc.SetResult(response);
            return tsc.Task;
        }
    }
    

    Hinweis

    Sicherheitshinweis: Die Klasse AuthenticationTestHandler ermöglicht keine wirkliche Authentifizierung.Security note: The AuthenticationTestHandler class does not provide true authentication. Sie wird nur verwendet, um eine Standardauthentifizierung zu imitieren, und ist nicht sicher.It is used only to mimic basic authentication and is not secure. Sie müssen einen sicheren Authentifizierungsmechanismus in Ihren Produktionsanwendungen und -diensten implementieren.You must implement a secure authentication mechanism in your production applications and services.

  5. Fügen Sie am Ende der Methode Register in der Klasse App_Start/WebApiConfig.cs den folgenden Code hinzu, um den Meldungshandler zu registrieren:To register the message handler, add the following code at the end of the Register method in the App_Start/WebApiConfig.cs class:

    config.MessageHandlers.Add(new AuthenticationTestHandler());
    
  6. Speichern Sie die Änderungen.Save your changes.

Registrieren für Benachrichtigungen unter Verwendung des WebAPI-Back-EndsRegister for notifications by using the WebAPI backend

In diesem Abschnitt wird dem WebAPI-Back-End ein neuer Controller hinzugefügt, um Anforderungen zum Registrieren eines Benutzers und eines Geräts für Benachrichtigungen unter Verwendung der Clientbibliothek für Notification Hubs zu verarbeiten.In this section, you add a new controller to the WebAPI backend to handle requests to register a user and a device for notifications by using the client library for notification hubs. Der Controller fügt ein Benutzertag für den Benutzer hinzu, der durch AuthenticationTestHandler authentifiziert und an „HttpContext“ angefügt wurde.The controller adds a user tag for the user that was authenticated and attached to HttpContext by AuthenticationTestHandler. Die Markierung hat das Zeichenfolgenformat "username:<actual username>".The tag has the string format, "username:<actual username>".

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie dann NuGet-Pakete verwalten aus.In Solution Explorer, right-click the AppBackend project and then select Manage NuGet Packages.

  2. Wählen Sie im linken Bereich Online aus, und geben Sie dann im Feld Suche die Zeichenfolge Microsoft.Azure.NotificationHubs ein.In the left pane, select Online and then, in the Search box, type Microsoft.Azure.NotificationHubs.

  3. Wählen Sie in der Ergebnisliste die Option Microsoft Azure Notification Hubs und anschließend Installieren aus.In the results list, select Microsoft Azure Notification Hubs, and then select Install. Schließen Sie die Installation ab, und schließen Sie dann das Fenster des NuGet-Paket-Managers.Complete the installation, and then close the NuGet Package Manager window.

    Dadurch wird mithilfe des Microsoft.Azure.NotificationHubs-NuGet-Pakets ein Verweis auf das Azure Notification Hubs-SDK hinzugefügt.This action adds a reference to the Azure Notification Hubs SDK by using the Microsoft.Azure.Notification Hubs NuGet package.

  4. Erstellen Sie eine neue Klassendatei, die die Verbindung mit dem Notification Hub darstellt, der zum Senden von Benachrichtigungen verwendet wird.Create a new class file that represents the connection with the notification hub that's used to send notifications. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Modelle, und wählen Sie dann Hinzufügen und anschließend Klasse aus.In Solution Explorer, right-click the Models folder, select Add, and then select Class. Nennen Sie die neue Klasse Notifications.cs, und wählen Sie dann Hinzufügen aus, um die Klasse zu generieren.Name the new class Notifications.cs, and then select Add to generate the class.

    Das Fenster „Neues Element hinzufügen“

  5. Fügen Sie die folgende using -Anweisung am Anfang der Datei "Notifications.cs" hinzu:In Notifications.cs, add the following using statement at the top of the file:

    using Microsoft.Azure.NotificationHubs;
    
  6. Ersetzen Sie die Definition der Klasse Notifications durch den folgenden Code und die beiden Platzhalter durch die Verbindungszeichenfolge (mit Vollzugriff) für Ihren Notification Hub bzw. durch den Namen des Hubs (verfügbar im Azure-Portal):Replace the Notifications class definition with the following code, and replace the two placeholders with the connection string (with full access) for your notification hub and the hub name (available at Azure portal):

    public class Notifications
    {
        public static Notifications Instance = new Notifications();
    
        public NotificationHubClient Hub { get; set; }
    
        private Notifications() {
            Hub = NotificationHubClient.CreateClientFromConnectionString("<your hub's DefaultFullSharedAccessSignature>",
                                                                            "<hub name>");
        }
    }
    
  7. Erstellen Sie als Nächstes einen neuen Controller namens RegisterController.Next, create a new controller named RegisterController. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Controller, und wählen Sie dann Hinzufügen und Controller aus.In Solution Explorer, right-click the Controllers folder, select Add, and then select Controller.

  8. Wählen Sie Web-API-2-Controller – Leer und anschließend Hinzufügen aus.Select Web API 2 Controller - Empty, and then select Add.

    Das Fenster „Gerüst hinzufügen“

  9. Geben Sie im Feld Controllername die Zeichenfolge RegisterController ein, um die neue Klasse zu benennen, und wählen Sie anschließend Hinzufügen aus.In the Controller name box, type RegisterController to name the new class, and then select Add.

    Das Fenster „Controller hinzufügen“

  10. Fügen Sie in der Datei "RegisterController.cs" die folgenden using -Anweisungen hinzu:In RegisterController.cs, add the following using statements:

    using Microsoft.Azure.NotificationHubs;
    using Microsoft.Azure.NotificationHubs.Messaging;
    using AppBackend.Models;
    using System.Threading.Tasks;
    using System.Web;
    
  11. Fügen Sie innerhalb der RegisterController -Klassendefinition den folgenden Code hinzu.Add the following code inside the RegisterController class definition. Mit diesem Code fügen Sie ein Benutzertag für den Benutzer hinzu, der HttpContext angefügt ist.In this code, you add a user tag for the user that's attached to HttpContext. Der Benutzer wurde mit dem von Ihnen hinzugefügten Nachrichtenfilter AuthenticationTestHandler authentifiziert und HttpContext angefügt.The user was authenticated and attached to HttpContext by the message filter that you added, AuthenticationTestHandler. Sie können auch optionale Überprüfungen hinzufügen, um zu überprüfen, dass der Benutzer die richtigen Berechtigungen besitzt, um sich für die angeforderten Tags zu registrieren.You can also add optional checks to verify that the user has rights to register for the requested tags.

    private NotificationHubClient hub;
    
    public RegisterController()
    {
        hub = Notifications.Instance.Hub;
    }
    
    public class DeviceRegistration
    {
        public string Platform { get; set; }
        public string Handle { get; set; }
        public string[] Tags { get; set; }
    }
    
    // POST api/register
    // This creates a registration id
    public async Task<string> Post(string handle = null)
    {
        string newRegistrationId = null;
    
        // make sure there are no existing registrations for this push handle (used for iOS and Android)
        if (handle != null)
        {
            var registrations = await hub.GetRegistrationsByChannelAsync(handle, 100);
    
            foreach (RegistrationDescription registration in registrations)
            {
                if (newRegistrationId == null)
                {
                    newRegistrationId = registration.RegistrationId;
                }
                else
                {
                    await hub.DeleteRegistrationAsync(registration);
                }
            }
        }
    
        if (newRegistrationId == null) 
            newRegistrationId = await hub.CreateRegistrationIdAsync();
    
        return newRegistrationId;
    }
    
    // PUT api/register/5
    // This creates or updates a registration (with provided channelURI) at the specified id
    public async Task<HttpResponseMessage> Put(string id, DeviceRegistration deviceUpdate)
    {
        RegistrationDescription registration = null;
        switch (deviceUpdate.Platform)
        {
            case "mpns":
                registration = new MpnsRegistrationDescription(deviceUpdate.Handle);
                break;
            case "wns":
                registration = new WindowsRegistrationDescription(deviceUpdate.Handle);
                break;
            case "apns":
                registration = new AppleRegistrationDescription(deviceUpdate.Handle);
                break;
            case "fcm":
                registration = new FcmRegistrationDescription(deviceUpdate.Handle);
                break;
            default:
                throw new HttpResponseException(HttpStatusCode.BadRequest);
        }
    
        registration.RegistrationId = id;
        var username = HttpContext.Current.User.Identity.Name;
    
        // add check if user is allowed to add these tags
        registration.Tags = new HashSet<string>(deviceUpdate.Tags);
        registration.Tags.Add("username:" + username);
    
        try
        {
            await hub.CreateOrUpdateRegistrationAsync(registration);
        }
        catch (MessagingException e)
        {
            ReturnGoneIfHubResponseIsGone(e);
        }
    
        return Request.CreateResponse(HttpStatusCode.OK);
    }
    
    // DELETE api/register/5
    public async Task<HttpResponseMessage> Delete(string id)
    {
        await hub.DeleteRegistrationAsync(id);
        return Request.CreateResponse(HttpStatusCode.OK);
    }
    
    private static void ReturnGoneIfHubResponseIsGone(MessagingException e)
    {
        var webex = e.InnerException as WebException;
        if (webex.Status == WebExceptionStatus.ProtocolError)
        {
            var response = (HttpWebResponse)webex.Response;
            if (response.StatusCode == HttpStatusCode.Gone)
                throw new HttpRequestException(HttpStatusCode.Gone.ToString());
        }
    }
    
  12. Speichern Sie die Änderungen.Save your changes.

Senden von Benachrichtigungen über das WebAPI-Back-EndSend notifications from the WebAPI backend

In diesem Abschnitt wird ein neuer Controller hinzugefügt, der Clientgeräten das Senden einer Benachrichtigung ermöglicht.In this section, you add a new controller that exposes a way for client devices to send a notification. Die Benachrichtigung basiert auf dem Benutzernamentag, das die Azure Notification Hubs .NET-Bibliothek des ASP.NET WebAPI-Back-Ends verwendet.The notification is based on the username tag that uses Azure Notification Hubs .NET Library in the ASP.NET WebAPI backend.

  1. Erstellen Sie einen weiteren neuen Domänencontroller namens NotificationsController. Verwenden Sie dazu die gleiche Vorgehensweise wie bei der Erstellung von RegisterController im vorherigen Abschnitt.Create another new controller named NotificationsController the same way you created RegisterController in the previous section.

  2. Fügen Sie in der Datei "NotificationsController.cs" die folgenden using -Anweisungen hinzu:In NotificationsController.cs, add the following using statements:

    using AppBackend.Models;
    using System.Threading.Tasks;
    using System.Web;
    
  3. Fügen Sie der Klasse NotificationsController die folgende Methode hinzu:Add the following method to the NotificationsController class:

    Mit diesem Code wird ein Benachrichtigungstyp gesendet, der auf dem Parameter pns des Plattformbenachrichtigungssystems (Plattform Notification System, PNS) basiert.This code sends a notification type that's based on the Platform Notification Service (PNS) pns parameter. Der Wert von to_tag dient zum Festlegen des username -Tags in der Nachricht.The value of to_tag is used to set the username tag on the message. Dieses Tag muss mit einem Benutzernamentag einer aktiven Notification Hub-Registrierung übereinstimmen.This tag must match a username tag of an active notification hub registration. Die Benachrichtigung wird aus dem Text der POST-Anforderung abgerufen und für den Ziel-PNS formatiert.The notification message is pulled from the body of the POST request and formatted for the target PNS.

    Abhängig von dem PNS, mit dem Ihre unterstützten Geräte Benachrichtigungen empfangen, werden Benachrichtigungen mit unterschiedlichen Formaten unterstützt.Depending on the PNS that your supported devices use to receive notifications, the notifications are supported by a variety of formats. Ein Beispiel: Angenommen, Sie verwenden auf Windows-Geräten eine Popupbenachrichtigung mit WNS, die nicht direkt durch ein anderes PNS unterstützt wird.For example, on Windows devices, you might use a toast notification with WNS that isn't directly supported by another PNS. In diesem Fall muss Ihr Back-End die Benachrichtigung so formatieren, dass sie mit dem PNS der zu unterstützenden Geräte kompatibel ist.In such an instance, your backend needs to format the notification into a supported notification for the PNS of devices you plan to support. Verwenden Sie anschließend die entsprechende Sende-API für die NotificationHubClient-Klasse.Then use the appropriate send API on the NotificationHubClient class.

    public async Task<HttpResponseMessage> Post(string pns, [FromBody]string message, string to_tag)
    {
        var user = HttpContext.Current.User.Identity.Name;
        string[] userTag = new string[2];
        userTag[0] = "username:" + to_tag;
        userTag[1] = "from:" + user;
    
        Microsoft.Azure.NotificationHubs.NotificationOutcome outcome = null;
        HttpStatusCode ret = HttpStatusCode.InternalServerError;
    
        switch (pns.ToLower())
        {
            case "wns":
                // Windows 8.1 / Windows Phone 8.1
                var toast = @"<toast><visual><binding template=""ToastText01""><text id=""1"">" + 
                            "From " + user + ": " + message + "</text></binding></visual></toast>";
                outcome = await Notifications.Instance.Hub.SendWindowsNativeNotificationAsync(toast, userTag);
                break;
            case "apns":
                // iOS
                var alert = "{\"aps\":{\"alert\":\"" + "From " + user + ": " + message + "\"}}";
                outcome = await Notifications.Instance.Hub.SendAppleNativeNotificationAsync(alert, userTag);
                break;
            case "fcm":
                // Android
                var notif = "{ \"data\" : {\"message\":\"" + "From " + user + ": " + message + "\"}}";
                outcome = await Notifications.Instance.Hub.SendFcmNativeNotificationAsync(notif, userTag);
                break;
        }
    
        if (outcome != null)
        {
            if (!((outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Abandoned) ||
                (outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Unknown)))
            {
                ret = HttpStatusCode.OK;
            }
        }
    
        return Request.CreateResponse(ret);
    }
    
  4. Drücken Sie F5, um die Anwendung auszuführen und sich zu vergewissern, dass soweit alles funktioniert.To run the application and ensure the accuracy of your work so far, select the F5 key. Die App öffnet einen Webbrowser und wird auf der Homepage von ASP.NET angezeigt.The app opens a web browser, and it is displayed on the ASP.NET home page.

Veröffentlichen des neuen WebAPI-Back-EndsPublish the new WebAPI backend

Als Nächstes wird die App auf einer Azure-Website bereitgestellt, damit sie für alle Geräte zur Verfügung steht.Next, you deploy the app to an Azure website to make it accessible from all devices.

  1. Klicken Sie mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie Veröffentlichen aus.Right-click the AppBackend project, and then select Publish.

  2. Wählen Sie Microsoft Azure App Service als Veröffentlichungsziel und anschließend **Veröffentlichen aus.Select Microsoft Azure App Service as your publish target, and then select **Publish. Das Fenster „App Service erstellen“ wird geöffnet.The Create App Service window opens. Hier können Sie alle Azure-Ressourcen erstellen, die zum Ausführen der ASP.NET-Web-App in Azure benötigt werden.Here you can create all the necessary Azure resources to run the ASP.NET web app in Azure.

    Die Kachel „Microsoft Azure App Service“

  3. Wählen Sie im Fenster App Service erstellen Ihr Azure-Konto aus.In the Create App Service window, select your Azure account. Wählen Sie Typ ändern > Web App aus.Select Change Type > Web App. Behalten Sie den Standardwert für Web-App-Name bei, und wählen Sie Abonnement, Ressourcengruppe und App Service-Plan aus.Keep the default Web App Name, and then select the Subscription, Resource Group, and App Service Plan.

  4. Klicken Sie auf Erstellen.Select Create.

  5. Notieren Sie sich die Website-URL aus der Zusammenfassung.Make a note of the Site URL property in the Summary section. Diese URL ist später im Tutorial Ihr Back-End-Endpunkt.This URL is your back-end endpoint later in the tutorial.

  6. Wählen Sie Veröffentlichen.Select Publish.

Nach Abschluss des Assistenten wird die ASP.NET Web-App in Azure veröffentlicht und anschließend im Standardbrowser geöffnet.After you've completed the wizard, it publishes the ASP.NET web app to Azure and then opens the app in the default browser. Ihre Anwendung kann in Azure App Services angezeigt werden.Your application is viewable in Azure App Services.

In der URL wird der von Ihnen angegebene Web-App-Name im Format „http://.azurewebsites.net“ verwendet.The URL uses the web app name that you specified earlier, with the format http://<app_name>.azurewebsites.net.

Erstellen des Android-ProjektsCreate the Android Project

Aktualisieren Sie als Nächstes die Android-Anwendung, die Sie in Tutorial: Senden von Pushbenachrichtigungen an Android-Geräte mit Azure Notification Hubs und Google Cloud Messaging erstellt haben.The next step is to update the Android application created in the Tutorial: Push notifications to Android devices by using Azure Notification Hubs and Google Cloud Messaging.

  1. Öffnen Sie die Datei res/layout/activity_main.xml, und ersetzen Sie die folgenden Inhaltsdefinitionen:Open your res/layout/activity_main.xml file, replace the following content definitions:

    So werden neue EditText-Steuerelemente für die Anmeldung als Benutzer hinzugefügt.It adds new EditText controls for logging in as a user. Zudem wird ein Feld für eine Benutzernamenmarkierung hinzugefügt, die in den von Ihnen gesendeten Benachrichtigungen enthalten ist.Also a field is added for a username tag that will be part of notifications you send:

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
    
    <EditText
        android:id="@+id/usernameText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="@string/usernameHint"
        android:layout_above="@+id/passwordText"
        android:layout_alignParentEnd="true" />
    <EditText
        android:id="@+id/passwordText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="@string/passwordHint"
        android:inputType="textPassword"
        android:layout_above="@+id/buttonLogin"
        android:layout_alignParentEnd="true" />
    <Button
        android:id="@+id/buttonLogin"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/loginButton"
        android:onClick="login"
        android:layout_above="@+id/toggleButtonGCM"
        android:layout_centerHorizontal="true"
        android:layout_marginBottom="24dp" />
    <ToggleButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textOn="WNS on"
        android:textOff="WNS off"
        android:id="@+id/toggleButtonWNS"
        android:layout_toLeftOf="@id/toggleButtonGCM"
        android:layout_centerVertical="true" />
    <ToggleButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textOn="GCM on"
        android:textOff="GCM off"
        android:id="@+id/toggleButtonGCM"
        android:checked="true"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true" />
    <ToggleButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textOn="APNS on"
        android:textOff="APNS off"
        android:id="@+id/toggleButtonAPNS"
        android:layout_toRightOf="@id/toggleButtonGCM"
        android:layout_centerVertical="true" />
    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/editTextNotificationMessageTag"
        android:layout_below="@id/toggleButtonGCM"
        android:layout_centerHorizontal="true"
        android:hint="@string/notification_message_tag_hint" />
    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/editTextNotificationMessage"
        android:layout_below="@+id/editTextNotificationMessageTag"
        android:layout_centerHorizontal="true"
        android:hint="@string/notification_message_hint" />
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/send_button"
        android:id="@+id/sendbutton"
        android:onClick="sendNotificationButtonOnClick"
        android:layout_below="@+id/editTextNotificationMessage"
        android:layout_centerHorizontal="true" />
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:id="@+id/text_hello"
    />  
    </RelativeLayout>
    
  2. Öffnen Sie die Datei res/values/strings.xml, und ersetzen Sie die Definition send_button durch die folgenden Zeilen, um die Zeichenfolge für send_button neu zu definieren und Zeichenfolgen für die anderen Steuerelemente hinzuzufügen:Open your res/values/strings.xml file and replace the send_button definition with the following lines that redefine the string for the send_button and add strings for the other controls:

    <string name="usernameHint">Username</string>
    <string name="passwordHint">Password</string>
    <string name="loginButton">1. Sign in</string>
    <string name="send_button">2. Send Notification</string>
    <string name="notification_message_hint">Notification message</string>
    <string name="notification_message_tag_hint">Recipient username</string>
    

    Das grafische Layout von main_activity.xml sollte nun wie folgt aussehen:Your main_activity.xml graphical layout should now look like the following image:

  3. Erstellen Sie in dem Paket, in dem sich auch die Klasse MainActivity befindet, eine neue Klasse mit dem Namen RegisterClient.Create a new class named RegisterClient in the same package as your MainActivity class. Verwenden Sie den folgenden Code für die neue Klassendatei.Use the code below for the new class file.

    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.util.Set;
    
    import org.apache.http.HttpResponse;
    import org.apache.http.HttpStatus;
    import org.apache.http.client.ClientProtocolException;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.client.methods.HttpPut;
    import org.apache.http.client.methods.HttpUriRequest;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.util.EntityUtils;
    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;
    
    import android.content.Context;
    import android.content.SharedPreferences;
    import android.util.Log;
    
    public class RegisterClient {
        private static final String PREFS_NAME = "ANHSettings";
        private static final String REGID_SETTING_NAME = "ANHRegistrationId";
        private String Backend_Endpoint;
        SharedPreferences settings;
        protected HttpClient httpClient;
        private String authorizationHeader;
    
        public RegisterClient(Context context, String backendEndpoint) {
            super();
            this.settings = context.getSharedPreferences(PREFS_NAME, 0);
            httpClient =  new DefaultHttpClient();
            Backend_Endpoint = backendEndpoint + "/api/register";
        }
    
        public String getAuthorizationHeader() {
            return authorizationHeader;
        }
    
        public void setAuthorizationHeader(String authorizationHeader) {
            this.authorizationHeader = authorizationHeader;
        }
    
        public void register(String handle, Set<String> tags) throws ClientProtocolException, IOException, JSONException {
            String registrationId = retrieveRegistrationIdOrRequestNewOne(handle);
    
            JSONObject deviceInfo = new JSONObject();
            deviceInfo.put("Platform", "gcm");
            deviceInfo.put("Handle", handle);
            deviceInfo.put("Tags", new JSONArray(tags));
    
            int statusCode = upsertRegistration(registrationId, deviceInfo);
    
            if (statusCode == HttpStatus.SC_OK) {
                return;
            } else if (statusCode == HttpStatus.SC_GONE){
                settings.edit().remove(REGID_SETTING_NAME).commit();
                registrationId = retrieveRegistrationIdOrRequestNewOne(handle);
                statusCode = upsertRegistration(registrationId, deviceInfo);
                if (statusCode != HttpStatus.SC_OK) {
                    Log.e("RegisterClient", "Error upserting registration: " + statusCode);
                    throw new RuntimeException("Error upserting registration");
                }
            } else {
                Log.e("RegisterClient", "Error upserting registration: " + statusCode);
                throw new RuntimeException("Error upserting registration");
            }
        }
    
        private int upsertRegistration(String registrationId, JSONObject deviceInfo)
                throws UnsupportedEncodingException, IOException,
                ClientProtocolException {
            HttpPut request = new HttpPut(Backend_Endpoint+"/"+registrationId);
            request.setEntity(new StringEntity(deviceInfo.toString()));
            request.addHeader("Authorization", "Basic "+authorizationHeader);
            request.addHeader("Content-Type", "application/json");
            HttpResponse response = httpClient.execute(request);
            int statusCode = response.getStatusLine().getStatusCode();
            return statusCode;
        }
    
        private String retrieveRegistrationIdOrRequestNewOne(String handle) throws ClientProtocolException, IOException {
            if (settings.contains(REGID_SETTING_NAME))
                return settings.getString(REGID_SETTING_NAME, null);
    
            HttpUriRequest request = new HttpPost(Backend_Endpoint+"?handle="+handle);
            request.addHeader("Authorization", "Basic "+authorizationHeader);
            HttpResponse response = httpClient.execute(request);
            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                Log.e("RegisterClient", "Error creating registrationId: " + response.getStatusLine().getStatusCode());
                throw new RuntimeException("Error creating Notification Hubs registrationId");
            }
            String registrationId = EntityUtils.toString(response.getEntity());
            registrationId = registrationId.substring(1, registrationId.length()-1);
    
            settings.edit().putString(REGID_SETTING_NAME, registrationId).commit();
    
            return registrationId;
        }
    }
    

    Diese Komponente implementiert die REST-Aufrufe, die für das Kontaktieren des App-Back-Ends erforderlich sind, um sich für Pushbenachrichtigungen zu registrieren.This component implements the REST calls required to contact the app backend, in order to register for push notifications. Außerdem werden die vom Notification Hub erstellten registrationIds lokal gespeichert, wie unter Registrierung vom App-Back-End ausbeschrieben.It also locally stores the registrationIds created by the Notification Hub as detailed in Registering from your app backend. Wenn Sie die Schaltfläche Anmelden verwenden, wird ein Authentifizierungstoken aus dem lokalen Speicher verwendet.It uses an authorization token stored in local storage when you click the Sign in button.

  4. Entfernen Sie in Ihrer Klasse Ihr privates Feld für NotificationHub, oder kommentieren Sie es aus, und fügen Sie ein Feld für die RegisterClient-Klasse und eine Zeichenfolge für den Endpunkt Ihres ASP.NET-Back-Ends hinzu.In your class, remove or comment out your private field for NotificationHub, and add a field for the RegisterClient class and a string for your ASP.NET backend's endpoint. Ersetzen Sie <Enter Your Backend Endpoint> unbedingt durch den tatsächlichen Back-End-Endpunkt, den Sie zuvor abgerufen haben.Be sure to replace <Enter Your Backend Endpoint> with your actual backend endpoint obtained previously. Beispiel: http://mybackend.azurewebsites.net.For example, http://mybackend.azurewebsites.net.

    //private NotificationHub hub;
    private RegisterClient registerClient;
    private static final String BACKEND_ENDPOINT = "<Enter Your Backend Endpoint>";
    
  5. Entfernen Sie in der MainActivity-Klasse in der onCreate-Methode die Initialisierung des hub-Felds, oder kommentieren Sie sie aus, und rufen Sie die registerWithNotificationHubs-Methode auf.In your MainActivity class, in the onCreate method, remove, or comment out the initialization of the hub field and the call to the registerWithNotificationHubs method. Fügen Sie dann Code zum Initialisieren einer Instanz der RegisterClient -Klasse hinzu.Then add code to initialize an instance of the RegisterClient class. Die Methode sollte die folgenden Zeilen enthalten:The method should contain the following lines:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    
        mainActivity = this;
        NotificationsManager.handleNotifications(this, NotificationSettings.SenderId, MyHandler.class);
        gcm = GoogleCloudMessaging.getInstance(this);
    
        //hub = new NotificationHub(HubName, HubListenConnectionString, this);
        //registerWithNotificationHubs();
    
        registerClient = new RegisterClient(this, BACKEND_ENDPOINT);
    
        setContentView(R.layout.activity_main);
    }
    
  6. Löschen Sie in der MainActivity-Klasse die gesamte registerWithNotificationHubs-Methode, oder kommentieren Sie sie aus.In your MainActivity class, delete or comment out the entire registerWithNotificationHubs method. Sie wird in diesem Lernprogramm nicht verwendet.It will not be used in this tutorial.

  7. Fügen Sie der Datei MainActivity.java die folgenden import-Anweisungen hinzu:Add the following import statements to your MainActivity.java file.

    import android.util.Base64;
    import android.view.View;
    import android.widget.EditText;
    
    import android.widget.Button;
    import android.widget.ToggleButton;
    import java.io.UnsupportedEncodingException;
    import android.content.Context;
    import java.util.HashSet;
    import android.widget.Toast;
    import org.apache.http.client.ClientProtocolException;
    import java.io.IOException;
    import org.apache.http.HttpStatus;
    
    import android.os.AsyncTask;
    import org.apache.http.HttpResponse;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.DefaultHttpClient;
    
    import android.app.AlertDialog;
    import android.content.DialogInterface;
    
  8. Ersetzen Sie den Code in der onStart-Methode durch den folgenden Code:Replace code on the onStart method with the following code:

    super.onStart();
    Button sendPush = (Button) findViewById(R.id.sendbutton);
    sendPush.setEnabled(false);
    
  9. Fügen Sie dann die folgenden Methoden zum Verarbeiten des Click-Ereignisses der Schaltfläche Anmelden und zum Senden von Pushbenachrichtigungen hinzu.Then, add the following methods to handle the Sign in button click event and sending push notifications.

    public void login(View view) throws UnsupportedEncodingException {
        this.registerClient.setAuthorizationHeader(getAuthorizationHeader());
    
        final Context context = this;
        new AsyncTask<Object, Object, Object>() {
            @Override
            protected Object doInBackground(Object... params) {
                try {
                    String regid = gcm.register(NotificationSettings.SenderId);
                    registerClient.register(regid, new HashSet<String>());
                } catch (Exception e) {
                    DialogNotify("MainActivity - Failed to register", e.getMessage());
                    return e;
                }
                return null;
            }
    
            protected void onPostExecute(Object result) {
                Button sendPush = (Button) findViewById(R.id.sendbutton);
                sendPush.setEnabled(true);
                Toast.makeText(context, "Logged in and registered.",
                        Toast.LENGTH_LONG).show();
            }
        }.execute(null, null, null);
    }
    
    private String getAuthorizationHeader() throws UnsupportedEncodingException {
        EditText username = (EditText) findViewById(R.id.usernameText);
        EditText password = (EditText) findViewById(R.id.passwordText);
        String basicAuthHeader = username.getText().toString()+":"+password.getText().toString();
        basicAuthHeader = Base64.encodeToString(basicAuthHeader.getBytes("UTF-8"), Base64.NO_WRAP);
        return basicAuthHeader;
    }
    
    /**
        * This method calls the ASP.NET WebAPI backend to send the notification message
        * to the platform notification service based on the pns parameter.
        *
        * @param pns     The platform notification service to send the notification message to. Must
        *                be one of the following ("wns", "gcm", "apns").
        * @param userTag The tag for the user who will receive the notification message. This string
        *                must not contain spaces or special characters.
        * @param message The notification message string. This string must include the double quotes
        *                to be used as JSON content.
        */
    public void sendPush(final String pns, final String userTag, final String message)
            throws ClientProtocolException, IOException {
        new AsyncTask<Object, Object, Object>() {
            @Override
            protected Object doInBackground(Object... params) {
                try {
    
                    String uri = BACKEND_ENDPOINT + "/api/notifications";
                    uri += "?pns=" + pns;
                    uri += "&to_tag=" + userTag;
    
                    HttpPost request = new HttpPost(uri);
                    request.addHeader("Authorization", "Basic "+ getAuthorizationHeader());
                    request.setEntity(new StringEntity(message));
                    request.addHeader("Content-Type", "application/json");
    
                    HttpResponse response = new DefaultHttpClient().execute(request);
    
                    if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                        DialogNotify("MainActivity - Error sending " + pns + " notification",
                            response.getStatusLine().toString());
                        throw new RuntimeException("Error sending notification");
                    }
                } catch (Exception e) {
                    DialogNotify("MainActivity - Failed to send " + pns + " notification ", e.getMessage());
                    return e;
                }
    
                return null;
            }
        }.execute(null, null, null);
    }
    

    Der login-Handler für die Schaltfläche Anmelden generiert unter Verwendung des eingegebenen Benutzernamens und Kennworts ein Standardauthentifizierungstoken (dies kann ein beliebiges in Ihrem Authentifizierungsschema verwendetes Token sein) und verwendet dann RegisterClient zum Aufrufen des Back-Ends für die Registrierung.The login handler for the Sign in button generates a basic authentication token using on the input username and password (it represents any token your authentication scheme uses), then it uses RegisterClient to call the backend for registration.

    Die sendPush -Methode ruft das Back-End auf, um basierend auf der Benutzermarkierung eine sichere Benachrichtigung auszulösen.The sendPush method calls the backend to trigger a secure notification to the user based on the user tag. Der Plattformbenachrichtigungsdienst, auf den sendPush verweist, hängt von der übergebenen pns-Zeichenfolge ab.The platform notification service that sendPush targets depends on the pns string passed in.

  10. Fügen Sie der MainActivity-Klasse die folgende DialogNotify-Methode hinzu.Add the following DialogNotify method to the MainActivity class.

    protected void DialogNotify(String title, String message)
    {
        AlertDialog alertDialog = new AlertDialog.Builder(MainActivity.this).create();
        alertDialog.setTitle(title);
        alertDialog.setMessage(message);
        alertDialog.setButton(AlertDialog.BUTTON_NEUTRAL, "OK",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                    }
                });
        alertDialog.show();
    }
    
  11. Aktualisieren Sie in der MainActivity-Klasse die sendNotificationButtonOnClick-Methode so, dass sie wie folgt die sendPush-Methode mit den ausgewählten Plattformbenachrichtigungsdiensten des Benutzers aufruft.In your MainActivity class, update the sendNotificationButtonOnClick method to call the sendPush method with the user's selected platform notification services as follows.

    /**
    * Send Notification button click handler. This method sends the push notification
    * message to each platform selected.
    *
    * @param v The view
    */
    public void sendNotificationButtonOnClick(View v)
            throws ClientProtocolException, IOException {
    
        String nhMessageTag = ((EditText) findViewById(R.id.editTextNotificationMessageTag))
                .getText().toString();
        String nhMessage = ((EditText) findViewById(R.id.editTextNotificationMessage))
                .getText().toString();
    
        // JSON String
        nhMessage = "\"" + nhMessage + "\"";
    
        if (((ToggleButton)findViewById(R.id.toggleButtonWNS)).isChecked())
        {
            sendPush("wns", nhMessageTag, nhMessage);
        }
        if (((ToggleButton)findViewById(R.id.toggleButtonGCM)).isChecked())
        {
            sendPush("gcm", nhMessageTag, nhMessage);
        }
        if (((ToggleButton)findViewById(R.id.toggleButtonAPNS)).isChecked())
        {
            sendPush("apns", nhMessageTag, nhMessage);
        }
    }
    
  12. Fügen Sie dem Abschnitt android in der Datei build.gradle nach dem Abschnitt buildTypes die folgende Zeile hinzu:In the build.gradle file, add the following line to the android section after the buildTypes section.

    useLibrary 'org.apache.http.legacy'
    
  13. Erstellen Sie das Projekt.Build the project.

Testen der AppTest the app

  1. Führen Sie die Anwendung unter Verwendung von Android Studio auf einem Gerät oder einen Emulator aus.Run the application on a device or an emulator using Android Studio.

  2. Geben Sie in der Android-App einen Benutzernamen und ein Kennwort ein.In the Android app, enter a username and password. Beide müssen den gleichen Zeichenfolgenwert aufweisen und dürfen keine Leerzeichen oder Sonderzeichen enthalten.They must both be the same string value and they must not contain spaces or special characters.

  3. Tippen Sie in der Android-App auf Anmelden.In the Android app, click Sign in. Warten Sie, bis die Popupmeldung Logged in and registeredangezeigt wird.Wait for a toast message that states Logged in and registered. Dadurch wird die Schaltfläche Send Notification (Benachrichtigung senden) aktiviert.It enables the Send Notification button.

  4. Klicken Sie auf die Umschaltflächen, um alle Plattformen zu aktivieren, auf denen Sie die App ausgeführt und einen Benutzer registriert haben.Click the toggle buttons to enable all platforms where you ran the app and registered a user.

  5. Geben Sie den Namen des Benutzers ein, der die Benachrichtigungsmeldung erhält.Enter the user's name that receives the notification message. Dieser Benutzer muss für Benachrichtigungen auf dem Zielgerät registriert werden.That user must be registered for notifications on the target devices.

  6. Geben Sie eine Nachricht für den Benutzer ein, die als Pushbenachrichtigungsmeldung empfangen wird.Enter a message for the user to receive as a push notification message.

  7. Tippen Sie auf Send Notification.Click Send Notification. Die Pushbenachrichtigung wird auf jedem Gerät empfangen, das für die übereinstimmende Benutzernamensmarkierung registriert ist.Each device that has a registration with the matching username tag receives the push notification.

Nächste SchritteNext steps

In diesem Tutorial haben Sie gelernt, wie Sie Pushbenachrichtigungen an bestimmte Benutzer senden, deren Registrierungen Tags zugeordnet sind.In this tutorial, you learned how to push notifications to specific users that have tags associated with their registrations. Um zu erfahren, wie Sie standortbasierte Pushbenachrichtigungen senden, fahren Sie mit dem folgenden Tutorial fort:To learn how to push location-based notifications, advance to the following tutorial: