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

Artikel
07/27/2020

In diesem Lernprogramm verwenden Sie Azure Notification Hubs, um Benachrichtigungen an eine Xamarin.Forms Anwendung für Android und iOS-zu übertragen.

Eine ASP.NET Core Web API Back-End wird verwendet, um Geräteregistrierung für den Client mithilfe des neuesten und besten Installations- Ansatzes zu behandeln. Der Dienst sendet pushbenachrichtigungen auch plattformübergreifend.

Diese Vorgänge werden mithilfe des Notification Hubs SDK für Back-End-Vorgängebehandelt. Weitere Details zum allgemeinen Ansatz finden Sie in der Registrierung aus Ihrem App-Back-End Dokumentation.

Dieses Lernprogramm führt Sie durch die folgenden Schritte:

Einrichten von Pushbenachrichtigungsdiensten und Azure Notification Hubs.
Erstellen einer ASP.NET Core Web API-Back-End-Anwendung.
Erstellen einer plattformübergreifenden Xamarin.Forms-Anwendung.
Konfigurieren des systemeigenen Android-Projekts für Pushbenachrichtigungen.
Konfigurieren des systemeigenen iOS-Projekts für Pushbenachrichtigungen.
Testen Sie die Lösung.

Voraussetzungen

Um ihnen zu folgen, benötigen Sie Folgendes:

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

Für Android müssen Sie folgendes haben:

Ein entwickler entsperrtes physisches Gerät oder ein Emulator (ausgeführt api 26 und höher mit installierten Google Play Services).

Für iOS müssen Sie folgendes haben:

Ein aktives Apple Developer Account.
Ein physisches iOS-Gerät, das für Ihr Entwicklerkonto registriert (unter iOS 13.0 und höher).
Ein .p12-Entwicklungszertifikat in Ihrem Schlüsselbund installiert, mit dem Sie eine App auf einem physischen Gerätausführen können.

Anmerkung

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

Sie können die Schritte in diesem Beispiel für erste Prinzipien ohne vorherige Erfahrung ausführen. Sie profitieren jedoch von der Vertrautheit mit den folgenden Aspekten.

Wichtig

Die bereitgestellten Schritte sind spezifisch 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 miteinander in Einklang gebracht werden können. Beispielsweise Beschreibungen von Benutzeroberfläche und Workflows, Vorlagennamen, Umgebungskonfiguration usw.

Einrichten von Pushbenachrichtigungsdiensten 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 Benachrichtigungshub für die Arbeit mit diesen Diensten.

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

Melden Sie sich bei der Firebase-Konsolean. Erstellen Sie ein neues Firebase-Projekt, das PushDemo- als Projektnameneingibt.

Anmerkung

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 Gedankenstrich getrennt ist. Sie können dies ändern, wenn sie bereitgestellt werden soll, dass sie weiterhin global eindeutig ist.
Nachdem Sie Ihr Projekt erstellt haben, wählen Sie "Firebase hinzufügen" zu Ihrer Android-Appaus.
Führen Sie auf der Seite Hinzufügen von Firebase zu Ihrer Android-App Seite die folgenden Schritte aus.
1. Geben Sie für den Android-Paketnameneinen Namen für Ihr Paket ein. Beispiel: com.<organization_identifier>.<package_name>.
2. Wählen Sie App-registrieren aus.
3. Wählen Sie Herunterladen google-services.jsonaus. Speichern Sie die Datei dann in einem lokalen Ordner, um sie später zu verwenden, und wählen Sie Nextaus.
4. Wählen Sie Nächstenaus.
5. Wählen Sie Weiter zur Konsolen-
  
  Anmerkung
  
  Wenn die Schaltfläche Konsole fortsetzen nicht aktiviert ist, klicken Sie aufgrund der Überprüfung der Installation überprüfen, und wählen Sie Diesen Schritt überspringenaus.
Wählen Sie in der Firebase-Konsole die Kopp für Ihr Projekt aus. Wählen Sie dann Projekteinstellungenaus.

Anmerkung

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 für die spätere Verwendung. Sie verwenden diesen Wert, um Ihren Benachrichtigungshub zu konfigurieren.

kopieren

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 Zertifikaten, Bezeichnern & Profilen, und wählen Sie dann Bezeichneraus. Klicken Sie auf +, um eine neue App zu registrieren.

seite
Wählen Sie auf dem Bildschirm Registrieren eines neuen Bezeichners die App-IDs Optionsfeld aus. Wählen Sie dann Weiteraus.
Aktualisieren Sie die folgenden drei Werte für Ihre neue App, und wählen Sie dann Weiteraus:
- Beschreibung: Geben Sie einen beschreibenden Namen für Ihre App ein.
- Bundle-ID: Geben Sie eine Bundle-ID des Formulars com ein.<organization_identifier>.<product_name> wie im App-Verteilungshandbucherwähnt. Im folgenden Screenshot wird der mobcat Wert als Organisationsbezeichner verwendet, und der PushDemo- Wert wird als Produktname verwendet.
- Pushbenachrichtigungen: Überprüfen Sie die Option Pushbenachrichtigungen im Abschnitt Funktionen.
  
  Diese Aktion generiert Ihre App-ID und fordert sie an, die Informationen zu bestätigen. Wählen Sie Weiteraus, und wählen Sie dann Registrieren aus, um die neue App-ID zu bestätigen.
  
  bestätigen
  
  Nachdem Sie Registrierenausgewählt haben, wird die neue App-ID als Zeilenelement auf der Seite Zertifikate, Bezeichner & Profile Seite angezeigt.
Suchen Sie auf der Seite Zertifikate bezeichner & Profile Seite unter Bezeichnernach dem von Ihnen erstellten Element der App-ID. Wählen Sie dann die Zeile aus, um den Bildschirm App-ID-Konfiguration bearbeiten Bildschirm anzuzeigen.

Erstellen eines Zertifikats für Benachrichtigungshubs

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

Erstellen eines p12-Pushzertifikats, das direkt in den Notification Hub- hochgeladen werden kann (den ursprünglichen Ansatz)
Erstellen eines p8-Zertifikats, das für die tokenbasierte Authentifizierung verwendet werden kann (den neueren und empfohlenen Ansatz)

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

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

Führen Sie auf Ihrem Mac das Schlüsselbund-Access-Tool aus. Sie kann über den Ordner Dienstprogramme oder den Ordner Andere auf dem Launchpad geöffnet werden.
Wählen Sie Schlüsselbundzugriffaus, erweitern Sie Zertifikat-Assistenten, und wählen Sie dann Zertifikat von einer Zertifizierungsstelleanfordern.

