Tutorial: Senden von Pushbenachrichtigungen an Xamarin.Forms-Apps mithilfe von Azure Notification Hubs über einen Back-End-Dienst

Artikel
07/27/2020

Beispiel herunterladen Herunterladen des Beispiels

In diesem Tutorial verwenden Sie Azure Notification Hubs zum Pushen von Benachrichtigungen an eine Xamarin.Forms-Anwendung für Android und iOS.

Ein ASP.NET Core Web-API-Back-End wird verwendet, um die Geräteregistrierung für den Client mithilfe des neuesten und besten Installationsansatzes zu verarbeiten. Der Dienst sendet auch plattformübergreifend Pushbenachrichtigungen.

Diese Vorgänge werden mit dem Notification Hubs SDK für Back-End-Vorgänge verarbeitet. Weitere Details zum Gesamtansatz finden Sie in der Dokumentation Registrieren über Das App-Back-End .

In diesem Tutorial werden die folgenden Schritte erklärt:

Richten Sie Push Notification Services und Azure Notification Hubs ein.
Erstellen Sie eine ASP.NET Core Web-API-Back-End-Anwendung.
Erstellen Sie eine plattformübergreifende Xamarin.Forms-Anwendung.
Konfigurieren Sie das native Android-Projekt für Pushbenachrichtigungen.
Konfigurieren Sie das native iOS-Projekt für Pushbenachrichtigungen.
Testen der Lösung

Voraussetzungen

Für die Weiterverfolgung benötigen Sie Folgendes:

Ein Azure-Abonnement, in dem Sie Ressourcen erstellen und verwalten können.
Ein Mac mit installierter Visual Studio für Mac oder ein PC mit Visual Studio 2019.
Visual Studio 2019-Benutzer müssen auch mobile Entwicklung mit .NET und ASP.NET- und Webentwicklungsworkloads installiert haben.
Die Möglichkeit, die App entweder unter Android (physische Geräte oder Emulatorgeräte) oder iOS (nur physische Geräte) auszuführen.

Für Android benötigen Sie Folgendes:

Ein entwicklerentsperrtes physisches Gerät oder ein Emulator (mit API 26 und höher mit installierten Google Play Services)

Für iOS benötigen Sie Folgendes:

Ein aktives Apple Developer-Konto.
Ein physisches iOS-Gerät, das bei Ihrem Entwicklerkonto registriert ist (unter iOS 13.0 und höher)
Ein P12-Entwicklungszertifikat, das in Ihrem Keychain installiert ist, mit dem Sie eine App auf einem physischen Gerät ausführen können.

Hinweis

Der iOS-Simulator unterstützt keine Remotebenachrichtigungen, sodass ein physisches Gerät erforderlich ist, wenn Sie dieses Beispiel unter iOS untersuchen. Sie müssen die App jedoch nicht sowohl unter Android als auch unter iOS ausführen, um dieses Tutorial abzuschließen.

Sie können die Schritte in diesem ersten Beispiel für Prinzipien ohne vorherige Erfahrung ausführen. Sie profitieren jedoch davon, dass Sie mit den folgenden Aspekten vertraut sind.

Wichtig

Die angegebenen Schritte gelten speziell für Visual Studio für Mac. Es ist möglich, die Verwendung von Visual Studio 2019 zu verfolgen, aber es gibt möglicherweise einige Unterschiede, die abgeglichen werden müssen. Beispielsweise Beschreibungen der Benutzeroberfläche und Workflows, Vorlagennamen, Umgebungskonfiguration usw.

Einrichten von Push Notification Services und Azure Notification Hub

In diesem Abschnitt richten Sie Firebase Cloud Messaging (FCM) und Apple Push Notification Services (APNS) ein. Anschließend erstellen und konfigurieren Sie einen Notification Hub für die Verwendung dieser Dienste.

Erstellen eines Firebase-Projekts und Aktivieren von Firebase Cloud Messaging für Android

Melden Sie sich bei der Firebase-Konsole an. Erstellen Sie ein neues Firebase-Projekt, indem Sie PushDemo als Projektnamen eingeben.

Hinweis

Ein eindeutiger Name wird für Sie generiert. Standardmäßig besteht dies aus einer Kleinbuchstabenvariante des angegebenen Namens sowie einer generierten Zahl, die durch einen Bindestrich getrennt ist. Sie können dies ändern, wenn Sie dies möchten, sofern sie weiterhin global eindeutig ist.
Nachdem Sie Ihr Projekt erstellt haben, wählen Sie Firebase zu Ihrer Android-App hinzufügen aus.
Führen Sie auf der Seite Firebase zu Ihrer Android-App hinzufügen die folgenden Schritte aus.
1. Geben Sie unter Android-Paketname einen Namen für Ihr Paket ein. Beispiel: com.<organization_identifier>.<package_name>.
2. Wählen Sie App registrieren aus.
3. Wählen Sie google-services.json herunterladen aus. Speichern Sie die Datei dann zur späteren Verwendung in einem lokalen Ordner, und wählen Sie Weiter aus.
4. Klicken Sie auf Weiter.
5. Wählen Sie Weiter zur Konsole aus.
  
  Hinweis
  
  Wenn die Schaltfläche Mit Konsole fortfahren aufgrund der Überprüfung der Installation nicht aktiviert ist, wählen Sie Diesen Schritt überspringen aus.
Wählen Sie in der Firebase-Konsole das Zahnrad für Ihr Projekt aus. Wählen Sie dann Projekteinstellungen aus.

Hinweis

Wenn Sie die google-services.json-Datei nicht heruntergeladen haben, können Sie sie auf dieser Seite herunterladen.
Wechseln Sie oben zur Registerkarte Cloud Messaging . Kopieren Und speichern Sie den Serverschlüssel zur späteren Verwendung. Sie verwenden diesen Wert, um Ihren Notification Hub zu konfigurieren.

Registrieren Ihrer iOS-App für Pushbenachrichtigungen

Um Pushbenachrichtigungen an eine iOS-App zu senden, registrieren Sie Ihre Anwendung bei Apple, und registrieren Sie sich auch für Pushbenachrichtigungen.

Wenn Sie Ihre App noch nicht registriert haben, navigieren Sie zum iOS-Bereitstellungsportal im Apple Developer Center. Melden Sie sich mit Ihrer Apple-ID beim Portal an, navigieren Sie zu Zertifikate, Bezeichner & Profile, und wählen Sie dann Bezeichner aus. Klicken Sie hier + , um eine neue App zu registrieren.
Wählen Sie auf dem Bildschirm Neuen Bezeichner registrieren das Optionsfeld App-IDs aus. Klicken Sie anschließend auf Weiter.
Aktualisieren Sie die folgenden drei Werte für Ihre neue App, und wählen Sie dann Weiter aus:
- Beschreibung: Geben Sie einen beschreibenden Namen für Ihre App ein.
- Bundle-ID: Geben Sie eine Bundle-ID im Format com.organization_identifier<> ein.<>product_name, wie im App-Verteilungshandbuch erwähnt. Im folgenden Screenshot wird der mobcat Wert als organization-Bezeichner und der PushDemo-Wert als Produktname verwendet.
- Pushbenachrichtigungen: Aktivieren Sie die Option Pushbenachrichtigungen im Abschnitt Funktionen .
  
  Diese Aktion generiert Ihre App-ID und fordert sie auf, die Informationen zu bestätigen. Wählen Sie Weiter und dann Registrieren aus, um die neue App-ID zu bestätigen.
  
  Nachdem Sie Registrieren ausgewählt haben, wird die neue App-ID als Zeilenelement auf der Seite Zertifikate, Bezeichner & Profile angezeigt .
Suchen Sie auf der Seite Zertifikate, Bezeichner & Profile unter Bezeichner das von Ihnen erstellte App-ID-Zeilenelement. Wählen Sie dann die zugehörige Zeile aus, um den Bildschirm App-ID-Konfiguration bearbeiten anzuzeigen.

Erstellen eines Zertifikats für Notification Hubs

Ein Zertifikat ist erforderlich, damit der Notification Hub mit Apple Push Notification Services (APNS) funktioniert, und es kann auf eine von zwei Arten bereitgestellt werden:

Erstellen eines p12-Pushzertifikats, das direkt in Notification Hub hochgeladen werden kann (der ursprüngliche Ansatz)
Erstellen eines p8-Zertifikats, das für die tokenbasierte Authentifizierung verwendet werden kann (der neuere und empfohlene Ansatz)

Der neuere Ansatz bietet eine Reihe von Vorteilen, wie in der tokenbasierten Authentifizierung (HTTP/2) für APNS dokumentiert. Es sind weniger Schritte erforderlich, aber auch für bestimmte Szenarien vorgeschrieben. Es wurden jedoch Schritte für beide Ansätze bereitgestellt, da beide für die Zwecke dieses Tutorials funktionieren.

OPTION 1: Erstellen eines p12-Pushzertifikats, das direkt in Notification Hub hochgeladen werden kann

Führen Sie auf Ihrem Mac das Keychain-Zugriffstool aus. Sie kann im Ordner Hilfsprogramme oder im Ordner Andere auf dem Launchpad geöffnet werden.
Wählen Sie Schlüsselbundzugriff aus, erweitern Sie Zertifikat-Assistent, und wählen Sie dann Zertifikat von einer Zertifizierungsstelle anfordern aus.

Hinweis

Standardmäßig wählt Keychain Access das erste Element in der Liste aus. Dies kann ein Problem sein, wenn Sie sich in der Kategorie Zertifikate befinden und die Apple Worldwide Developer Relations Certification Authority nicht das erste Element in der Liste ist. Stellen Sie sicher, dass Sie über ein Nicht-Schlüsselelement verfügen oder der Apple Worldwide Developer Relations-Zertifizierungsstelle-Schlüssel ausgewählt ist, bevor Sie die CSR (Certificate Signing Request) generieren.
Wählen Sie Ihren Benutzer Email Adresse aus, geben Sie Ihren Allgemeinen Namen ein, stellen Sie sicher, dass Sie Auf Datenträger gespeichert angeben, und wählen Sie dann Weiter aus. Lassen Sie ca Email Address leer, da dies nicht erforderlich ist.
Geben Sie unter Speichern unter einen Namen für die Zertifikatsignieranforderungsdatei (Certificate Signing Request, CSR) ein, wählen Sie den Speicherort unter Wo aus, und wählen Sie dann Speichern aus.

Mit dieser Aktion wird die CSR-Datei am ausgewählten Speicherort gespeichert. Der Standardspeicherort ist Desktop. Merken Sie sich den für die Datei ausgewählten Speicherort.
Scrollen Sie zurück auf der Seite Zertifikate, Bezeichner & Profile im iOS-Bereitstellungsportal nach unten zur aktivierten Option Pushbenachrichtigungen , und wählen Sie dann Konfigurieren aus, um das Zertifikat zu erstellen.
Das Fenster TLS/SSL-Zertifikate des Apple-Pushbenachrichtigungsdiensts wird angezeigt. Wählen Sie im Abschnitt Tls/SSL-Zertifikat der Entwicklung die Schaltfläche Zertifikat erstellen aus.

Der Bildschirm Neues Zertifikat erstellen wird angezeigt.

Hinweis

In diesem Tutorial wird ein Entwicklungszertifikat verwendet. Der gleiche Prozess wird beim Registrieren eines Produktionszertifikats verwendet. Stellen Sie sicher, dass Sie beim Senden von Benachrichtigungen den gleichen Zertifikattyp verwenden.
Wählen Sie Datei auswählen aus, navigieren Sie zu dem Speicherort, an dem Sie die CSR-Datei gespeichert haben, und doppelklicken Sie dann auf den Zertifikatnamen, um sie zu laden. Klicken Sie anschließend auf Weiter.
Nachdem das Portal das Zertifikat erstellt hat, wählen Sie die Schaltfläche Herunterladen aus. Speichern Sie das Zertifikat, und merken Sie sich den Speicherort, an dem es gespeichert ist.

Das Zertifikat wird heruntergeladen und auf Ihrem Computer im Ordner Downloads gespeichert.