Anmerkung

Standardmäßig wählt Access das erste Element in der Liste aus. Dies kann ein Problem sein, wenn Sie sich in der Kategorie Zertifikate befinden und Zertifizierungsstelle für Apple Worldwide Developer Relations nicht das erste Element in der Liste ist. Stellen Sie sicher, dass Sie über ein Nichtschlüsselelement oder die Apple Worldwide Developer Relations Zertifizierungsstelle Schlüssel ausgewählt ist, bevor Sie die CSR (Zertifikatsignierungsanforderung) generieren.
Wählen Sie ihre Benutzer-E-Mail-Adresseaus, geben Sie Ihren Allgemeinen Namen Wert ein, stellen Sie sicher, dass Sie auf Datenträger gespeichertangeben, und wählen Sie dann Weiteraus. Lassen Sie E-Mail-Adresse der Zertifizierungsstelle leer, da sie nicht erforderlich ist.
Geben Sie einen Namen für die datei Zertifikatsignaturanforderung (CSR) in Speichern unterein, wählen Sie den Speicherort in Woaus, und wählen Sie dann Speichernaus.

Diese Aktion speichert die CSR-Datei am ausgewählten Speicherort. Der Standardspeicherort ist Desktop-. Denken Sie an den Speicherort, der für die Datei ausgewählt wurde.
Zurück auf der Seite Zertifikate & Profile Seite im iOS-Bereitstellungsportalscrollen Sie nach unten zur aktivierten option Pushbenachrichtigungen, und wählen Sie dann Konfigurieren zum Erstellen des Zertifikats aus.
Das Fenster Apple Push Notification Service TLS/SSL-Zertifikate angezeigt. Wählen Sie die Schaltfläche Zertifikat erstellen unter dem Abschnitt Entwicklungs-TLS/SSL-Zertifikat aus.

Der Bildschirm Erstellen eines neuen Zertifikats wird angezeigt.

Anmerkung

In diesem Lernprogramm wird ein Entwicklungszertifikat verwendet. Derselbe Prozess wird beim Registrieren eines Produktionszertifikats verwendet. Stellen Sie einfach sicher, dass Sie beim Senden von Benachrichtigungen denselben Zertifikattyp verwenden.
Wählen Sie Dateiauswählen, navigieren Sie zu dem Speicherort, an dem Sie die CSR-Dateigespeichert haben, und doppelklicken Sie dann auf den Zertifikatnamen, um sie zu laden. Wählen Sie dann Weiteraus.
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 in Ihrem ordner "Downloads" gespeichert.

Anmerkung

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 dargestellt:

Anmerkung

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

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 speicherort des exportierten p12-Zertifikats. Sie werden verwendet, um die Authentifizierung mit APNs zu aktivieren.

Anmerkung

Ihr p12-Dateiname und -Speicherort unterscheiden sich möglicherweise von dem, was in diesem Lernprogramm dargestellt wird.

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

Notieren Sie sich die folgenden Details:
- App-ID-Präfix (Team-ID)
- Bundle-ID
Zurück in Zertifikaten, Bezeichner & Profile, klicken Sie auf Schlüssel.

Anmerkung

Wenn Sie bereits einen Schlüssel für APNS-konfiguriert haben, können Sie das p8-Zertifikat erneut verwenden, das Sie direkt nach der Erstellung heruntergeladen haben. Wenn ja, können Sie die Schritte 3 bis 5ignorieren.
Klicken Sie auf die Schaltfläche + (oder auf die Schaltfläche Erstellen eines Schlüssels), um einen neuen Schlüssel zu erstellen.
Geben Sie einen geeigneten Key Name Wert an, überprüfen 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 Download, und verschieben Sie dann die p8--Datei (vorangestellt mit AuthKey_) in ein sicheres lokales Verzeichnis, und klicken Sie dann auf Fertig.

Anmerkung

Achten Sie darauf, ihre p8-Datei an einem sicheren Ort zu speichern (und eine Sicherung zu speichern). Nach dem Herunterladen des Schlüssels kann er nicht erneut heruntergeladen werden, wenn die Serverkopie entfernt wird.
Klicken Sie auf Tastenauf den von Ihnen erstellten Schlüssel (oder auf einen vorhandenen Schlüssel, wenn Sie stattdessen dies verwenden möchten).
Notieren Sie sich den wert Key ID.
Ö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 PRIVATEN SCHLÜSSEL-----

Anmerkung

Dies ist der Tokenwert, der später verwendet wird, um Notification Hub-zu konfigurieren.

Am Ende dieser Schritte sollten Sie die folgenden Informationen zur späteren Verwendung in Konfigurieren Ihres Benachrichtigungshubs mit APNS-Informationenhaben:

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, wählen Sie Zertifikate, Bezeichner & Profileaus, wählen Sie im linken Menü Profile aus, und wählen Sie dann + aus, um ein neues Profil zu erstellen. Der Bildschirm Registrieren eines neuen Bereitstellungsprofils angezeigt.
Wählen Sie iOS App Development unter Development als Bereitstellungsprofiltyp aus, und wählen Sie dann Weiteraus.
Wählen Sie als Nächstes die App-ID aus, die Sie aus der Dropdownliste App-ID erstellt haben, und wählen Sie Weiteraus.
Wählen Sie im Fenster Zertifikat auswählen das Entwicklungszertifikat aus, das Sie für die Codesignierung verwenden, und wählen Sie Weiteraus.

Anmerkung

Dieses Zertifikat ist nicht das Pushzertifikat, das Sie im vorherigen Schritterstellt haben. Dies ist Ihr Entwicklungszertifikat. Wenn eine nicht vorhanden ist, müssen Sie sie erstellen, da es sich um eine Voraussetzung für dieses Lernprogramm handelt. Entwicklerzertifikate können im Apple Developer Portalüber Xcode- oder in Visual Studio-erstellt werden.
Kehren Sie zur Seite Zertifikate, Bezeichner & Profile Seite zurück, wählen Sie im linken Menü Profile aus, und wählen Sie dann + aus, um ein neues Profil zu erstellen. Der Bildschirm Registrieren eines neuen Bereitstellungsprofils angezeigt.
Wählen Sie im Fenster Zertifikate auswählen das von Ihnen erstellte Entwicklungszertifikat aus. Wählen Sie dann Weiteraus.
Wählen Sie als Nächstes die geräte aus, die zum Testen verwendet werden sollen, und wählen Sie Weiteraus.
Wählen Sie schließlich einen Namen für das Profil in Bereitstellungsprofilnameaus, und wählen Sie Generierenaus.
Wenn das neue Bereitstellungsprofil erstellt wird, wählen Sie Herunterladenaus. Denken Sie an den Speicherort, an dem sie gespeichert ist.
Navigieren Sie zum Speicherort des Bereitstellungsprofils, und doppelklicken Sie dann darauf, um es auf Ihrem Entwicklungscomputer zu installieren.

Erstellen eines Benachrichtigungshubs

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

Melden Sie sich bei Azurean.
Klicken Sie auf Erstellen einer Ressource, suchen Und wählen Sie Notification Hub-aus, und klicken Sie dann auf Erstellen.
Aktualisieren Sie die folgenden Felder, und klicken Sie dann auf Erstellen:

GRUNDLEGENDE DETAILS

Abonnement: Wählen Sie das Ziel Abonnement- aus der Dropdownliste aus.
Ressourcengruppe: Erstellen einer neuen Ressourcengruppe (oder Auswählen einer vorhandenen)

NAMESPACEDETAILS

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

Anmerkung

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

NOTIFICATION HUB DETAILS

Benachrichtigungshub: Geben Sie einen Namen für den Benachrichtigungshub-
Speicherort: Wählen Sie einen geeigneten Speicherort aus der Dropdownliste aus.
Preisstufe: Standardoption Kostenlos beibehalten

Anmerkung

Sofern Sie nicht die maximale Anzahl von Hubs auf der kostenlosen Ebene erreicht haben.
Nachdem der Notification Hub bereitgestellt bereitgestellt wurde, navigieren Sie zu dieser Ressource.
Navigieren Sie zum neuen Notification Hub-.
Wählen Sie Zugriffsrichtlinien aus der Liste aus (unter VERWALTEN).
Notieren Sie sich den Richtliniennamen Werte zusammen mit den entsprechenden Verbindungszeichenfolgen- Werten.

Konfigurieren des Benachrichtigungshubs mit APNS-Informationen

Wählen Sie unter Notification ServicesApple dann die entsprechenden Schritte basierend auf dem Ansatz aus, den Sie zuvor im Abschnitt Erstellen eines Zertifikats für Benachrichtigungshubs ausgewählt haben.

Anmerkung

Verwenden Sie die Production- nur für Anwendungsmodus, wenn Sie Pushbenachrichtigungen an Benutzer senden möchten, die Ihre App aus dem Store erworben haben.

OPTION 1: Verwenden eines P12-Pushzertifikats

Wählen Sie Zertifikataus.
Wählen Sie das Dateisymbol aus.
Wählen Sie die P12-Datei aus, die Sie zuvor exportiert haben, und wählen Sie dann Öffnenaus.
Geben Sie bei Bedarf das richtige Kennwort an.
Wählen Sie Sandkastenmodus aus.
Wählen Sie Speichernaus.

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 Sandkasten-aus.
Wählen Sie Speichernaus.

Konfigurieren Des Benachrichtigungshubs mit FCM-Informationen

Wählen Sie Google (GCM/FCM) im Abschnitt Einstellungen im linken Menü aus.
Geben Sie den Serverschlüssel ein, Sie aus der Google Firebase Consolenotiert haben.
Wählen Sie Speichern auf der Symbolleiste aus.

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

In diesem Abschnitt erstellen Sie die ASP.NET Core Web API Back-End, um 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 Projektmappeaus.
Wählen Sie .NET Core>App>ASP.NET Core>API>Nextaus.
Wählen Sie im Dialogfeld Konfigurieren der neuen ASP.NET Core Web APITarget Framework.NET Core 3.1aus.
Geben Sie PushDemoApi- für den Projektnamen ein, und wählen Sie dann Erstellenaus.
Starten Sie das Debuggen (Command + Enter), um die vorlagenbasierte App zu testen.
Anmerkung

Die vorlagenbasierte App ist so konfiguriert, dass die WeatherForecastController- als launchUrl-verwendet wird. Dies wird in Eigenschaften>launchSettings.jsonfestgelegt.

Wenn Sie mit einem Ungültiges Entwicklungszertifikat aufgefordert werden, wurde Meldung gefunden:
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 Schlüsselbund einzugeben.
2. Klicken Sie auf Ja, wenn Sie aufgefordert werden, das neue Zertifikatzu installieren und als vertrauenswürdig einzustufen, und geben Sie dann das Kennwort für Ihren Schlüsselbund ein.
Erweitern Sie den Ordner Controller, und löschen Sie dann WeatherForecastController.cs.
WeatherForecast.cslöschen .
Richten Sie lokale Konfigurationswerte mithilfe des Secret Manager-Toolsein. Durch das Decoupieren der geheimen Schlüssel aus der Lösung wird sichergestellt, dass sie nicht in der Quellcodeverwaltung enden. Ö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 Benachrichtigungshubnamen und Verbindungszeichenfolgenwerte. Sie haben im einen Benachrichtigungshub Abschnitt erstellt. Andernfalls können Sie sie in Azurenachschlagen.

NotificationHub:Name:
Siehe Name in der Zusammenfassung Essentials oben in Übersicht.

NotificationHub:ConnectionString:
Siehe DefaultFullSharedAccessSignature in Access Policies

Anmerkung

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

Authentifizieren von Clients mit einem API-Schlüssel (optional)

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

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

Sie sollten den Platzhalterwert durch Ihren eigenen ersetzen und eine Notiz davon machen.
SteuerelementKlicken Sie im PushDemoApi- Projekt auf Klicken Sie im Menü Hinzufügen auf, und klicken Sie dann auf Hinzufügen mithilfe Authentifizierung als Ordnername.
SteuerelementKlicken Sie im Ordner Authentifizierung auf, und wählen Sie dann im Menü " hinzufügen" "Neue Datei" aus.

Wählen Sie Allgemeine>Leere Klasseaus, geben Sie ApiKeyAuthOptions.cs für den Namenein, und klicken Sie dann auf Neue Hinzufügen der folgenden Implementierung.

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 Ordner "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));
        }
    }
}

Anmerkung

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

Fügen Sie dem Ordner "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);
        }
    }
}

Anmerkung

Diese Erweiterungsmethode vereinfacht den Middleware-Konfigurationscode in Startup.cs die Lesbarkeit und im Allgemeinen einfacher zu verfolgen.