Hinweis

Standardmäßig heißt das heruntergeladene Entwicklungszertifikat aps_development.cer.
Doppelklicken Sie auf das heruntergeladene Pushzertifikat aps_development.cer. Mit dieser Aktion wird das neue Zertifikat im Schlüsselbund installiert, wie in der folgenden Abbildung gezeigt:

Hinweis

Obwohl der Name in Ihrem Zertifikat möglicherweise anders ist, wird dem Namen das Präfix Apple Development iOS Push Services vorangestellt und der entsprechende Bundlebezeichner zugeordnet.
Klicken Sie unter Schlüsselbundzugriff, Steuerelement + Klicken Sie in der Kategorie Zertifikate auf das neue Pushzertifikat, das Sie erstellt haben. Wählen Sie Exportieren aus, benennen Sie die Datei, wählen Sie das p12-Format und dann Speichern aus.

Sie können das Zertifikat mit einem Kennwort schützen, aber ein Kennwort ist optional. Klicken Sie auf OK , wenn Sie die Kennworterstellung umgehen möchten. Notieren Sie sich den Dateinamen und den Speicherort des exportierten P12-Zertifikats. Sie werden verwendet, um die Authentifizierung mit APNs zu aktivieren.

Hinweis

Ihr P12-Dateiname und -Speicherort unterscheiden sich möglicherweise von den Abbildungen in diesem Tutorial.

OPTION 2: Erstellen eines P8-Zertifikats, das für die tokenbasierte Authentifizierung verwendet werden kann

Notieren Sie sich die folgenden Details:
- Präfix der App-ID (Team-ID)
- Bundle-ID
Klicken Sie zurück unter Zertifikate, Bezeichner & Profile auf Schlüssel.

Hinweis

Wenn Sie bereits einen Schlüssel für APNS konfiguriert haben, können Sie das p8-Zertifikat, das Sie direkt nach der Erstellung heruntergeladen haben, erneut verwenden. Wenn ja, können Sie die Schritte 3 bis 5 ignorieren.
Klicken Sie auf die + Schaltfläche (oder auf die Schaltfläche Schlüssel erstellen ), um einen neuen Schlüssel zu erstellen.
Geben Sie einen geeigneten Schlüsselnamenwert an, aktivieren Sie dann die Option Apple Push Notifications Service (APNS), und klicken Sie dann auf Weiter, gefolgt von Registrieren auf dem nächsten Bildschirm.
Klicken Sie auf Herunterladen , und verschieben Sie dann die P8-Datei (mit dem Präfix AuthKey_) in ein sicheres lokales Verzeichnis, und klicken Sie dann auf Fertig.

Hinweis

Stellen Sie sicher, dass Sie Ihre p8-Datei an einem sicheren Ort aufbewahren (und eine Sicherung speichern). Nach dem Herunterladen des Schlüssels kann er nicht erneut heruntergeladen werden, da die Serverkopie entfernt wird.
Klicken Sie unter Schlüssel auf den schlüssel, den Sie erstellt haben (oder auf einen vorhandenen Schlüssel, wenn Sie diesen stattdessen verwenden möchten).
Notieren Sie sich den Schlüssel-ID-Wert .
Öffnen Sie Ihr p8-Zertifikat in einer geeigneten Anwendung Ihrer Wahl, z. B . Visual Studio Code. Notieren Sie sich den Schlüsselwert (zwischen -----BEGIN PRIVATE KEY----- und -----END PRIVATE KEY-----).

-----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----

Hinweis

Dies ist der Tokenwert , der später zum Konfigurieren von Notification Hub verwendet wird.

Am Ende dieser Schritte sollten Sie die folgenden Informationen zur späteren Verwendung unter Konfigurieren Ihres Notification Hubs mit APNS-Informationen haben:

Team-ID (siehe Schritt 1)
Bundle-ID (siehe Schritt 1)
Schlüssel-ID (siehe Schritt 7)
Tokenwert (P8-Schlüsselwert, der in Schritt 8 abgerufen wurde)

Erstellen eines Bereitstellungsprofils für die App

Kehren Sie zum iOS-Bereitstellungsportal zurück, wählen Sie Zertifikate, Bezeichner & Profile aus, wählen Sie im linken Menü Profile aus, und wählen Sie + dann aus, um ein neues Profil zu erstellen. Der Bildschirm Neues Bereitstellungsprofil registrieren wird angezeigt.
Wählen Sie unter Entwicklung als Bereitstellungsprofiltyp die Option iOS-App-Entwicklung und dann Weiter aus.
Wählen Sie als Nächstes die app-ID aus, die Sie in der Dropdownliste App-ID erstellt haben, und wählen Sie Weiter aus.
Wählen Sie im Fenster Zertifikate auswählen das Entwicklungszertifikat aus, das Sie für die Codesignatur verwenden, und wählen Sie Weiter aus.

Hinweis

Dieses Zertifikat ist nicht das Pushzertifikat, das Sie im vorherigen Schritt erstellt haben. Dies ist Ihr Entwicklungszertifikat. Wenn keine vorhanden ist, müssen Sie sie erstellen, da dies eine Voraussetzung für dieses Tutorial ist. Entwicklerzertifikate können im Apple Developer Portal, über Xcode oder in Visual Studio erstellt werden.
Kehren Sie zur Seite Zertifikate, Bezeichner & Profile zurück, wählen Sie im linken Menü Profile aus, und wählen Sie + dann aus, um ein neues Profil zu erstellen. Der Bildschirm Neues Bereitstellungsprofil registrieren wird angezeigt.
Wählen Sie im Fenster Zertifikate auswählen das von Ihnen erstellte Entwicklungszertifikat aus. Klicken Sie anschließend auf Weiter.
Wählen Sie als Nächstes die Geräte aus, die zum Testen verwendet werden sollen, und wählen Sie Weiter aus.
Wählen Sie schließlich unter Name des Bereitstellungsprofils einen Namen für das Profil aus, und wählen Sie Generieren aus.
Wenn das neue Bereitstellungsprofil erstellt wird, wählen Sie Herunterladen aus. Merken Sie sich den Speicherort, an dem sie gespeichert wird.
Navigieren Sie zum Speicherort des Bereitstellungsprofils, und doppelklicken Sie darauf, um es auf Ihrem Entwicklungscomputer zu installieren.

Erstellen eines Notification Hubs

In diesem Abschnitt erstellen Sie einen Notification Hub und konfigurieren die Authentifizierung mit APNS. Sie können ein p12-Pushzertifikat oder eine tokenbasierte Authentifizierung verwenden. Wenn Sie einen bereits erstellten Notification Hub verwenden möchten, können Sie mit Schritt 5 fortfahren.

Melden Sie sich bei Azure an.
Klicken Sie auf Ressource erstellen, suchen Sie nach Notification Hub, und wählen Sie diese Option aus, und klicken Sie dann auf Erstellen.
Aktualisieren Sie die folgenden Felder, und klicken Sie dann auf Erstellen:

GRUNDLEGENDE DETAILS

Abonnement: Auswählen des Zielabonnements aus der Dropdownliste
Ressourcengruppe: Erstellen einer neuen Ressourcengruppe (oder Auswählen einer vorhandenen Ressourcengruppe)

NAMESPACEDETAILS

Notification Hub-Namespace: Geben Sie einen global eindeutigen Namen für den Notification Hub-Namespace ein.

Hinweis

Stellen Sie sicher, dass die Option Neu erstellen für dieses Feld ausgewählt ist.

NOTIFICATION HUB-DETAILS

Notification Hub: Geben Sie einen Namen für den Notification Hub ein.
Lage: Auswählen eines geeigneten Standorts aus der Dropdownliste
Tarif: Behalten Sie die Standardoption Free bei.

Hinweis

Es sei denn, Sie haben die maximale Anzahl von Hubs im Free-Tarif erreicht.
Nachdem der Notification Hub bereitgestellt wurde, navigieren Sie zu dieser Ressource.
Navigieren Sie zu Ihrem neuen Notification Hub.
Wählen Sie in der Liste Zugriffsrichtlinien aus (unter VERWALTEN).
Notieren Sie sich die Werte des Richtliniennamens zusammen mit den entsprechenden Verbindungszeichenfolgenwerten .

Konfigurieren Ihres Notification Hubs mit APNS-Informationen

Wählen Sie unter Notification Servicesdie Option Apple aus, und führen Sie dann die entsprechenden Schritte basierend auf dem Ansatz aus, den Sie zuvor im Abschnitt Erstellen eines Zertifikats für Notification Hubs ausgewählt haben.

Hinweis

Verwenden Sie den Produktionsmodus nur, wenn Sie Pushbenachrichtigungen an Benutzer senden möchten, die Ihre App im Store erworben haben.

OPTION 1: Verwenden eines P12-Pushzertifikats

Wählen Sie Certificateaus.
Wählen Sie das Dateisymbol aus.
Wählen Sie die P12-Datei aus, die Sie zuvor exportiert haben, und wählen Sie dann Öffnen aus.
Geben Sie bei Bedarf das richtige Kennwort an.
Wählen Sie den Modus Sandbox aus.
Wählen Sie Speichern aus.

OPTION 2: Verwenden der tokenbasierten Authentifizierung

Wählen Sie Token aus.
Geben Sie die folgenden Werte ein, die Sie zuvor erworben haben:
- Schlüssel-ID
- Bundle-ID
- Team-ID
- Token
Wählen Sie Sandbox aus.
Wählen Sie Speichern aus.

Konfigurieren Ihres Notification Hubs mit FCM-Informationen

Wählen Sie im linken Menü im Abschnitt Einstellungen die Option Google (GCM/FCM) aus.
Geben Sie den Serverschlüssel ein, den Sie sich in der Google Firebase-Konsole notiert haben.
Wählen Sie auf der Symbolleiste Speichern aus.

Erstellen einer ASP.NET Core Web-API-Back-End-Anwendung

In diesem Abschnitt erstellen Sie das ASP.NET Core Web-API-Back-End, um die Geräteregistrierung und das Senden von Benachrichtigungen an die mobile Xamarin.Forms-App zu verarbeiten.

Erstellen eines Webprojekts

Wählen Sie in Visual StudioDatei>Neue Projektmappe aus.
Wählen Sie .NETCore-App>>ASP.NET Core>API>Weiter aus.
Wählen Sie im Dialogfeld Neue ASP.NET Core Web-API konfigurierendie Option Zielframework von .NET Core 3.1 aus.
Geben Sie pushDemoApi als Projektname ein, und wählen Sie dann Erstellen aus.
Starten Sie das Debuggen (Eingabetaste), + um die app mit Vorlagen zu testen.
Hinweis

Die app mit Vorlagen ist so konfiguriert, dass der WeatherForecastController als launchUrl verwendet wird. Dies wird unter Eigenschaften>launchSettings.json festgelegt.

Wenn Sie zur Meldung Ungültiges Entwicklungszertifikat gefunden aufgefordert werden:
1. Klicken Sie auf Ja , um der Ausführung des Tools "dotnet dev-certs https" zuzustimmen, um dies zu beheben. Das Tool "dotnet dev-certs https" fordert Sie dann auf, ein Kennwort für das Zertifikat und das Kennwort für Ihren Keychain einzugeben.
2. Klicken Sie auf Ja , wenn Sie aufgefordert werden, das neue Zertifikat zu installieren und dem neuen Zertifikat zu vertrauen, und geben Sie dann das Kennwort für Ihren Schlüsselbund ein.
Erweitern Sie den Ordner Controller , und löschen Sie dann WeatherForecastController.cs.
Löschen Sie WeatherForecast.cs.
Richten Sie lokale Konfigurationswerte mit dem Geheimnis-Manager-Tool ein. Durch das Entkoppeln der Geheimnisse von der Lösung wird sichergestellt, dass sie nicht in der Quellcodeverwaltung landen. Öffnen Sie Terminal , wechseln Sie dann zum Verzeichnis der Projektdatei, und führen Sie die folgenden Befehle aus:
```
dotnet user-secrets init
dotnet user-secrets set "NotificationHub:Name" <value>
dotnet user-secrets set "NotificationHub:ConnectionString" <value>
```
Ersetzen Sie die Platzhalterwerte durch Ihren eigenen Notification Hub-Namen und Verbindungszeichenfolge Werte. Sie haben sich diese im Abschnitt Erstellen eines Notification Hubs notieren. Andernfalls können Sie sie in Azure nachschlagen.