Aktualisieren Sie in Startup.csdie ConfigureServices-Methode, um die API-Schlüsselauthentifizierung unter dem Aufruf 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 in Startup.csdie Configure-Methode, um die UseAuthentication- und UseAuthorization- Erweiterungsmethoden für die IApplicationBuilder-der App aufzurufen. Stellen Sie sicher, dass diese Methoden nach UseRouting und vor 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();
    });
}
```
Anmerkung

Durch Aufrufen UseAuthentication wird die Middleware registriert, die die zuvor registrierten Authentifizierungsschemas verwendet (von ConfigureServices). Dies muss vor jeder Middleware aufgerufen werden, die von authentifizierten Benutzern abhängt.

Hinzufügen von Abhängigkeiten und Konfigurieren von Diensten

ASP.NET Core unterstützt das Abhängigkeitsinjektion (DI) Softwaredesignmuster, das eine Technik zum Erreichen Inversion of Control (IoC) zwischen Klassen und deren Abhängigkeiten ist.

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

Steuerelement + Klicken Sie im Ordner Abhängigkeiten auf, und wählen Sie dann NuGet-Pakete verwalten...aus.
Suchen Sie nach Microsoft.Azure.NotificationHubs, und stellen Sie sicher, dass sie aktiviert ist.
Klicken Sie auf Paketehinzufügen, und klicken Sie dann auf Akzeptieren, wenn Sie aufgefordert werden, die Lizenzbedingungen zu akzeptieren.
SteuerelementKlicken Sie im projekt PushDemoApi auf klicken, wählen Sie im Menü Ordner hinzufügen Neuen Ordner aus, und klicken Sie dann auf Hinzufügen mithilfe Modelle als Ordnername.
Steuerelement + Klicken Sie im Ordner Modelle auf, und wählen Sie dann Neue Datei... aus dem Menü Hinzufügen aus.

Wählen Sie Allgemeine>Leere Klasseaus, geben Sie PushTemplates.cs für den Namenein, und klicken Sie dann auf Neue 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)\" }";
        }
    }
}

Anmerkung

Diese Klasse enthält die tokenisierten Benachrichtigungsnutzlasten für die generischen und automatischen Benachrichtigungen, die in diesem Szenario erforderlich sind. Die Nutzlasten werden außerhalb des Installation definiert, um Experimenten zu ermöglichen, ohne vorhandene Installationen über den Dienst aktualisieren zu müssen. Die Behandlung von Änderungen an Installationen auf diese Weise liegt außerhalb des Umfangs für dieses Lernprogramm. Berücksichtigen Sie für die Produktion benutzerdefinierte Vorlagen.

Fügen Sie dem Ordner "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 ordner "NotificationRequest.cs" weitere "Empty Class" 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 Ordner mit dem Namen NotificationHubOptions.csweitere 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 namens Serviceseinen neuen Ordner hinzu.

Fügen Sie eine leere Schnittstelle zum Ordner Services namens INotificationService.cshinzu, 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 NotificationHubsService.csOrdner "" eine "Leere Klasse" 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);
        }
    }
}

Anmerkung

Der Tagausdruck, der für SendTemplateNotificationAsync- bereitgestellt wird, ist auf 20 Tags beschränkt. Er ist für die meisten Operatoren auf 6 beschränkt, der Ausdruck enthält jedoch nur ORs (||) in diesem Fall. Wenn in der Anforderung mehr als 20 Tags vorhanden sind, müssen sie in mehrere Anforderungen aufgeteilt werden. Weitere Details finden Sie in der Dokumentation Routing- und Tagausdrücke.

Aktualisieren Sie in Startup.csdie ConfigureServices-Methode, um die NotificationHubsService- als Singletonimplementierung von INotificationServicehinzuzufü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

SteuerelementKlicken Sie im Ordner Controller auf, und wählen Sie dann im Menü Hinzufügen neue Datei aus.
Wählen Sie ASP.NET Core>Web API Controller-Klasseaus, geben Sie NotificationsController- für den Namenein, und klicken Sie dann auf Neue.

Anmerkung

Wenn Sie mit Visual Studio 2019folgen, wählen Sie den API Controller mit Lese-/Schreibaktionen Vorlage 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
}
```
Anmerkung

Die Controller Basisklasse bietet Unterstützung für Ansichten, dies ist jedoch in diesem Fall nicht erforderlich, sodass ControllerBase- stattdessen verwendet werden kann. Wenn Sie mit Visual Studio 2019folgen, können Sie diesen Schritt überspringen.
Wenn Sie sich entschieden haben, die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abzuschließen, sollten Sie auch den NotificationsController- mit dem Attribut Authorize versehen.
```
[Authorize]
```

Aktualisieren Sie den Konstruktor so, dass die registrierte Instanz von INotificationService als Argument akzeptiert wird, und weisen Sie ihn einem readonly-Element zu.

readonly INotificationService _notificationService;

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

Ändern Sie in launchSettings.json (im Ordner Eigenschaften Ordner) die launchUrl- von weatherforecast in API/Benachrichtigungen so, dass sie mit der url übereinstimmen, die im RegistrationsControllerRoute Attribut angegeben ist.
Starten Sie das Debuggen (Command + Enter), um zu überprüfen, ob die App mit dem neuen NotificationsController- arbeitet und einen 401 Nicht autorisiert Status zurückgibt.

Anmerkung

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

Die applicationUrl- sollte für das Standardprofil "https://localhost:5001" sein. Wenn Sie IIS- verwenden (Standardeinstellung in Visual Studio 2019- unter Windows), sollten Sie stattdessen die applicationUrl- verwenden, die im iisSettings- Element angegeben ist. Sie erhalten eine 404-Antwort, wenn die Adresse falsch ist.
Wenn Sie sich entschieden haben, die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abzuschließen, müssen Sie die Anforderungsheader so konfigurieren, dass ihr apikey Wert enthalten ist.

Schlüssel Wert

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

Anmerkung

Sie sollten einen 200 OK Status mit einigen JSON- Inhalt erhalten.

Wenn Sie eine SSL-Zertifikatüberprüfung Warnung erhalten, können Sie die Anforderungs-SSL-Zertifikatüberprüfung Postman einstellung in den Einstellungenwechseln.

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 nun eine -API-App- in Azure App Service zum Hosten des Back-End-Diensts.

Melden Sie sich beim Azure-Portalan.
Klicken Sie auf Erstellen einer Ressource, suchen Und wählen Sie API-App-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 Ziel Abonnement Sie den Benachrichtigungshub erstellt haben.

Ressourcengruppe:
Wählen Sie dieselbe Ressourcengruppe aus, Sie den Benachrichtigungshub erstellt haben.

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

Anmerkung

Wechseln 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 ausführen, 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.
Nachdem die -API-App bereitgestellt wurde, navigieren Sie zu dieser Ressource.
Notieren Sie sich die eigenschaft URL in der Zusammenfassung Essentials oben im Overview. Diese URL ist Ihr Back-End-Endpunkt, der später in diesem Lernprogramm verwendet wird.

Anmerkung

Die URL verwendet den API-App-Namen, den Sie zuvor angegeben haben, mit dem Format https://<app_name>.azurewebsites.net.
Wählen Sie Konfigurations- aus der Liste aus (unter Einstellungen).

Klicken Sie für jede der folgenden Einstellungen auf Neue Anwendungseinstellung, um den Namen und einen Werteinzugeben, und klicken Sie dann auf OK.

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

Anmerkung

Dies sind die gleichen Einstellungen, die Sie zuvor in den Benutzereinstellungen definiert haben. Sie sollten diese kopieren können. Die einstellung Authentication:ApiKey ist nur erforderlich, wenn Sie die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abgeschlossen haben. Für Produktionsszenarien können Sie Optionen wie Azure KeyVault-anzeigen. Diese wurden in diesem Fall als Anwendungseinstellungen hinzugefügt.

Nachdem alle Anwendungseinstellungen hinzugefügt wurden, klicken Sie auf Speichern, und Weiter.

Veröffentlichen des Back-End-Diensts

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

Anmerkung

Die folgenden Schritte sind spezifisch für Visual Studio für Mac. Wenn Sie mit Visual Studio 2019 unter Windows folgen, unterscheidet sich der Veröffentlichungsfluss. Siehe Veröffentlichen in Azure App Service unter Windows.

Ändern Sie Ihre Konfiguration von Debug- in Release-, sofern dies noch nicht geschehen ist.
Steuerelement + Klicken Sie auf das PushDemoApi- Projekt, und wählen Sie dann im Menü VeröffentlichenIn Azure veröffentlichen... aus.
Folgen Sie dem Authentifizierungsfluss, wenn Sie dazu aufgefordert werden. Verwenden Sie das Konto, das Sie im vorherigen zum Erstellen des Abschnitts "API-App" verwendet haben.
Wählen Sie die Azure App Service-API-App aus, die Sie zuvor in der Liste als Veröffentlichungsziel erstellt haben, 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 dies noch nicht geschehen ist. Diese URL ist Ihr Back-End-Endpunkt, das weiter unten in diesem Lernprogramm verwendet wird.

Überprüfen der veröffentlichten API

Legen Sie in Postman eine neue Registerkarte öffnen, 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 Veröffentlichen des Back-End-Diensts Abschnitt vorgenommen haben.
```
https://<app_name>.azurewebsites.net/api/notifications/installations
```
Anmerkung

Die Basisadresse sollte im Format https://<app_name>.azurewebsites.net/
Wenn Sie sich entschieden haben, die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abzuschließen, müssen Sie die Anforderungsheader so konfigurieren, dass ihr apikey Wert enthalten ist.

Schlüssel Wert

apikey <your_api_key>
Wählen Sie die Option unformatierten für den Bodyaus, und wählen Sie dann JSON- aus der Liste der Formatoptionen aus, und fügen Sie dann einen Platzhalter JSON- Inhalt ein:
```
{}
```
Klicken Sie auf senden.

Anmerkung

Sie sollten einen 422 UnprocessableEntity Status des Diensts erhalten.
Führen Sie die Schritte 1 bis 4 erneut aus, aber dieses Mal geben Sie den Anforderungsendpunkt an, um zu überprüfen, dass Sie eine 400 Ungültige Anforderung Antwort erhalten.
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```

Schlüssel	Wert
apikey	<your_api_key>

Anmerkung

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 Xamarin.Forms mobile Anwendung, die Pushbenachrichtigungen plattformübergreifend implementiert.

Damit können Sie sich über den von Ihnen erstellten Back-End-Dienst von einem Benachrichtigungshub registrieren und abmelden.

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

Anmerkung

Normalerweise führen Sie die Registrierungsaktionen (und Die Registrierung) während des entsprechenden Zeitpunkts im Anwendungslebenszyklus (oder als Teil der Ersten Ausführungserfahrung möglicherweise) ohne explizite Benutzerregistrierungs-/Registrierungseingaben durch. Dieses Beispiel erfordert jedoch explizite Benutzereingaben, damit diese Funktionalität einfacher untersucht und getestet werden kann.

Erstellen der Xamarin.Forms-Lösung

Erstellen Sie in Visual Studioeine neue Xamarin.Forms- Lösung, indem Sie Leere Formular-App als Vorlage und PushDemo- für den Projektnameneingeben.

Anmerkung

Stellen Sie im Dialogfeld Konfigurieren ihrer leeren Formular-App sicher, dass der Organisations bezeichner dem zuvor verwendeten Wert entspricht und dass sowohl Android als auch iOS- Ziele überprüft werden.
Steuerelement + Klicken Sie auf in der PushDemo Lösung, und wählen Sie dann NuGet-Pakete aktualisierenaus.
Steuerelement + Klicken Sie auf in der PushDemo Lösung, und wählen Sie dann NuGet-Pakete verwalten..
Suchen Sie nach Newtonsoft.Json, und stellen Sie sicher, dass sie aktiviert ist.
Klicken Sie auf Paketehinzufügen, und klicken Sie dann auf Akzeptieren, wenn Sie aufgefordert werden, die Lizenzbedingungen zu akzeptieren.
Erstellen und ausführen Sie die App auf jeder Zielplattform (Command + Enter), um die App mit Vorlagen zu testen, die auf Ihren Geräten ausgeführt wird.

Implementieren der plattformübergreifenden Komponenten

Steuerelement + Klicken Sie auf im PushDemo- Projekt, wählen Sie neuen Ordner aus dem Menü Hinzufügen, und klicken Sie dann auf Hinzufügen mithilfe Modelle als Ordnername.
Steuerelement + Klicken Sie im Ordner Modelle auf, und wählen Sie dann Neue Datei... aus dem Menü Hinzufügen aus.

Wählen Sie Allgemeine>Leere Klasseaus, geben Sie DeviceInstallation.csein, 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 der folgenden Implementierung eine leere EnumerationPushDemoAction.cs hinzu.

namespace PushDemo.Models
{
    public enum PushDemoAction
    {
        ActionA,
        ActionB
    }
}

Fügen Sie dem PushDemo- Projekt mit dem Namen Services einen neuen Ordner hinzu, und fügen Sie dann einen leeren Klassen- zu diesem Ordner hinzu, der mit der folgenden Implementierung ServiceContainer.cs aufgerufen wird.

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}'");
           }
       }
   }
}

Anmerkung

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

Fügen Sie dem IDeviceInstallationService.csOrdner "Services" eine leere Schnittstelle 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);
    }
}
```
Anmerkung