NotificationHub:Name:
Weitere Informationen finden Sie unter Name in der Zusammenfassung der Grundlagen oben in der Übersicht.

NotificationHub:ConnectionString:
Weitere Informationen finden Sie unter DefaultFullSharedAccessSignature unter Zugriffsrichtlinien.

Hinweis

Für Produktionsszenarien können Sie Optionen wie Azure KeyVault anzeigen, um die Verbindungszeichenfolge sicher zu speichern. Der Einfachheit halber werden die Geheimnisse den Azure App Service Anwendungseinstellungen hinzugefügt.

Authentifizieren von Clients mithilfe eines API-Schlüssels (optional)

API-Schlüssel sind nicht so sicher wie Token, reichen aber für die Zwecke dieses Tutorials aus. Ein API-Schlüssel kann einfach über die ASP.NET Middleware konfiguriert werden.

Fügen Sie den lokalen Konfigurationswerten den API-Schlüssel hinzu.
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
Hinweis

Ersetzen Sie den Platzhalterwert durch Ihren eigenen Wert, und notieren Sie sich ihn.
Steuerung + Klicken Sie auf das Projekt PushDemoApi, wählen Sie im Menü Hinzufügen die Option Neuer Ordner aus, und klicken Sie dann auf Mithilfe der Authentifizierung als Ordnernamehinzufügen.
Steuerung + Klicken Sie auf den Ordner Authentifizierung, und wählen Sie dann im Menü Hinzufügen die Option Neue Datei... aus.

Wählen Sie Allgemein>Leere Klasse aus, geben Sie ApiKeyAuthOptions.cs als Name ein, und klicken Sie dann auf Neu , um die folgende Implementierung hinzuzufügen.

using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthOptions : AuthenticationSchemeOptions
    {
        public const string DefaultScheme = "ApiKey";
        public string Scheme => DefaultScheme;
        public string ApiKey { get; set; }
    }
}

Fügen Sie dem Authentifizierungsordnermit dem Namen ApiKeyAuthHandler.cs eine weitere leere Klasse hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Text.Encodings.Web;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthHandler : AuthenticationHandler<ApiKeyAuthOptions>
    {
        const string ApiKeyIdentifier = "apikey";

        public ApiKeyAuthHandler(
            IOptionsMonitor<ApiKeyAuthOptions> options,
            ILoggerFactory logger,
            UrlEncoder encoder,
            ISystemClock clock)
            : base(options, logger, encoder, clock) {}

        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
        {
            string key = string.Empty;

            if (Request.Headers[ApiKeyIdentifier].Any())
            {
                key = Request.Headers[ApiKeyIdentifier].FirstOrDefault();
            }
            else if (Request.Query.ContainsKey(ApiKeyIdentifier))
            {
                if (Request.Query.TryGetValue(ApiKeyIdentifier, out var queryKey))
                    key = queryKey;
            }

            if (string.IsNullOrWhiteSpace(key))
                return Task.FromResult(AuthenticateResult.Fail("No api key provided"));

            if (!string.Equals(key, Options.ApiKey, StringComparison.Ordinal))
                return Task.FromResult(AuthenticateResult.Fail("Invalid api key."));

            var identities = new List<ClaimsIdentity> {
                new ClaimsIdentity("ApiKeyIdentity")
            };

            var ticket = new AuthenticationTicket(
                new ClaimsPrincipal(identities), Options.Scheme);

            return Task.FromResult(AuthenticateResult.Success(ticket));
        }
    }
}

Hinweis

Ein Authentifizierungshandler ist ein Typ, der das Verhalten eines Schemas implementiert, in diesem Fall ein benutzerdefiniertes API-Schlüsselschema.

Fügen Sie dem Authentifizierungsordner mit dem Namen ApiKeyAuthenticationBuilderExtensions.cs eine weitere leere Klasse hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using System;
using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public static class AuthenticationBuilderExtensions
    {
        public static AuthenticationBuilder AddApiKeyAuth(
            this AuthenticationBuilder builder,
            Action<ApiKeyAuthOptions> configureOptions)
        {
            return builder
                .AddScheme<ApiKeyAuthOptions, ApiKeyAuthHandler>(
                    ApiKeyAuthOptions.DefaultScheme,
                    configureOptions);
        }
    }
}

Hinweis

Diese Erweiterungsmethode vereinfacht den Middlewarekonfigurationscode in Startup.cs macht ihn lesbarer und im Allgemeinen einfacher zu befolgen.

Aktualisieren Sie in Startup.cs die ConfigureServices-Methode , um die API-Schlüsselauthentifizierung unterhalb des Aufrufs der Dienste zu konfigurieren . AddControllers-Methode .

using PushDemoApi.Authentication;
using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = ApiKeyAuthOptions.DefaultScheme;
        options.DefaultChallengeScheme = ApiKeyAuthOptions.DefaultScheme;
    }).AddApiKeyAuth(Configuration.GetSection("Authentication").Bind);
}

Aktualisieren Sie noch in Startup.cs die Configure-Methode , um die Erweiterungsmethoden UseAuthentication und UseAuthorization für den IApplicationBuilder der App aufzurufen. Stellen Sie sicher, dass diese Methoden nach UseRouting und vor der App aufgerufen werden. UseEndpoints.
```
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();

    app.UseRouting();

    app.UseAuthentication();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}
```
Hinweis

Beim Aufrufen von UseAuthentication wird die Middleware registriert, die die zuvor registrierten Authentifizierungsschemas (von ConfigureServices) verwendet. Dies muss vor jeder Middleware aufgerufen werden, die von der Authentifizierung der Benutzer abhängt.

Hinzufügen von Abhängigkeiten und Konfigurieren von Diensten

ASP.NET Core unterstützt das Di-Softwareentwurfsmuster (Dependency Injection), ein Verfahren zum Erreichen der Inversion der Steuerung (Inversion of Control, IoC) zwischen Klassen und ihren Abhängigkeiten.

Die Verwendung des Notification Hubs und des Notification Hubs SDK für Back-End-Vorgänge wird in einem Dienst gekapselt. Der Dienst wird registriert und durch eine geeignete Abstraktion zur Verfügung gestellt.

Steuerung + Klicken Sie auf den Ordner Abhängigkeiten , und wählen Sie NuGet-Pakete verwalten... aus.
Suchen Sie nach Microsoft.Azure.NotificationHubs , und stellen Sie sicher, dass es aktiviert ist.
Klicken Sie auf Pakete hinzufügen und dann auf Akzeptieren , wenn Sie aufgefordert werden, die Lizenzbedingungen zu akzeptieren.
Steuerung + Klicken Sie auf das Projekt PushDemoApi, wählen Sie im Menü Hinzufügen die Option Neuer Ordner aus, und klicken Sie dann auf Mithilfe von Modellen als Ordnernamehinzufügen.
Steuerung + Klicken Sie auf den Ordner Modelle, und wählen Sie dann im Menü Hinzufügendie Option Neue Datei... aus.

Wählen Sie Allgemein>Leere Klasse aus, geben Sie als NamePushTemplates.cs ein, und klicken Sie dann auf Neu, um die folgende Implementierung hinzuzufügen.

namespace PushDemoApi.Models
{
    public class PushTemplates
    {
        public class Generic
        {
            public const string Android = "{ \"notification\": { \"title\" : \"PushDemo\", \"body\" : \"$(alertMessage)\"}, \"data\" : { \"action\" : \"$(alertAction)\" } }";
            public const string iOS = "{ \"aps\" : {\"alert\" : \"$(alertMessage)\"}, \"action\" : \"$(alertAction)\" }";
        }

        public class Silent
        {
            public const string Android = "{ \"data\" : {\"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\"} }";
            public const string iOS = "{ \"aps\" : {\"content-available\" : 1, \"apns-priority\": 5, \"sound\" : \"\", \"badge\" : 0}, \"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\" }";
        }
    }
}

Hinweis

Diese Klasse enthält die tokenisierten Benachrichtigungsnutzlasten für die generischen und unbeaufsichtigten Benachrichtigungen, die für dieses Szenario erforderlich sind. Die Nutzlasten werden außerhalb der Installation definiert, um Experimente zu ermöglichen, ohne vorhandene Installationen über den Dienst aktualisieren zu müssen. Die Verarbeitung von Änderungen an Installationen auf diese Weise ist für dieses Tutorial nicht vorgesehen. Für die Produktion sollten Sie benutzerdefinierte Vorlagen berücksichtigen.

Fügen Sie dem Ordner Models mit dem Namen DeviceInstallation.cs eine weitere leere Klasse hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class DeviceInstallation
    {
        [Required]
        public string InstallationId { get; set; }

        [Required]
        public string Platform { get; set; }

        [Required]
        public string PushChannel { get; set; }

        public IList<string> Tags { get; set; } = Array.Empty<string>();
    }
}

Fügen Sie dem Ordner Models mit dem Namen NotificationRequest.cs eine weitere leere Klasse hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using System;

namespace PushDemoApi.Models
{
    public class NotificationRequest
    {
        public string Text { get; set; }
        public string Action { get; set; }
        public string[] Tags { get; set; } = Array.Empty<string>();
        public bool Silent { get; set; }
    }
}

Fügen Sie dem Ordner Models mit dem Namen NotificationHubOptions.cs eine weitere leere Klasse hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class NotificationHubOptions
    {
        [Required]
        public string Name { get; set; }

        [Required]
        public string ConnectionString { get; set; }
    }
}

Fügen Sie dem PushDemoApi-Projekt einen neuen Ordner mit dem Namen Services hinzu.

Fügen Sie dem Ordner Dienste eine leere Schnittstelle mit dem Namen INotificationService.cs hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using System.Threading;
using System.Threading.Tasks;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public interface INotificationService
    {
        Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token);
        Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token);
        Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token);
    }
}

Fügen Sie dem Ordner Services eine leere Klasse mit dem Namen NotificationHubsService.cs hinzu, und fügen Sie dann den folgenden Code hinzu, um die INotificationService-Schnittstelle zu implementieren:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public class NotificationHubService : INotificationService
    {
        readonly NotificationHubClient _hub;
        readonly Dictionary<string, NotificationPlatform> _installationPlatform;
        readonly ILogger<NotificationHubService> _logger;

        public NotificationHubService(IOptions<NotificationHubOptions> options, ILogger<NotificationHubService> logger)
        {
            _logger = logger;
            _hub = NotificationHubClient.CreateClientFromConnectionString(
                options.Value.ConnectionString,
                options.Value.Name);

            _installationPlatform = new Dictionary<string, NotificationPlatform>
            {
                { nameof(NotificationPlatform.Apns).ToLower(), NotificationPlatform.Apns },
                { nameof(NotificationPlatform.Fcm).ToLower(), NotificationPlatform.Fcm }
            };
        }

        public async Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(deviceInstallation?.InstallationId) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.Platform) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.PushChannel))
                return false;

            var installation = new Installation()
            {
                InstallationId = deviceInstallation.InstallationId,
                PushChannel = deviceInstallation.PushChannel,
                Tags = deviceInstallation.Tags
            };

            if (_installationPlatform.TryGetValue(deviceInstallation.Platform, out var platform))
                installation.Platform = platform;
            else
                return false;

            try
            {
                await _hub.CreateOrUpdateInstallationAsync(installation, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(installationId))
                return false;

            try
            {
                await _hub.DeleteInstallationAsync(installationId, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token)
        {
            if ((notificationRequest.Silent &&
                string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
                (!notificationRequest.Silent &&
                (string.IsNullOrWhiteSpace(notificationRequest?.Text)) ||
                string.IsNullOrWhiteSpace(notificationRequest?.Action)))
                return false;

            var androidPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.Android :
                PushTemplates.Generic.Android;

            var iOSPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.iOS :
                PushTemplates.Generic.iOS;

            var androidPayload = PrepareNotificationPayload(
                androidPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            var iOSPayload = PrepareNotificationPayload(
                iOSPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            try
            {
                if (notificationRequest.Tags.Length == 0)
                {
                    // This will broadcast to all users registered in the notification hub
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, token);
                }
                else if (notificationRequest.Tags.Length <= 20)
                {
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, notificationRequest.Tags, token);
                }
                else
                {
                    var notificationTasks = notificationRequest.Tags
                        .Select((value, index) => (value, index))
                        .GroupBy(g => g.index / 20, i => i.value)
                        .Select(tags => SendPlatformNotificationsAsync(androidPayload, iOSPayload, tags, token));

                    await Task.WhenAll(notificationTasks);
                }

                return true;
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Unexpected error sending notification");
                return false;
            }
        }

        string PrepareNotificationPayload(string template, string text, string action) => template
            .Replace("$(alertMessage)", text, StringComparison.InvariantCulture)
            .Replace("$(alertAction)", action, StringComparison.InvariantCulture);

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, token)
            };

            return Task.WhenAll(sendTasks);
        }

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, IEnumerable<string> tags, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, tags, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, tags, token)
            };

            return Task.WhenAll(sendTasks);
        }
    }
}

Hinweis

Der für SendTemplateNotificationAsync bereitgestellte Tagausdruck ist auf 20 Tags beschränkt. Er ist für die meisten Operatoren auf 6 beschränkt, aber der Ausdruck enthält in diesem Fall nur ORs (||). Wenn die Anforderung mehr als 20 Tags enthält, müssen sie in mehrere Anforderungen unterteilt werden. Weitere Informationen finden Sie in der Dokumentation zu Routing- und Tagausdrücken .

Aktualisieren Sie in Startup.cs die ConfigureServices-Methode , um NotificationHubsService als Singletonimplementierung von INotificationService hinzuzufügen.


using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddSingleton<INotificationService, NotificationHubService>();

    services.AddOptions<NotificationHubOptions>()
        .Configure(Configuration.GetSection("NotificationHub").Bind)
        .ValidateDataAnnotations();
}

Erstellen der Benachrichtigungs-API

Steuerung + Klicken Sie auf den Ordner Controller, und wählen Sie dann Im Menü Hinzufügen die Option Neue Datei... aus.
Wählen Sie ASP.NET Core>Web-API-Controller-Klasse aus, geben Sie NotificationsController als Namen ein, und klicken Sie dann auf Neu.

Hinweis

Wenn Sie visual Studio 2019 verwenden, wählen Sie die Api Controller-Vorlage mit Lese-/Schreibaktionen aus.

Fügen Sie die folgenden Namespaces am Anfang der Datei hinzu.

using System.ComponentModel.DataAnnotations;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PushDemoApi.Models;
using PushDemoApi.Services;

Aktualisieren Sie den vorlagenbasierten Controller so, dass er von ControllerBase abgeleitet wird und mit dem ApiController-Attribut versehen ist.
```
[ApiController]
[Route("api/[controller]")]
public class NotificationsController : ControllerBase
{
    // Templated methods here
}
```
Hinweis

Die Controller-Basisklasse bietet Unterstützung für Ansichten, dies ist in diesem Fall jedoch nicht erforderlich, sodass stattdessen ControllerBase verwendet werden kann. Wenn Sie visual Studio 2019 verwenden, können Sie diesen Schritt überspringen.
Wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben, sollten Sie auch den NotificationsController mit dem Attribut Authorize versehen.
```
[Authorize]
```

Aktualisieren Sie den Konstruktor, um die registrierte instance von INotificationService als Argument zu akzeptieren, und weisen Sie es einem schreibgeschützten Member zu.

readonly INotificationService _notificationService;

public NotificationsController(INotificationService notificationService)
{
    _notificationService = notificationService;
}

Ändern Sie in launchSettings.json (im Ordner Eigenschaften ) die launchUrl von in weatherforecastapi/notifications , um der URL zu entsprechen, die im Attribut "RegistrationsControllerRoute " angegeben ist.
Starten Sie das Debuggen (Befehlseingabe + ), um zu überprüfen, ob die App mit dem neuen NotificationsController funktioniert, und gibt einen nicht autorisierten status 401 zurück.

Hinweis

Visual Studio startet die App möglicherweise nicht automatisch im Browser. Ab diesem Zeitpunkt verwenden Sie Postman , um die API zu testen.
Legen Sie auf einer neuen Postman-Registerkarte die Anforderung auf GET fest. Geben Sie die folgende Adresse ein, und ersetzen Sie den Platzhalter <applicationUrl> durch den https applicationUrl in Properties>launchSettings.json.
```
<applicationUrl>/api/notifications
```
Hinweis

ApplicationUrl sollte für das Standardprofil "https://localhost:5001" sein. Wenn Sie IIS verwenden (Standard in Visual Studio 2019 unter Windows), sollten Sie stattdessen die im element iisSettings angegebene applicationUrl verwenden. Sie erhalten eine Antwort 404, wenn die Adresse falsch ist.
Wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben, müssen Sie die Anforderungsheader so konfigurieren, dass sie Ihren apikey-Wert enthalten.

Schlüssel Wert

apikey <your_api_key>
Klicken Sie auf die Schaltfläche Senden .

Hinweis

Sie sollten eine 200 OK-status mit JSON-Inhalten erhalten.

Wenn Sie eine SSL-Zertifikatüberprüfungswarnung erhalten, können Sie die Postman-Einstellung SSL-Zertifikatüberprüfung der Anforderung in den Einstellungen deaktivieren.

Schlüssel	Wert
apikey	<your_api_key>

Ersetzen Sie die vorlagenbasierten Klassenmethoden in NotificationsController.cs durch den folgenden Code.