Diese Schnittstelle wird von jedem Ziel später implementiert und bootstrapped, um die plattformspezifische Funktionalität bereitzustellen und DeviceInstallation Informationen bereitzustellen, die vom Back-End-Dienst benötigt werden.

Fügen Sie dem Ordner "", der INotificationRegistrationService.csheißt, eine weitere leere Schnittstelle 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();
    }
}

Anmerkung

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

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

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

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

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

Fügen Sie dem Ordner Services einen leeren Klassenordner mit dem Namen NotificationRegistrationService.cs Implementierung des 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();
        }
    }
}

Anmerkung

Das argument apiKey ist nur erforderlich, wenn Sie die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abgeschlossen haben.

Fügen Sie dem Ordner Services eine leere Klasse hinzu, die PushDemoNotificationActionService.cs implementierung des IPushDemoNotificationActionService- mit dem folgenden Code aufgerufen wird.

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 ,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";
    }
}
```
Anmerkung

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

Das feld ApiKey ist nur erforderlich, wenn Sie die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abgeschlossen haben.
Fügen Sie dem PushDemo Projekt dieses Mal Config.local_secrets.cs mit der folgenden Implementierung eine weitere "Leere Klasse" hinzu.
```
namespace PushDemo
{
    public static partial class Config
    {
        static Config()
        {
            ApiKey = "<your_api_key>";
            BackendServiceEndpoint = "<your_api_app_url>";
        }
    }
}
```
Anmerkung

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

Das feld ApiKey ist nur erforderlich, wenn Sie die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abgeschlossen haben.

Fügen Sie dem PushDemo- projekt namens Bootstrap.cs mit der folgenden Implementierung eine "Leere Klasse" 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));
        }
    }
}

Anmerkung

Die Begin-Methode wird von jeder Plattform aufgerufen, wenn die App startet, die eine plattformspezifische Implementierung von IDeviceInstallationServiceübergibt.

Das NotificationRegistrationServiceapiKey Konstruktorargument ist nur erforderlich, wenn Sie die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abgeschlossen haben.

Implementieren der plattformübergreifenden Benutzeroberfläche

Öffnen Sie im PushDemo--Projekt "MainPage.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.csein lesegeschütztes Sicherungsfeld hinzu, um einen Verweis auf die INotificationRegistrationService Implementierung zu speichern.
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
Lösen Sie im MainPage--Konstruktor die INotificationRegistrationService Implementierung mithilfe der ServiceContainer- auf, und weisen Sie sie dem notificationRegistrationService- Sicherungsfeld zu.
```
public MainPage()
{
    InitializeComponent();

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

Implementieren Sie die Ereignishandler für die schaltflächen RegisterButton und DeregisterButtonClicked Ereignisse, die die entsprechenden Register/Deregister--Methoden 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.cssicher, 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 IPushDemoNotificationActionService-ActionTriggered--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 den IPushDemoNotificationActionServiceActionTriggered-Ereignis.
```
public App()
{
    InitializeComponent();

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

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

Dies ist einfach, den Empfang und die Verteilung von Pushbenachrichtigungsaktionen zu veranschaulichen. In der Regel werden diese im Hintergrund behandelt, z. B. navigieren zu einer bestimmten Ansicht oder Aktualisieren einiger Daten, anstatt eine Benachrichtigung über die Stamm-Seite, MainPage- in diesem Fall anzuzeigen.

Konfigurieren des systemeigenen Android-Projekts für Pushbenachrichtigungen

Überprüfen des Paketnamens und der Berechtigungen

Öffnen Sie in PushDemo.Android-die Projektoptionen dann Android-Anwendung aus dem Abschnitt Build.
Überprüfen Sie, ob der Paketname dem Wert entspricht, den Sie in der Firebase ConsolePushDemo Projekt verwendet haben. Der Paketname im Format com.<organization>.pushdemo.
Legen Sie die mindeste Android-Version auf Android 8.0 (API-Ebene 26) und die Ziel-Android-Version auf die neueste API-Ebene.

Anmerkung

Nur die Geräte, auf denen API-Ebene 26 und höher ausgeführt werden, werden für die Zwecke dieses Lernprogramms unterstützt. Sie können sie jedoch erweitern, um Geräte mit älteren Versionen zu unterstützen.
Stellen Sie sicher, dass die INTERNET- und READ_PHONE_STATE Berechtigungen unter Erforderlichen Berechtigungenaktiviert 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 im Ordner Pakete auf, und wählen Sie dann Verwalten von NuGet-Paketen....
Suchen Sie nach Xamarin.GooglePlayServices.Base (nicht Keller), und stellen Sie sicher, dass sie überprüft ist.
Suchen Sie nach Xamarin.Firebase.Messaging und stellen Sie sicher, dass sie aktiviert ist.
Klicken Sie auf Paketehinzufügen, und klicken Sie dann auf Akzeptieren, wenn Sie aufgefordert werden, die Lizenzbedingungenzu akzeptieren.

Hinzufügen der JSON-Datei von Google Services

SteuerelementKlicken Sie im Projekt auf, und wählen Sie dann im Menü " hinzufügen" "Vorhandene Datei" aus.
Wählen Sie die google-services.json Datei aus, die Sie zuvor heruntergeladen haben, wenn Sie das PushDemo- Projekt in der Firebase Console einrichten, klicken Sie dann auf Öffnen.
Wenn Sie dazu aufgefordert werden, wählen Sie Kopieren Sie die Datei in das Verzeichnis.
Control + Klicken Sie in der google-services.json Datei im PushDemo.Android Projekt auf, und stellen Sie dann sicher, dass GoogleServicesJson als Buildaktionfestgelegt ist.

Behandeln von Pushbenachrichtigungen für Android

Steuerelement + Klicken Sie im PushDemo.Android Projekt auf, wählen Sie neuen Ordner aus dem Menü Hinzufügen, und klicken Sie dann auf hinzufügen, indem Sie Dienste als Ordnernamenverwenden.
SteuerelementKlicken Sie im Ordner Services auf, und wählen Sie dann im Menü " hinzufügen" "Neue Datei" aus.

Wählen Sie Allgemeine>Leere Klasseaus, geben Sie DeviceInstallationService.cs für den Namenein, und klicken Sie dann auf Neue Hinzufügen der folgenden Implementierung.

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";
        }
    }
}

Anmerkung

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

Fügen Sie dem Ordner Services eine weitere "Leere Klasse" PushNotificationFirebaseMessagingService.cshinzu, 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.cssicher, 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.csdie LaunchMode- 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 IPushNotificationActionService- und IDeviceInstallationService Implementierungen 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 zum Abrufen und Speichern des Firebase--Tokens.

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 ein bestimmter Intent- einen zusätzlichen Wert namens Aktionhat. Lösen Sie diese Aktion bedingt mithilfe der IPushDemoNotificationActionService Implementierung 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 ProcessNotificationActions--Methode aufzurufen.
```
protected override void OnNewIntent(Intent intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationActions(intent);
}
```
Anmerkung

Da die LaunchMode- für die Activity auf SingleTop-festgelegt ist, wird über die eine Intent- an die vorhandene Activity Instanz gesendet. OnNewIntent-Methode anstelle der OnCreate-Methode. Daher müssen Sie eine eingehende Absicht sowohl in OnCreate als auch in OnNewIntent--Methoden behandeln.
Aktualisieren Sie die OnCreate-Methode, um Bootstrap.Begin direkt nach dem Aufruf von base.OnCreate die plattformspezifische Implementierung von IDeviceInstallationServiceaufzurufen.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

Rufen Sie in derselben Methode GetInstanceId für die FirebaseApp-Instanz Instanz direkt nach dem Aufruf von Bootstrap.Beginauf, und fügen Sie MainActivity als IOnSuccessListenerhinzu.

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

Rufen Sie in OnCreateProcessNotificationActions unmittelbar nach dem Aufruf auf, LoadApplication den aktuellen Intent-übergeben.
```
...

LoadApplication(new App());

ProcessNotificationActions(Intent);
```

Anmerkung

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 systemeigenen iOS-Projekts für Pushbenachrichtigungen

Konfigurieren von Info.plist und Entitlements.plist

Stellen Sie sicher, dass Sie sich bei Ihrem Apple-Entwicklerkonto in Visual Studio>Einstellungen angemeldet haben...>Veröffentlichung>Apple-Entwicklerkonten und das entsprechende Zertifikat und Bereitstellungsprofil heruntergeladen wurde. Sie sollten diese Ressourcen als Teil der vorherigen Schritte erstellt haben.
Öffnen Sie in PushDemo.iOS-Info.plist, und stellen Sie sicher, dass die BundleIdentifier- dem Wert entspricht, der für das jeweilige Bereitstellungsprofil im Apple Developer Portalverwendet wurde. Die BundleIdentifier- war im Format com.<organization>.PushDemo.
Legen Sie in derselben Datei Mindestsystemversion auf 13.0fest.

Anmerkung

Nur die Geräte, auf denen iOS 13.0 und höher ausgeführt werden, werden für die Zwecke dieses Lernprogramms unterstützt. Sie können sie 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 in Project-Optionenunter Build > iOS Bundle Signingsicher, dass Ihr Entwicklerkonto unter Team-ausgewählt ist. Stellen Sie dann sicher, dass "Signatur automatisch verwalten" ausgewählt ist, und Ihr Signaturzertifikat und Das Bereitstellungsprofil werden automatisch ausgewählt.

Anmerkung

Wenn Ihr Signaturzertifikat und Bereitstellungsprofil nicht automatisch ausgewählt wurde, wählen Sie manuelle Bereitstellungaus, und klicken Sie dann auf Paketsignaturoptionen. Stellen Sie sicher, dass Ihr Team- für Signierungsidentität ausgewählt ist und ihr PushDemo- spezifisches Bereitstellungsprofil für Bereitstellungsprofil sowohl für Debug- als auch für Release- Konfigurationen ausgewählt ist, um sicherzustellen, dass iPhone- für die Platform in beiden Fällen ausgewählt ist.
Öffnen Sie in PushDemo.iOS-Berechtigungen.plist, und stellen Sie sicher, dass Pushbenachrichtigung en aktivieren, wenn sie auf der Registerkarte Berechtigungen angezeigt wird. Stellen Sie dann sicher, dass die Einstellung APS-Umgebung auf Entwicklungs- festgelegt ist, wenn sie auf der Registerkarte Quelle angezeigt wird.

Behandeln von Pushbenachrichtigungen für iOS

SteuerelementKlicken Sie auf im PushDemo.iOS- Projekt, wählen Sie im Menü Ordner hinzufügen neuen Ordner aus, und klicken Sie dann auf Hinzufügen Dienste als Ordnername.
SteuerelementKlicken Sie im Ordner Services auf, und wählen Sie dann im Menü " hinzufügen" "Neue Datei" aus.

Wählen Sie Allgemeine>Leere Klasseaus, geben Sie DeviceInstallationService.cs für den Namenein, und klicken Sie dann auf Neue Hinzufügen der folgenden Implementierung.

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";
        }
    }
}

Anmerkung

Diese Klasse stellt eine eindeutige ID (mithilfe der UIDevice.IdentifierForVendor Wert) und der Benachrichtigungshub-Registrierungsnutzlast bereit.

Fügen Sie dem PushDemo.iOS- Projekt mit dem Namen Erweiterungen einen neuen Ordner hinzu, und fügen Sie dann einen leeren Klassen- zu diesem Ordner hinzu, der mit der folgenden Implementierung NSDataExtensions.cs aufgerufen wird.

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.cssicher, 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 IPushDemoNotificationActionService-, INotificationRegistrationService-und IDeviceInstallationService Implementierungen 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 hinzu, um Benutzerbenachrichtigungseinstellungen zu registrieren und dann für Remotebenachrichtigungen mit APNS-.

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 Wert der IDeviceInstallationService.Token Eigenschaft festzulegen. Aktualisieren Sie die Registrierung, und speichern Sie das Gerätetoken zwischen, wenn es seit dem letzten Speichern aktualisiert wurde.
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```

Fügen Sie die ProcessNotificationActions Methode zum Verarbeiten der NSDictionary Benachrichtigungsdaten hinzu und rufen Sie bedingt NotificationActionService.TriggerActionauf.

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);
```
Anmerkung

Dies ist sehr viel ein Platzhalter. Sie möchten die richtige Protokollierung und Fehlerbehandlung für Produktionsszenarien implementieren.
Aktualisieren Sie die FinishedLaunching-Methode, um Bootstrap.Begin direkt nach dem Aufruf Forms.Init übergeben die plattformspezifische Implementierung von IDeviceInstallationService.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

Fordern Sie in derselben Methode die Autorisierung bedingt an und registrieren Sie sich sofort nach Bootstrap.Beginfür Remotebenachrichtigungen.

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

Rufen Sie ProcessNotificationActions in FinishedLaunching-unmittelbar nach dem Aufruf von LoadApplication auf, wenn das argument Optionen das Argument UIApplication.LaunchOptionsRemoteNotificationKey enthält, das resultierende userInfo-Objekt übergeben.
```
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 eine neue Registerkarte in Postman-.
Legen Sie die Anforderung auf POST-fest, und geben Sie die folgende Adresse ein:
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```
Wenn Sie sich entschieden haben, die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt abzuschließen, müssen Sie die Anforderungsheader so konfigurieren, dass ihr apikey Wert enthalten ist.

Schlüssel Wert

apikey <your_api_key>
Wählen Sie die Option unformatierten für den Bodyaus, und wählen Sie dann JSON- aus der Liste der Formatoptionen aus, und fügen Sie dann einen Platzhalter JSON- Inhalt 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 dem folgenden Beispiel ähnlich aussehen, wenn sie für HTML- angezeigt wird (je nachdem, ob Sie einen apikey Header eingeschlossen 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 aus (Android und iOS-).

Anmerkung

Wenn Sie auf 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 vom Startfeld.
Tippen Sie in der PushDemo--App auf die Schaltfläche Registrieren.
Schließen Sie zurück in Postmandas Fenster Codeausschnitte generieren (sofern dies noch nicht geschehen ist), 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 mit Aktion angezeigt wird, dieempfangen wurde.
Schließen Sie die PushDemo--App, und klicken Sie dann erneut in Postman-auf die Schaltfläche " senden".
Überprüfen Sie, ob Sie eine 200 OK Antwort in Postman erneut 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 sie die App öffnet und die ActionA-Aktion angezeigt hat, die Warnung empfangen wurde.
Ändern Sie zurück in Postmanden vorherigen Anforderungstext, um eine automatische Benachrichtigung zu senden, die action_b anstelle von action_a für die Aktion Wert 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, in der ActionB-Aktion empfangen anstelle aktionA empfangen.
Schließen Sie die PushDemo--App, und klicken Sie dann erneut in Postman-auf die Schaltfläche " senden".
Überprüfen Sie, ob Sie eine 200 OK Antwort in Postman- erhalten und dass die automatische Benachrichtigung nicht im Infobereich angezeigt wird.

Schlüssel	Wert
apikey	<your_api_key>

Fehlerbehebung

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 Tests mit der Azure API Appdurchgeführt werden, überprüfen Sie, ob der Dienst ausgeführt wird und ohne Fehler gestartet wurde.

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

Empfangen von 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. Die Installation des Benachrichtigungshubs muss ebenfalls aktualisiert werden.

Empfangen eines 401-Statuscodes vom Back-End-Dienst

Überprüfen Sie, ob Sie den apikey Anforderungsheader festlegen, und dieser Wert entspricht dem, 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 Authentication:ApiKey vom -API-verwendeten Benutzereinstellungswert entspricht.

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

Anmerkung

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 sich entschieden haben, die Authentifizieren von Clients mit einem API-Schlüssel Abschnitt nicht abzuschließen, stellen Sie sicher, dass Sie das attribut Authorize nicht auf die NotificationsController Klasse angewendet haben.

Empfangen eines 404-Statuscodes vom Back-End-Dienst

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

[PUT]-https://<api_name>.azurewebsites.net/api/notifications/installations
[DELETE]-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
[DELETE]-https://localhost:5001/api/notifications/installations/<installation_id>
[POST]-https://localhost:5001/api/notifications/requests

Stellen Sie beim Angeben der Basisadresse in der Client-App sicher, dass sie mit einem /endet. Die Basisadresse sollte bei lokalen Tests indikativ https://<api_name>.azurewebsites.net/ oder https://localhost:5001/ werden.

Die Registrierung ist nicht möglich, und es wird eine Fehlermeldung des Benachrichtigungshubs angezeigt.

Stellen Sie sicher, dass das Testgerät über netzwerkkonnektivität verfügt. Bestimmen Sie dann den Http-Antwortstatuscode, indem Sie einen Haltepunkt festlegen, um den wert der StatusCode Eigenschaft im HttpResponse-zu prüfen.

Überprüfen Sie die vorherigen Problembehandlungsvorschläge, sofern zutreffend, basierend auf dem Statuscode.

Legen Sie einen Haltepunkt für die Zeilen fest, die diese spezifischen Statuscodes 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 wie erwartet über Postman- mit der entsprechenden Nutzlast funktioniert. Verwenden Sie die tatsächliche Nutzlast, die vom Clientcode für die betreffende Plattform erstellt wurde.

Überprüfen Sie die plattformspezifischen Konfigurationsabschnitte, 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.

Es wird keine ID für die Gerätefehlermeldung angezeigt.

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

Nächste Schritte

Sie sollten jetzt über einen Back-End-Dienst eine einfache Xamarin.Forms-App mit einem Benachrichtigungshub verbunden haben und Benachrichtigungen senden und empfangen können.

Wahrscheinlich müssen Sie das in diesem Lernprogramm verwendete Beispiel an Ihr eigenes Szenario anpassen. Die Implementierung robusterer Fehlerbehandlung, Wiederholungslogik und Protokollierung wird ebenfalls empfohlen.

Visual Studio App Center- können schnell in mobile Apps integriert werden, die Analyse- und Diagnose- zur Unterstützung der Problembehandlung bereitstellen.

Freigeben über

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

Voraussetzungen

Einrichten von Pushbenachrichtigungsdiensten 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 Benachrichtigungshubs

OPTION 1: Erstellen eines p12-Pushzertifikats, das direkt in den 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 Benachrichtigungshubs

Konfigurieren des Benachrichtigungshubs mit APNS-Informationen

OPTION 1: Verwenden eines P12-Pushzertifikats

OPTION 2: Verwenden der tokenbasierten Authentifizierung

Konfigurieren Des Benachrichtigungshubs mit FCM-Informationen

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

Erstellen eines Webprojekts

Authentifizieren von Clients mit einem API-Schlüssel (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 systemeigenen 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 systemeigenen 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

Fehlerbehebung

Keine Antwort vom Back-End-Dienst

Empfangen von Benachrichtigungen unter Android nach dem Starten oder Beenden einer Debugsitzung

Empfangen eines 401-Statuscodes vom Back-End-Dienst

Empfangen eines 404-Statuscodes vom Back-End-Dienst

Die Registrierung ist nicht möglich, und es wird eine Fehlermeldung des Benachrichtigungshubs angezeigt.

Es wird keine ID für die Gerätefehlermeldung angezeigt.

Verwandte Links

Nächste Schritte

Zusätzliche Ressourcen