[HttpPut]
[Route("installations")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> UpdateInstallation(
    [Required]DeviceInstallation deviceInstallation)
{
    var success = await _notificationService
        .CreateOrUpdateInstallationAsync(deviceInstallation, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpDelete()]
[Route("installations/{installationId}")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<ActionResult> DeleteInstallation(
    [Required][FromRoute]string installationId)
{
    var success = await _notificationService
        .DeleteInstallationByIdAsync(installationId, CancellationToken.None);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpPost]
[Route("requests")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> RequestPush(
    [Required]NotificationRequest notificationRequest)
{
    if ((notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
        (!notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Text)))
        return new BadRequestResult();

    var success = await _notificationService
        .RequestNotificationAsync(notificationRequest, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

Erstellen der API-App

Sie erstellen jetzt eine API-App in Azure App Service zum Hosten des Back-End-Diensts.

Melden Sie sich beim Azure-Portal an.
Klicken Sie auf Ressource erstellen, suchen Sie nach API-App, und wählen Sie sie aus, und klicken Sie dann auf Erstellen.
Aktualisieren Sie die folgenden Felder, und klicken Sie dann auf Erstellen.

App-Name:
Geben Sie einen global eindeutigen Namen für die API-App ein.

Abonnement:
Wählen Sie dasselbe Zielabonnement aus, in dem Sie den Notification Hub erstellt haben.

Ressourcengruppe:
Wählen Sie dieselbe Ressourcengruppe aus, in der Sie den Notification Hub erstellt haben.

App Service Plan/Standort:
Erstellen eines neuen App Service Plans

Hinweis

Ändern Sie von der Standardoption zu einem Plan, der SSL-Unterstützung enthält. Andernfalls müssen Sie beim Arbeiten mit der mobilen App die entsprechenden Schritte unternehmen, um zu verhindern , dass HTTP-Anforderungen blockiert werden.

Application Insights:
Behalten Sie die vorgeschlagene Option bei (eine neue Ressource wird mit diesem Namen erstellt), oder wählen Sie eine vorhandene Ressource aus.
Navigieren Sie nach der Bereitstellung der API-App zu dieser Ressource.
Notieren Sie sich die URL-Eigenschaft in der Zusammenfassung der Grundlagen oben in der Übersicht. Diese URL ist Ihr Back-End-Endpunkt , der später in diesem Tutorial verwendet wird.

Hinweis

Die URL verwendet den zuvor angegebenen API-App-Namen im Format https://<app_name>.azurewebsites.net.
Wählen Sie in der Liste (unter Einstellungen) die Option Konfiguration aus.
Klicken Sie für jede der folgenden Einstellungen auf Neue Anwendungseinstellung , um den Namen und einen Wert einzugeben, und klicken Sie dann auf OK.

NAME Wert

Authentication:ApiKey <api_key_value>

NotificationHub:Name <hub_name_value>

NotificationHub:ConnectionString <hub_connection_string_value>

Hinweis

Dies sind dieselben Einstellungen, die Sie zuvor in den Benutzereinstellungen definiert haben. Sie sollten in der Lage sein, diese zu kopieren. Die Einstellung Authentication:ApiKey ist nur erforderlich, wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben. Für Produktionsszenarien können Sie Optionen wie Azure KeyVault anzeigen. Diese wurden der Einfachheit halber in diesem Fall als Anwendungseinstellungen hinzugefügt.
Nachdem alle Anwendungseinstellungen hinzugefügt wurden, klicken Sie auf Speichern und dann auf Weiter.

NAME	Wert
`Authentication:ApiKey`	<api_key_value>
`NotificationHub:Name`	<hub_name_value>
`NotificationHub:ConnectionString`	<hub_connection_string_value>

Veröffentlichen des Back-End-Diensts

Als Nächstes stellen Sie die App in der API-App bereit, damit sie von allen Geräten aus zugänglich ist.

Hinweis

Die folgenden Schritte sind spezifisch für Visual Studio für Mac. Wenn Sie Visual Studio 2019 unter Windows verwenden, unterscheidet sich der Veröffentlichungsablauf. Weitere Informationen finden Sie unter Veröffentlichen in Azure App Service unter Windows.

Ändern Sie Ihre Konfiguration von Debuggen in Release , wenn Sie dies noch nicht getan haben.
Steuerung + Klicken Sie auf das Projekt PushDemoApi, und wählen Sie dann im Menü Veröffentlichen die Option In Azure veröffentlichen... aus.
Befolgen Sie den Authentifizierungsflow, wenn Sie dazu aufgefordert werden. Verwenden Sie das Konto, das Sie im vorherigen Erstellen des Abschnitts API-App verwendet haben.
Wählen Sie die Azure App Service API-App, die Sie zuvor erstellt haben, aus der Liste als Veröffentlichungsziel aus, und klicken Sie dann auf Veröffentlichen.

Nachdem Sie den Assistenten abgeschlossen haben, veröffentlicht er die App in Azure und öffnet dann die App. Notieren Sie sich die URL , falls Sie dies noch nicht getan haben. Diese URL ist Ihr Back-End-Endpunkt , der später in diesem Tutorial verwendet wird.

Überprüfen der veröffentlichten API

Öffnen Sie in Postman eine neue Registerkarte, legen Sie die Anforderung auf PUT fest, und geben Sie die folgende Adresse ein. Ersetzen Sie den Platzhalter durch die Basisadresse, die Sie im vorherigen Abschnitt zum Veröffentlichen des Back-End-Diensts notieren haben.
```
https://<app_name>.azurewebsites.net/api/notifications/installations
```
Hinweis

Die Basisadresse sollte das Format aufweisen. https://<app_name>.azurewebsites.net/
Wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben, müssen Sie die Anforderungsheader so konfigurieren, dass sie Ihren apikey-Wert enthalten.

Schlüssel Wert

apikey <your_api_key>
Wählen Sie die Raw-Option für den Text aus, wählen Sie dann JSON aus der Liste der Formatoptionen aus, und fügen Sie dann einige Platzhalter-JSON-Inhalte ein:
```
{}
```
Klicken Sie auf Send.

Hinweis

Sie sollten eine 422 UnprocessableEntity-status vom Dienst erhalten.
Führen Sie die Schritte 1 bis 4 erneut aus, aber geben Sie diesmal den Anforderungsendpunkt an, um zu überprüfen, dass Sie eine Antwort mit 400 fehlerhaften Anforderungen erhalten.
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```

Schlüssel	Wert
apikey	<your_api_key>

Hinweis

Es ist noch nicht möglich, die API mit gültigen Anforderungsdaten zu testen, da dies plattformspezifische Informationen aus der mobilen Client-App erfordert.

Erstellen einer plattformübergreifenden Xamarin.Forms-Anwendung

In diesem Abschnitt erstellen Sie eine mobile Xamarin.Forms-Anwendung , die Pushbenachrichtigungen plattformübergreifend implementiert.

Sie können sich über den von Ihnen erstellten Back-End-Dienst bei einem Notification Hub registrieren und die Registrierung aufheben.

Eine Warnung wird angezeigt, wenn eine Aktion angegeben wird und sich die App im Vordergrund befindet. Andernfalls werden Benachrichtigungen im Notification Center angezeigt.

Hinweis

In der Regel führen Sie die Registrierungsaktionen (und die Registrierung aufheben) während des entsprechenden Punkts im Anwendungslebenszyklus (oder vielleicht als Teil Ihrer Ersten Ausführung) ohne explizite Benutzerregistrierungs-/Deregistrierungseingaben aus. Dieses Beispiel erfordert jedoch eine explizite Benutzereingabe, damit diese Funktionalität leichter untersucht und getestet werden kann.

Erstellen der Xamarin.Forms-Lösung

Erstellen Sie in Visual Studio eine neue Xamarin.Forms-Projektmappe , indem Sie leere Formular-App als Vorlage verwenden, und geben Sie PushDemo als Projektname ein.

Hinweis

Stellen Sie im Dialogfeld Leere Formular-App konfigurieren sicher, dass der Organisationsbezeichner dem zuvor verwendeten Wert entspricht und dass sowohl Android - als auch iOS-Ziele aktiviert sind.
Steuerung + Klicken Sie auf die PushDemo-Lösung , und wählen Sie NuGet-Pakete aktualisieren aus.
Steuerung + Klicken Sie auf die PushDemo-Lösung , und wählen Sie dann NuGet-Pakete verwalten aus.
Suchen Sie nach Newtonsoft.Json , und stellen Sie sicher, dass es aktiviert ist.
Klicken Sie auf Pakete hinzufügen und dann auf Akzeptieren , wenn Sie aufgefordert werden, die Lizenzbedingungen zu akzeptieren.
Erstellen und ausführen Sie die App auf jeder Zielplattform (Befehlseingabe + ), um die App-Ausführung in Vorlagen auf Ihrem(n) Gerät(n) zu testen.

Implementieren der plattformübergreifenden Komponenten

Steuerung + Klicken Sie auf das Projekt PushDemo, wählen Sie im Menü Hinzufügen die Option Neuer Ordner aus, und klicken Sie dann auf Mithilfe von Modellen als Ordnernamehinzufügen.
Steuerung + Klicken Sie auf den Ordner Modelle, und wählen Sie dann im Menü Hinzufügendie Option Neue Datei... aus.

Wählen Sie Allgemeine>leere Klasse aus, geben Sie DeviceInstallation.cs ein, und fügen Sie dann die folgende Implementierung hinzu.

using System.Collections.Generic;
using Newtonsoft.Json;

namespace PushDemo.Models
{
    public class DeviceInstallation
    {
        [JsonProperty("installationId")]
        public string InstallationId { get; set; }

        [JsonProperty("platform")]
        public string Platform { get; set; }

        [JsonProperty("pushChannel")]
        public string PushChannel { get; set; }

        [JsonProperty("tags")]
        public List<string> Tags { get; set; } = new List<string>();
    }
}

Fügen Sie dem Ordner Models mit dem Namen PushDemoAction.cs mit der folgenden Implementierung eine leere Enumeration hinzu.
```
namespace PushDemo.Models
{
    public enum PushDemoAction
    {
        ActionA,
        ActionB
    }
}
```

Fügen Sie dem PushDemo-Projekt einen neuen Ordner namens Services hinzu, und fügen Sie dann eine leere Klasse mit dem Namen ServiceContainer.cs mit der folgenden Implementierung hinzu.

using System;
using System.Collections.Generic;

namespace PushDemo.Services
{
   public static class ServiceContainer
   {
       static readonly Dictionary<Type, Lazy<object>> services
           = new Dictionary<Type, Lazy<object>>();

       public static void Register<T>(Func<T> function)
           => services[typeof(T)] = new Lazy<object>(() => function());

       public static T Resolve<T>()
           => (T)Resolve(typeof(T));

       public static object Resolve(Type type)
       {
           {
               if (services.TryGetValue(type, out var service))
                   return service.Value;

               throw new KeyNotFoundException($"Service not found for type '{type}'");
           }
       }
   }
}

Hinweis

Dies ist eine gekürzte Version der ServiceContainer-Klasse aus dem XamCAT-Repository . Er wird als leichter IoC-Container (Inversion of Control) verwendet.

Fügen Sie dem Ordner Dienste eine leere Schnittstelle mit dem Namen IDeviceInstallationService.cs hinzu, und fügen Sie dann den folgenden Code hinzu.
```
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IDeviceInstallationService
    {
        string Token { get; set; }
        bool NotificationsSupported { get; }
        string GetDeviceId();
        DeviceInstallation GetDeviceInstallation(params string[] tags);
    }
}
```
Hinweis

Diese Schnittstelle wird später von jedem Ziel implementiert und gestartet, um die plattformspezifischen Funktionen und Geräteinstallationsinformationen bereitzustellen, die vom Back-End-Dienst benötigt werden.

Fügen Sie dem Ordner Dienste eine weitere leere Schnittstelle mit dem Namen INotificationRegistrationService.cs hinzu, und fügen Sie dann den folgenden Code hinzu.

using System.Threading.Tasks;

namespace PushDemo.Services
{
    public interface INotificationRegistrationService
    {
        Task DeregisterDeviceAsync();
        Task RegisterDeviceAsync(params string[] tags);
        Task RefreshRegistrationAsync();
    }
}

Hinweis

Dadurch wird die Interaktion zwischen dem Client und dem Back-End-Dienst verarbeitet.

Fügen Sie dem Ordner Dienste eine weitere leere Schnittstelle namens INotificationActionService.cs hinzu, und fügen Sie dann den folgenden Code hinzu.
```
namespace PushDemo.Services
{
    public interface INotificationActionService
    {
        void TriggerAction(string action);
    }
}
```
Hinweis

Dies wird als einfacher Mechanismus verwendet, um die Behandlung von Benachrichtigungsaktionen zu zentralisieren.
Fügen Sie dem Ordner Services eine leere Schnittstelle namens IPushDemoNotificationActionService.cs hinzu, die von INotificationActionService abgeleitet ist, mit der folgenden Implementierung.
```
using System;
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IPushDemoNotificationActionService : INotificationActionService
    {
        event EventHandler<PushDemoAction> ActionTriggered;
    }
}
```
Hinweis

Dieser Typ ist spezifisch für die PushDemo-Anwendung und verwendet die PushDemoAction-Enumeration , um die Aktion zu identifizieren, die stark typisiert ausgelöst wird.

Fügen Sie dem Ordner Services eine leere Klasse mit dem Namen NotificationRegistrationService.cs Implementieren von INotificationRegistrationService mit dem folgenden Code hinzu.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using PushDemo.Models;
using Xamarin.Essentials;

namespace PushDemo.Services
{
    public class NotificationRegistrationService : INotificationRegistrationService
    {
        const string RequestUrl = "api/notifications/installations";
        const string CachedDeviceTokenKey = "cached_device_token";
        const string CachedTagsKey = "cached_tags";

        string _baseApiUrl;
        HttpClient _client;
        IDeviceInstallationService _deviceInstallationService;

        public NotificationRegistrationService(string baseApiUri, string apiKey)
        {
            _client = new HttpClient();
            _client.DefaultRequestHeaders.Add("Accept", "application/json");
            _client.DefaultRequestHeaders.Add("apikey", apiKey);

            _baseApiUrl = baseApiUri;
        }

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService = ServiceContainer.Resolve<IDeviceInstallationService>());

        public async Task DeregisterDeviceAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            if (cachedToken == null)
                return;

            var deviceId = DeviceInstallationService?.GetDeviceId();

            if (string.IsNullOrWhiteSpace(deviceId))
                throw new Exception("Unable to resolve an ID for the device.");

            await SendAsync(HttpMethod.Delete, $"{RequestUrl}/{deviceId}")
                .ConfigureAwait(false);

            SecureStorage.Remove(CachedDeviceTokenKey);
            SecureStorage.Remove(CachedTagsKey);
        }

        public async Task RegisterDeviceAsync(params string[] tags)
        {
            var deviceInstallation = DeviceInstallationService?.GetDeviceInstallation(tags);

            await SendAsync<DeviceInstallation>(HttpMethod.Put, RequestUrl, deviceInstallation)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedDeviceTokenKey, deviceInstallation.PushChannel)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedTagsKey, JsonConvert.SerializeObject(tags));
        }

        public async Task RefreshRegistrationAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            var serializedTags = await SecureStorage.GetAsync(CachedTagsKey)
                .ConfigureAwait(false);

            if (string.IsNullOrWhiteSpace(cachedToken) ||
                string.IsNullOrWhiteSpace(serializedTags) ||
                string.IsNullOrWhiteSpace(DeviceInstallationService.Token) ||
                cachedToken == DeviceInstallationService.Token)
                return;

            var tags = JsonConvert.DeserializeObject<string[]>(serializedTags);

            await RegisterDeviceAsync(tags);
        }

        async Task SendAsync<T>(HttpMethod requestType, string requestUri, T obj)
        {
            string serializedContent = null;

            await Task.Run(() => serializedContent = JsonConvert.SerializeObject(obj))
                .ConfigureAwait(false);

            await SendAsync(requestType, requestUri, serializedContent);
        }

        async Task SendAsync(
            HttpMethod requestType,
            string requestUri,
            string jsonRequest = null)
        {
            var request = new HttpRequestMessage(requestType, new Uri($"{_baseApiUrl}{requestUri}"));

            if (jsonRequest != null)
                request.Content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");

            var response = await _client.SendAsync(request).ConfigureAwait(false);

            response.EnsureSuccessStatusCode();
        }
    }
}

Hinweis

Das apiKey-Argument ist nur erforderlich, wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben.

Fügen Sie dem Ordner Services eine leere Klasse mit dem Namen PushDemoNotificationActionService.cs Implementieren des IPushDemoNotificationActionService mit dem folgenden Code hinzu.

using System;
using System.Collections.Generic;
using System.Linq;
using PushDemo.Models;

namespace PushDemo.Services
{
    public class PushDemoNotificationActionService : IPushDemoNotificationActionService
    {
        readonly Dictionary<string, PushDemoAction> _actionMappings = new Dictionary<string, PushDemoAction>
        {
            { "action_a", PushDemoAction.ActionA },
            { "action_b", PushDemoAction.ActionB }
        };

        public event EventHandler<PushDemoAction> ActionTriggered = delegate { };

        public void TriggerAction(string action)
        {
            if (!_actionMappings.TryGetValue(action, out var pushDemoAction))
                return;

            List<Exception> exceptions = new List<Exception>();

            foreach (var handler in ActionTriggered?.GetInvocationList())
            {
                try
                {
                    handler.DynamicInvoke(this, pushDemoAction);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Any())
                throw new AggregateException(exceptions);
        }
    }
}

Fügen Sie dem PushDemo-Projekt mit dem Namen Config.cs mit der folgenden Implementierung eine leere Klasse hinzu.
```
namespace PushDemo
{
    public static partial class Config
    {
        public static string ApiKey = "API_KEY";
        public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
    }
}
```
Hinweis

Dies wird als einfache Möglichkeit verwendet, Geheimnisse aus der Quellcodeverwaltung herauszuhalten. Sie können diese Werte als Teil eines automatisierten Builds ersetzen oder sie mithilfe einer lokalen partiellen Klasse überschreiben. Dies geschieht im nächsten Schritt.

Das Feld ApiKey ist nur erforderlich, wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben.
Fügen Sie dem PushDemo-Projekt dieses Mal eine weitere leere Klasse mit dem Namen Config.local_secrets.cs mit der folgenden Implementierung hinzu.
```
namespace PushDemo
{
    public static partial class Config
    {
        static Config()
        {
            ApiKey = "<your_api_key>";
            BackendServiceEndpoint = "<your_api_app_url>";
        }
    }
}
```
Hinweis

Ersetzen Sie die Platzhalterwerte durch Ihre eigenen Werte. Sie sollten sich diese beim Erstellen des Back-End-Diensts notieren. Die API-App-URL sollte sein https://<api_app_name>.azurewebsites.net/. Denken Sie daran, Ihrer gitignore-Datei hinzuzufügen *.local_secrets.* , um ein Commit für diese Datei zu vermeiden.

Das Feld ApiKey ist nur erforderlich, wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels abgeschlossen haben.

Fügen Sie dem PushDemo-Projekt eine leere Klasse mit dem Namen Bootstrap.cs mit der folgenden Implementierung hinzu.

using System;
using PushDemo.Services;

namespace PushDemo
{
    public static class Bootstrap
    {
        public static void Begin(Func<IDeviceInstallationService> deviceInstallationService)
        {
            ServiceContainer.Register(deviceInstallationService);

            ServiceContainer.Register<IPushDemoNotificationActionService>(()
                => new PushDemoNotificationActionService());

            ServiceContainer.Register<INotificationRegistrationService>(()
                => new NotificationRegistrationService(
                    Config.BackendServiceEndpoint,
                    Config.ApiKey));
        }
    }
}

Hinweis

Die Begin-Methode wird von jeder Plattform aufgerufen, wenn die App gestartet wird, indem eine plattformspezifische Implementierung von IDeviceInstallationService übergeben wird.

Das ApiKey-Konstruktorargument NotificationRegistrationService ist nur erforderlich, wenn Sie den Abschnitt Clients mithilfe eines API-Schlüssels authentifizieren abgeschlossen haben.

Implementieren der plattformübergreifenden Benutzeroberfläche

Öffnen Sie im PushDemo-ProjektMainPage.xaml , und ersetzen Sie das StackLayout-Steuerelement durch Folgendes.

<StackLayout VerticalOptions="EndAndExpand"  
             HorizontalOptions="FillAndExpand"
             Padding="20,40">
    <Button x:Name="RegisterButton"
            Text="Register"
            Clicked="RegisterButtonClicked" />
    <Button x:Name="DeregisterButton"
            Text="Deregister"
            Clicked="DeregisterButtonClicked" />
</StackLayout>

Fügen Sie nun in MainPage.xaml.cs ein schreibgeschütztes Hintergrundfeld hinzu, um einen Verweis auf die INotificationRegistrationService-Implementierung zu speichern.
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
Lösen Sie im MainPage-Konstruktor die INotificationRegistrationService-Implementierung mithilfe des ServiceContainers auf, und weisen Sie sie dem Sicherungsfeld notificationRegistrationService zu.
```
public MainPage()
{
    InitializeComponent();

    _notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>();
}
```

Implementieren Sie die Ereignishandler für die Schaltflächen RegisterButton und DeregisterButtonClicked-Ereignisse, die die entsprechendenRegister-Deregistrierungsmethoden/ aufrufen.

void RegisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.RegisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device registered"); });

void DeregisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.DeregisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device deregistered"); });

void ShowAlert(string message)
    => MainThread.BeginInvokeOnMainThread(()
        => DisplayAlert("PushDemo", message, "OK").ContinueWith((task)
            => { if (task.IsFaulted) throw task.Exception; }));

Stellen Sie nun in App.xaml.cs sicher, dass auf die folgenden Namespaces verwiesen wird.

using PushDemo.Models;
using PushDemo.Services;
using Xamarin.Essentials;
using Xamarin.Forms;

Implementieren Sie den Ereignishandler für das IPushDemoNotificationActionServiceActionTriggered-Ereignis .

void NotificationActionTriggered(object sender, PushDemoAction e)
    => ShowActionAlert(e);

void ShowActionAlert(PushDemoAction action)
    => MainThread.BeginInvokeOnMainThread(()
        => MainPage?.DisplayAlert("PushDemo", $"{action} action received", "OK")
            .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; }));

Lösen Sie im App-Konstruktor die IPushNotificationActionService-Implementierung mithilfe des ServiceContainer auf, und abonnieren Sie das Ereignis IPushDemoNotificationActionServiceActionTriggered.
```
public App()
{
    InitializeComponent();

    ServiceContainer.Resolve<IPushDemoNotificationActionService>()
        .ActionTriggered += NotificationActionTriggered;

    MainPage = new MainPage();
}
```
Hinweis

Dies ist einfach, um den Empfang und die Weitergabe von Pushbenachrichtigungsaktionen zu veranschaulichen. In der Regel werden diese im Hintergrund behandelt, z. B. beim Navigieren zu einer bestimmten Ansicht oder beim Aktualisieren einiger Daten, anstatt eine Warnung über die Stammseite, in diesem Fall MainPage , anzuzeigen.

Konfigurieren des nativen Android-Projekts für Pushbenachrichtigungen

Überprüfen des Paketnamens und der Berechtigungen

Öffnen Sie in PushDemo.Android die Projektoptionen und dann die Android-Anwendung im Abschnitt Erstellen .
Überprüfen Sie, ob der Paketname mit dem Wert übereinstimmt, den Sie im PushDemo-Projekt der Firebase-Konsole verwendet haben. Der Paketname hatte das Format com.<organization>.pushdemo.
Legen Sie die Android-Mindestversion auf Android 8.0 (API-Ebene 26) und die Android-Zielversion auf die neueste API-Ebene fest.

Hinweis

Für die Zwecke dieses Tutorials werden nur Geräte mit API-Ebene 26 und höher unterstützt. Sie können es jedoch erweitern, um Geräte mit älteren Versionen zu unterstützen.
Stellen Sie sicher, dass die Berechtigungen INTERNET und READ_PHONE_STATE unter Erforderliche Berechtigungen aktiviert sind.
Klicken Sie auf OK

Hinzufügen der Xamarin Google Play Services-Basis und der Xamarin.Firebase.Messaging-Pakete

Klicken Sie in PushDemo.Android, Steuerelement + Klicken Sie auf den Ordner Pakete , und wählen Sie dann NuGet-Pakete verwalten... aus.
Suchen Sie nach Xamarin.GooglePlayServices.Base (nicht nach Keller), und stellen Sie sicher, dass es aktiviert ist.
Suchen Sie nach Xamarin.Firebase.Messaging , und stellen Sie sicher, dass es aktiviert ist.
Klicken Sie auf Pakete hinzufügen, und klicken Sie dann auf Akzeptieren , wenn Sie aufgefordert werden, die Lizenzbedingungen zu akzeptieren.

Hinzufügen der JSON-Datei von Google Services

Steuerung + Klicken Sie auf das PushDemo.Android Projekt, und wählen Sie im Menü Hinzufügen die Option Vorhandene Datei... aus.
Wählen Sie die google-services.json Datei aus, die Sie zuvor beim Einrichten des PushDemo-Projekts in der Firebase-Konsole heruntergeladen haben, und klicken Sie dann auf Öffnen.
Wenn Sie dazu aufgefordert werden, wählen Sie Die Datei in das Verzeichnis kopieren aus.
Steuerung + Klicken Sie im PushDemo.Android Projekt auf die google-services.json Datei, und stellen Sie sicher, dass GoogleServicesJson als Buildaktion festgelegt ist.

Behandeln von Pushbenachrichtigungen für Android

Steuerung + Klicken Sie auf das PushDemo.Android Projekt, wählen Sie im Menü Hinzufügen die Option Neuer Ordner aus, und klicken Sie dann auf Mithilfe von Diensten als Ordnernamehinzufügen.
Steuerung + Klicken Sie auf den Ordner Dienste, und wählen Sie dann im Menü Hinzufügen die Option Neue Datei... aus.

Wählen Sie Allgemein>Leere Klasse aus, geben Sie als NameDeviceInstallationService.cs ein, und klicken Sie dann auf Neu, um die folgende Implementierung hinzuzufügen.

using System;
using Android.App;
using Android.Gms.Common;
using PushDemo.Models;
using PushDemo.Services;
using static Android.Provider.Settings;

namespace PushDemo.Droid.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        public string Token { get; set; }

        public bool NotificationsSupported
            => GoogleApiAvailability.Instance
                .IsGooglePlayServicesAvailable(Application.Context) == ConnectionResult.Success;

        public string GetDeviceId()
            => Secure.GetString(Application.Context.ContentResolver, Secure.AndroidId);

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetPlayServicesError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for FCM");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "fcm",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetPlayServicesError()
        {
            int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Application.Context);

            if (resultCode != ConnectionResult.Success)
                return GoogleApiAvailability.Instance.IsUserResolvableError(resultCode) ?
                           GoogleApiAvailability.Instance.GetErrorString(resultCode) :
                           "This device is not supported";

            return "An error occurred preventing the use of push notifications";
        }
    }
}

Hinweis

Diese Klasse stellt eine eindeutige ID (mit Secure.AndroidId) als Teil der Notification Hub-Registrierungsnutzlast bereit.

Fügen Sie dem Ordner Dienste mit dem Namen PushNotificationFirebaseMessagingService.cs eine weitere leere Klasse hinzu, und fügen Sie dann die folgende Implementierung hinzu.

using Android.App;
using Android.Content;
using Firebase.Messaging;
using PushDemo.Services;

namespace PushDemo.Droid.Services
{
    [Service]
    [IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
    public class PushNotificationFirebaseMessagingService : FirebaseMessagingService
    {
        IPushDemoNotificationActionService _notificationActionService;
        INotificationRegistrationService _notificationRegistrationService;
        IDeviceInstallationService _deviceInstallationService;

        IPushDemoNotificationActionService NotificationActionService
            => _notificationActionService ??
                (_notificationActionService =
                ServiceContainer.Resolve<IPushDemoNotificationActionService>());

        INotificationRegistrationService NotificationRegistrationService
            => _notificationRegistrationService ??
                (_notificationRegistrationService =
                ServiceContainer.Resolve<INotificationRegistrationService>());

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService =
                ServiceContainer.Resolve<IDeviceInstallationService>());

        public override void OnNewToken(string token)
        {
            DeviceInstallationService.Token = token;

            NotificationRegistrationService.RefreshRegistrationAsync()
                .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; });
        }

        public override void OnMessageReceived(RemoteMessage message)
        {
            if(message.Data.TryGetValue("action", out var messageAction))
                NotificationActionService.TriggerAction(messageAction);
        }
    }
}

Stellen Sie in MainActivity.cs sicher, dass die folgenden Namespaces am Anfang der Datei hinzugefügt wurden.

using System;
using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using Android.Runtime;
using Firebase.Iid;
using PushDemo.Droid.Services;
using PushDemo.Services;

Legen Sie in MainActivity.csLaunchMode auf SingleTop fest, damit MainActivity beim Öffnen nicht erneut erstellt wird.

[Activity(
    Label = "PushDemo",
    LaunchMode = LaunchMode.SingleTop,
    Icon = "@mipmap/icon",
    Theme = "@style/MainTheme",
    MainLauncher = true,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]

Fügen Sie private Eigenschaften und entsprechende Sicherungsfelder hinzu, um einen Verweis auf die Implementierungen IPushNotificationActionService und IDeviceInstallationService zu speichern.

IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Implementieren Sie die IOnSuccessListener-Schnittstelle , um das Firebase-Token abzurufen und zu speichern.

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity, Android.Gms.Tasks.IOnSuccessListener
{
    ...

    public void OnSuccess(Java.Lang.Object result)
        => DeviceInstallationService.Token =
            result.Class.GetMethod("getToken").Invoke(result).ToString();
}

Fügen Sie eine neue Methode namens ProcessNotificationActions hinzu, die überprüft, ob eine bestimmte Absicht über einen zusätzlichen Wert namens action verfügt. Lösen Sie diese Aktion mit der IPushDemoNotificationActionService-Implementierung bedingt aus.

void ProcessNotificationActions(Intent intent)
{
    try
    {
        if (intent?.HasExtra("action") == true)
        {
            var action = intent.GetStringExtra("action");

            if (!string.IsNullOrEmpty(action))
                NotificationActionService.TriggerAction(action);
        }
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(ex.Message);
    }
}

Überschreiben Sie die OnNewIntent-Methode , um die ProcessNotificationActions-Methode aufzurufen.
```
protected override void OnNewIntent(Intent intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationActions(intent);
}
```
Hinweis

Da launchMode für die Activity auf SingleTop festgelegt ist, wird eine Absicht über die OnNewIntent-Methode anstelle der OnCreate-Methode an die vorhandene Activity instance gesendet. Daher müssen Sie eine eingehende Absicht sowohl in der OnCreate- als auch in der OnNewIntent-Methode verarbeiten.
Aktualisieren Sie die OnCreate-Methode so, dass Bootstrap.Begin sie direkt nach dem Aufruf von aufruft, um base.OnCreate die plattformspezifische Implementierung von IDeviceInstallationService zu übergeben.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

Rufen Sie in derselben Methode getInstanceId für die FirebaseApp-instance auf, direkt nach dem Aufruf von Bootstrap.Begin, und fügen Sie MainActivity als IOnSuccessListener hinzu.

if (DeviceInstallationService.NotificationsSupported)
{
    FirebaseInstanceId.GetInstance(Firebase.FirebaseApp.Instance)
        .GetInstanceId()
        .AddOnSuccessListener(this);
}

Rufen Sie in OnCreateProcessNotificationActions unmittelbar nach dem Aufruf von an LoadApplication auf, der die aktuelle Absicht übergibt.
```
...

LoadApplication(new App());

ProcessNotificationActions(Intent);
```

Hinweis

Sie müssen die App jedes Mal erneut registrieren, wenn Sie sie ausführen, und sie von einer Debugsitzung beenden, um weiterhin Pushbenachrichtigungen zu erhalten.

Konfigurieren des nativen iOS-Projekts für Pushbenachrichtigungen

Konfigurieren von Info.plist und Entitlements.plist

Stellen Sie sicher, dass Sie sich in den Visual Studio-Einstellungen> bei Ihrem Apple-Entwicklerkonto angemeldet haben...>Publishing>Apple-Entwicklerkonten und das entsprechende Zertifikat und Bereitstellungsprofil wurden heruntergeladen. Sie sollten diese Ressourcen im Rahmen der vorherigen Schritte erstellt haben.
Öffnen Sie in PushDemo.iOSInfo.plist , und stellen Sie sicher, dass BundleIdentifier mit dem Wert übereinstimmt, der für das jeweilige Bereitstellungsprofil im Apple Developer Portal verwendet wurde. Der BundleIdentifier hatte das Format com.<organization>.PushDemo.
Legen Sie in derselben Datei Mindestsystemversion auf 13.0 fest.

Hinweis

Für die Zwecke dieses Tutorials werden nur Geräte mit iOS 13.0 und höher unterstützt. Sie können es jedoch erweitern, um Geräte mit älteren Versionen zu unterstützen.
Öffnen Sie die Projektoptionen für PushDemo.iOS (doppelklicken Sie auf das Projekt).
Stellen Sie unter Projektoptionen unter iOS-Bundlesignatur erstellen >sicher, dass Ihr Entwicklerkonto unter Team ausgewählt ist. Stellen Sie dann sicher, dass "Signierung automatisch verwalten" ausgewählt ist und Ihr Signaturzertifikat und Ihr Bereitstellungsprofil automatisch ausgewählt sind.

Hinweis

Wenn Ihr Signaturzertifikat und Ihr Bereitstellungsprofil nicht automatisch ausgewählt wurden, wählen Sie Manuelle Bereitstellung aus, und klicken Sie dann auf Signaturoptionen bündeln. Stellen Sie sicher, dass Ihr Team für Signaturidentität und Ihr PushDemo-spezifisches Bereitstellungsprofil für Bereitstellungsprofil sowohl für Debug - als auch für Releasekonfigurationen ausgewählt ist. Stellen Sie sicher, dass in beiden Fällen iPhone für die Plattform ausgewählt ist.
Öffnen Sie in PushDemo.iOSEntitlements.plist , und stellen Sie sicher, dass Pushbenachrichtigungen aktivieren aktiviert ist, wenn es auf der Registerkarte Berechtigungen angezeigt wird. Stellen Sie dann sicher, dass die Einstellung APS-Umgebung auf Entwicklung festgelegt ist, wenn sie auf der Registerkarte Quelle angezeigt wird.

Behandeln von Pushbenachrichtigungen für iOS

Steuerung + Klicken Sie auf das Projekt PushDemo.iOS, wählen Sie im Menü Hinzufügen die Option Neuer Ordner aus, und klicken Sie dann unter Verwendung von Diensten als Ordnername auf Hinzufügen.
Steuerung + Klicken Sie auf den Ordner Dienste, und wählen Sie dann im Menü Hinzufügen die Option Neue Datei... aus.

Wählen Sie Allgemein>Leere Klasse aus, geben Sie als NameDeviceInstallationService.cs ein, und klicken Sie dann auf Neu, um die folgende Implementierung hinzuzufügen.

using System;
using PushDemo.Models;
using PushDemo.Services;
using UIKit;

namespace PushDemo.iOS.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        const int SupportedVersionMajor = 13;
        const int SupportedVersionMinor = 0;

        public string Token { get; set; }

        public bool NotificationsSupported
            => UIDevice.CurrentDevice.CheckSystemVersion(SupportedVersionMajor, SupportedVersionMinor);

        public string GetDeviceId()
            => UIDevice.CurrentDevice.IdentifierForVendor.ToString();

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetNotificationsSupportError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for APNS");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "apns",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetNotificationsSupportError()
        {
            if (!NotificationsSupported)
                return $"This app only supports notifications on iOS {SupportedVersionMajor}.{SupportedVersionMinor} and above. You are running {UIDevice.CurrentDevice.SystemVersion}.";

            if (Token == null)
                return $"This app can support notifications but you must enable this in your settings.";


            return "An error occurred preventing the use of push notifications";
        }
    }
}

Hinweis

Diese Klasse stellt eine eindeutige ID (unter Verwendung des UIDevice.IdentifierForVendor-Werts ) und die Notification Hub-Registrierungsnutzlast bereit.

Fügen Sie dem Projekt PushDemo.iOS einen neuen Ordner namens Erweiterungen hinzu, und fügen Sie dann eine leere Klasse mit dem Namen NSDataExtensions.cs mit der folgenden Implementierung zu diesem Ordner hinzu.

using System.Text;
using Foundation;

namespace PushDemo.iOS.Extensions
{
    internal static class NSDataExtensions
    {
        internal static string ToHexString(this NSData data)
        {
            var bytes = data.ToArray();

            if (bytes == null)
                return null;

            StringBuilder sb = new StringBuilder(bytes.Length * 2);

            foreach (byte b in bytes)
                sb.AppendFormat("{0:x2}", b);

            return sb.ToString().ToUpperInvariant();
        }
    }
}

Stellen Sie in AppDelegate.cs sicher, dass die folgenden Namespaces am Anfang der Datei hinzugefügt wurden.

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Foundation;
using PushDemo.iOS.Extensions;
using PushDemo.iOS.Services;
using PushDemo.Services;
using UIKit;
using UserNotifications;
using Xamarin.Essentials;

Fügen Sie private Eigenschaften und die entsprechenden Sicherungsfelder hinzu, um einen Verweis auf die Implementierungen IPushDemoNotificationActionService, INotificationRegistrationService und IDeviceInstallationService zu speichern.

IPushDemoNotificationActionService _notificationActionService;
INotificationRegistrationService _notificationRegistrationService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

INotificationRegistrationService NotificationRegistrationService
    => _notificationRegistrationService ??
        (_notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Fügen Sie die RegisterForRemoteNotifications-Methode zum Registrieren von Benutzerbenachrichtigungseinstellungen und dann für Remotebenachrichtigungen mit APNS hinzu.

void RegisterForRemoteNotifications()
{
    MainThread.BeginInvokeOnMainThread(() =>
    {
        var pushSettings = UIUserNotificationSettings.GetSettingsForTypes(
            UIUserNotificationType.Alert |
            UIUserNotificationType.Badge |
            UIUserNotificationType.Sound,
            new NSSet());

        UIApplication.SharedApplication.RegisterUserNotificationSettings(pushSettings);
        UIApplication.SharedApplication.RegisterForRemoteNotifications();
    });
}

Fügen Sie die CompleteRegistrationAsync-Methode hinzu, um den IDeviceInstallationService.Token Eigenschaftswert festzulegen. Aktualisieren Sie die Registrierung, und speichern Sie das Gerätetoken zwischen, wenn es seit der letzten Speicherung aktualisiert wurde.
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```

Fügen Sie die ProcessNotificationActions-Methode zum Verarbeiten der NSDictionary-Benachrichtigungsdaten und zum bedingten Aufrufen von NotificationActionService.TriggerAction hinzu.

void ProcessNotificationActions(NSDictionary userInfo)
{
    if (userInfo == null)
        return;

    try
    {
        var actionValue = userInfo.ObjectForKey(new NSString("action")) as NSString;

        if (!string.IsNullOrWhiteSpace(actionValue?.Description))
            NotificationActionService.TriggerAction(actionValue.Description);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex.Message);
    }
}

Überschreiben Sie die RegisteredForRemoteNotifications-Methode , die das argument deviceToken an die CompleteRegistrationAsync-Methode übergibt.

public override void RegisteredForRemoteNotifications(
    UIApplication application,
    NSData deviceToken)
    => CompleteRegistrationAsync(deviceToken).ContinueWith((task)
        => { if (task.IsFaulted) throw task.Exception; });

Überschreiben Sie die ReceivedRemoteNotification-Methode , die das argument userInfo an die ProcessNotificationActions-Methode übergibt.

public override void ReceivedRemoteNotification(
    UIApplication application,
    NSDictionary userInfo)
    => ProcessNotificationActions(userInfo);

Überschreiben Sie die FailedToRegisterForRemoteNotifications-Methode , um den Fehler zu protokollieren.
```
public override void FailedToRegisterForRemoteNotifications(
    UIApplication application,
    NSError error)
    => Debug.WriteLine(error.Description);
```
Hinweis

Dies ist sehr viel ein Platzhalter. Sie sollten eine ordnungsgemäße Protokollierung und Fehlerbehandlung für Produktionsszenarien implementieren.
Aktualisieren Sie die FinishedLaunching-Methode, um direkt nach dem Aufruf von die Forms.Init plattformspezifische Implementierung von IDeviceInstallationService aufzurufenBootstrap.Begin.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

Fordern Sie bei der gleichen Methode die Autorisierung an, und registrieren Sie sich für Remotebenachrichtigungen unmittelbar nach Bootstrap.Begin.

if (DeviceInstallationService.NotificationsSupported)
{
    UNUserNotificationCenter.Current.RequestAuthorization(
            UNAuthorizationOptions.Alert |
            UNAuthorizationOptions.Badge |
            UNAuthorizationOptions.Sound,
            (approvalGranted, error) =>
            {
                if (approvalGranted && error == null)
                    RegisterForRemoteNotifications();
            });
}

Rufen Sie in FinishedLaunchingProcessNotificationActions unmittelbar nach dem Aufruf von auf LoadApplication , wenn das options-Argument die UIApplication.LaunchOptionsRemoteNotificationKey enthält und das resultierende userInfo-Objekt übergibt.
```
using (var userInfo = options?.ObjectForKey(
    UIApplication.LaunchOptionsRemoteNotificationKey) as NSDictionary)
        ProcessNotificationActions(userInfo);
```

Testen der Lösung

Sie können jetzt das Senden von Benachrichtigungen über den Back-End-Dienst testen.

Senden einer Testbenachrichtigung

Öffnen Sie in Postman eine neue Registerkarte.
Legen Sie die Anforderung auf POST fest, und geben Sie die folgende Adresse ein:
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```
Wenn Sie den Abschnitt Authentifizieren von Clients mithilfe eines API-Schlüssels ausgewählt haben, müssen Sie die Anforderungsheader so konfigurieren, dass sie Ihren apikey-Wert enthalten.

Schlüssel Wert

apikey <your_api_key>
Wählen Sie die Raw-Option für den Text aus, wählen Sie dann JSON aus der Liste der Formatoptionen aus, und fügen Sie dann einige Platzhalter-JSON-Inhalte ein:
```
{
    "text": "Message from Postman!",
    "action": "action_a"
}
```
Wählen Sie die Schaltfläche Code aus, die sich oben rechts im Fenster unter der Schaltfläche Speichern befindet. Die Anforderung sollte ähnlich wie das folgende Beispiel aussehen, wenn sie für HTML angezeigt wird (je nachdem, ob Sie einen apikey-Header eingefügt haben):
```
POST /api/notifications/requests HTTP/1.1
Host: https://<app_name>.azurewebsites.net
apikey: <your_api_key>
Content-Type: application/json

{
    "text": "Message from backend service",
    "action": "action_a"
}
```
Führen Sie die PushDemo-Anwendung auf einer oder beiden Zielplattformen (Android und iOS) aus.

Hinweis

Wenn Sie unter Android testen, stellen Sie sicher, dass Sie nicht in Debug ausgeführt werden, oder wenn die App durch Ausführen der Anwendung bereitgestellt wurde, erzwingen Sie das Schließen der App, und starten Sie sie erneut über das Startfeld.
Tippen Sie in der PushDemo-App auf die Schaltfläche Registrieren .
Zurück zu Postman, schließen Sie das Fenster Codeausschnitte generieren (falls sie dies noch nicht getan haben), und klicken Sie dann auf die Schaltfläche Senden .
Überprüfen Sie, ob Sie eine 200 OK-Antwort in Postman erhalten und die Warnung in der App angezeigt wird, die AktionA-Aktion empfangen.
Schließen Sie die PushDemo-App, und klicken Sie dann in Postman erneut auf die Schaltfläche Senden.
Überprüfen Sie, ob Sie in Postman erneut eine Antwort mit 200 OK erhalten. Überprüfen Sie, ob eine Benachrichtigung im Infobereich für die PushDemo-App mit der richtigen Nachricht angezeigt wird.
Tippen Sie auf die Benachrichtigung, um zu bestätigen, dass die App geöffnet und die AktionA-Warnung empfangen wurde .
Ändern Sie zurück in Postman den vorherigen Anforderungstext, um eine unbeaufsichtigte Benachrichtigung zu senden, die action_b anstelle von action_a für den Aktionswert angibt.
```
{
    "action": "action_b",
    "silent": true
}
```
Wenn die App weiterhin geöffnet ist, klicken Sie in Postman auf die Schaltfläche Senden.
Überprüfen Sie, ob Sie eine 200 OK-Antwort in Postman erhalten und dass die Warnung in der App angezeigt wird, die Die Aktion B-Aktion empfangen anstelle der empfangenen AktionA-Aktion anzeigt.
Schließen Sie die PushDemo-App, und klicken Sie dann in Postman erneut auf die Schaltfläche Senden.
Überprüfen Sie, ob Sie eine Antwort mit 200 OK in Postman erhalten und dass die unbeaufsichtigte Benachrichtigung nicht im Benachrichtigungsbereich angezeigt wird.

Schlüssel	Wert
apikey	<your_api_key>

Problembehandlung

Keine Antwort vom Back-End-Dienst

Stellen Sie beim lokalen Testen sicher, dass der Back-End-Dienst ausgeführt wird und den richtigen Port verwendet.

Wenn Sie mit der Azure-API-App testen, überprüfen Sie, ob der Dienst ausgeführt wird und bereitgestellt wurde und ohne Fehler gestartet wurde.

Vergewissern Sie sich, dass Sie die Basisadresse beim Testen über den Client in Postman oder in der Konfiguration der mobilen App korrekt angegeben haben. Die Basisadresse sollte indikativ oder beim lokalen Testen sein https://<api_name>.azurewebsites.net/https://localhost:5001/ .

Keine Benachrichtigungen unter Android nach dem Starten oder Beenden einer Debugsitzung

Stellen Sie sicher, dass Sie sich nach dem Starten oder Beenden einer Debugsitzung erneut registrieren. Der Debugger bewirkt, dass ein neues Firebase-Token generiert wird. Auch die Notification Hub-Installation muss aktualisiert werden.

Empfangen eines 401-status-Codes vom Back-End-Dienst

Überprüfen Sie, ob Sie den apikey-Anforderungsheader festlegen und dieser Wert mit dem Wert übereinstimmt, den Sie für den Back-End-Dienst konfiguriert haben.

Wenn Sie diesen Fehler beim lokalen Testen erhalten, stellen Sie sicher, dass der Schlüsselwert, den Sie in der Clientkonfiguration definiert haben, dem von der API verwendeten Wert für die Benutzereinstellung Authentication:ApiKey entspricht.

Wenn Sie mit einer API-App testen, stellen Sie sicher, dass der Schlüsselwert in der Clientkonfigurationsdatei der Anwendungseinstellung Authentication:ApiKey entspricht, die Sie in der API-App verwenden.

Hinweis

Wenn Sie diese Einstellung erstellt oder geändert haben, nachdem Sie den Back-End-Dienst bereitgestellt haben, müssen Sie den Dienst neu starten, damit er wirksam wird.

Wenn Sie den Abschnitt Clients mithilfe eines API-Schlüssels authentifizieren nicht abschließen möchten, stellen Sie sicher, dass Sie das Authorize-Attribut nicht auf die NotificationsController-Klasse angewendet haben.

Empfangen eines 404-status-Codes vom Back-End-Dienst

Überprüfen Sie, ob der Endpunkt und die HTTP-Anforderungsmethode korrekt sind. Die Endpunkte sollten z. B. indikativ sein:

[PUT]https://<api_name>.azurewebsites.net/api/notifications/installations
[LÖSCHEN]https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
[POST]https://<api_name>.azurewebsites.net/api/notifications/requests

Oder beim lokalen Testen:

[PUT]https://localhost:5001/api/notifications/installations
[LÖSCHEN]https://localhost:5001/api/notifications/installations/<installation_id>
[POST]https://localhost:5001/api/notifications/requests

Wenn Sie die Basisadresse in der Client-App angeben, stellen Sie sicher, dass sie mit einem /endet. Die Basisadresse sollte indikativ oder beim lokalen Testen sein https://<api_name>.azurewebsites.net/https://localhost:5001/ .

Registrierung nicht möglich, und eine Notification Hub-Fehlermeldung wird angezeigt

Vergewissern Sie sich, dass das Testgerät über Netzwerkkonnektivität verfügt. Bestimmen Sie dann die HTTP-Antwort status Code, indem Sie einen Haltepunkt festlegen, um den StatusCode-Eigenschaftswert in der HttpResponse zu überprüfen.

Überprüfen Sie ggf. die vorherigen Problembehandlungsvorschläge basierend auf dem status Code.

Legen Sie einen Haltepunkt für die Zeilen fest, die diese spezifischen status Codes für die jeweilige API zurückgeben. Versuchen Sie dann, den Back-End-Dienst beim lokalen Debuggen aufzurufen.

Überprüfen Sie, ob der Back-End-Dienst über Postman mit der entsprechenden Nutzlast wie erwartet funktioniert. Verwenden Sie die tatsächliche Nutzlast, die vom Clientcode für die betreffende Plattform erstellt wurde.

Überprüfen Sie die abschnitte zur plattformspezifischen Konfiguration, um sicherzustellen, dass keine Schritte verpasst wurden. Überprüfen Sie, ob geeignete Werte für installation id und token Variablen für die entsprechende Plattform aufgelöst werden.

Eine ID für die Angezeigte Gerätefehlermeldung kann nicht aufgelöst werden.

Überprüfen Sie die abschnitte zur plattformspezifischen Konfiguration, um sicherzustellen, dass keine Schritte verpasst wurden.

Nächste Schritte

Sie sollten jetzt über eine einfache Xamarin.Forms-App verfügen, die über einen Back-End-Dienst mit einem Notification Hub verbunden ist und Benachrichtigungen senden und empfangen kann.

Wahrscheinlich müssen Sie das in diesem Tutorial verwendete Beispiel an Ihr eigenes Szenario anpassen. Es wird auch empfohlen, eine robustere Fehlerbehandlung, Wiederholungslogik und Protokollierung zu implementieren.

Visual Studio App Center kann schnell in mobile Apps integriert werden, die Analysen und Diagnose bereitstellen, um die Problembehandlung zu unterstützen.

Tutorial: Senden von Pushbenachrichtigungen an Xamarin.Forms-Apps mithilfe von Azure Notification Hubs über einen Back-End-Dienst

Voraussetzungen

Einrichten von Push Notification Services und Azure Notification Hub

Erstellen eines Firebase-Projekts und Aktivieren von Firebase Cloud Messaging für Android

Registrieren Ihrer iOS-App für Pushbenachrichtigungen

Erstellen eines Zertifikats für Notification Hubs

OPTION 1: Erstellen eines p12-Pushzertifikats, das direkt in Notification Hub hochgeladen werden kann

OPTION 2: Erstellen eines P8-Zertifikats, das für die tokenbasierte Authentifizierung verwendet werden kann

Erstellen eines Bereitstellungsprofils für die App

Erstellen eines Notification Hubs

Konfigurieren Ihres Notification Hubs mit APNS-Informationen

OPTION 1: Verwenden eines P12-Pushzertifikats

OPTION 2: Verwenden der tokenbasierten Authentifizierung

Konfigurieren Ihres Notification Hubs mit FCM-Informationen

Erstellen einer ASP.NET Core Web-API-Back-End-Anwendung

Erstellen eines Webprojekts

Authentifizieren von Clients mithilfe eines API-Schlüssels (optional)

Hinzufügen von Abhängigkeiten und Konfigurieren von Diensten

Erstellen der Benachrichtigungs-API

Erstellen der API-App

Veröffentlichen des Back-End-Diensts

Überprüfen der veröffentlichten API

Erstellen einer plattformübergreifenden Xamarin.Forms-Anwendung

Erstellen der Xamarin.Forms-Lösung

Implementieren der plattformübergreifenden Komponenten

Implementieren der plattformübergreifenden Benutzeroberfläche

Konfigurieren des nativen Android-Projekts für Pushbenachrichtigungen

Überprüfen des Paketnamens und der Berechtigungen

Hinzufügen der Xamarin Google Play Services-Basis und der Xamarin.Firebase.Messaging-Pakete

Hinzufügen der JSON-Datei von Google Services

Behandeln von Pushbenachrichtigungen für Android

Konfigurieren des nativen iOS-Projekts für Pushbenachrichtigungen

Konfigurieren von Info.plist und Entitlements.plist

Behandeln von Pushbenachrichtigungen für iOS

Testen der Lösung

Senden einer Testbenachrichtigung

Problembehandlung

Keine Antwort vom Back-End-Dienst

Keine Benachrichtigungen unter Android nach dem Starten oder Beenden einer Debugsitzung

Empfangen eines 401-status-Codes vom Back-End-Dienst

Empfangen eines 404-status-Codes vom Back-End-Dienst

Registrierung nicht möglich, und eine Notification Hub-Fehlermeldung wird angezeigt

Eine ID für die Angezeigte Gerätefehlermeldung kann nicht aufgelöst werden.

Verwandte Links

Nächste Schritte

Zusätzliche Ressourcen