Hinzufügen von Pushbenachrichtigungen zu Ihrer Xamarin.Forms-App

Überblick

In diesem Lernprogramm fügen Sie Pushbenachrichtigungen zu allen Projekten hinzu, die sich aus dem Schnellstart von Xamarin.Forms ergeben haben. Dies bedeutet, dass bei jedem Einfügen eines Datensatzes eine Pushbenachrichtigung an alle plattformübergreifenden Clients gesendet wird.

Wenn Sie das heruntergeladene Schnellstartserverprojekt nicht verwenden, benötigen Sie das Paket für die Pushbenachrichtigungserweiterung. Weitere Informationen finden Sie unter Arbeiten mit dem .NET-Back-End-Server-SDK für Azure Mobile Apps.

Voraussetzungen

Für iOS benötigen Sie eine Apple Developer Program-Mitgliedschaft und ein physisches iOS-Gerät. Der iOS-Simulator unterstützt keine Pushbenachrichtigungen.

Konfigurieren eines Benachrichtigungshubs

Das Feature "Mobile Apps" von Azure App Service verwendet Azure Notification Hubs zum Senden von Pushs, sodass Sie einen Benachrichtigungshub für Ihre mobile App konfigurieren.

Wechseln Sie im Azure-Portalzu App Services, und wählen Sie dann Ihr App-Back-End aus. Wählen Sie unter Einstellungendie Option Pushaus.
Um der App eine Benachrichtigungshubressource hinzuzufügen, wählen Sie Verbindenaus. Sie können entweder einen Hub erstellen oder eine Verbindung mit einem vorhandenen herstellen.

Jetzt haben Sie einen Benachrichtigungshub mit Ihrem Back-End-Projekt für mobile Apps verbunden. Später konfigurieren Sie diesen Benachrichtigungshub so, dass eine Verbindung mit einem Plattformbenachrichtigungssystem (PNS) hergestellt wird, um auf Geräte zu übertragen.

Aktualisieren des Serverprojekts zum Senden von Pushbenachrichtigungen

In diesem Abschnitt aktualisieren Sie Code in Ihrem vorhandenen Back-End-Projekt für mobile Apps so, dass jedes Mal, wenn ein neues Element hinzugefügt wird, eine Pushbenachrichtigung gesendet wird. Der Prozess wird von der Vorlagenfunktion von Azure Notification Hubs unterstützt, die plattformübergreifende Push-Benachrichtigungen ermöglicht. Die verschiedenen Clients werden mithilfe von Vorlagen für Pushbenachrichtigungen registriert, und ein einzelner universeller Push kann auf alle Clientplattformen übertragen werden.

Wählen Sie eine der folgenden Verfahren aus, die Ihrem Back-End-Projekttyp entsprechen – entweder .NET Back-End oder Node.js Back-End.

.NET-Back-End-Projekt

Klicken Sie in Visual Studio mit der rechten Maustaste auf das Serverprojekt. Wählen Sie dann "NuGet-Pakete verwalten" aus. Suchen Sie nach Microsoft.Azure.NotificationHubs, und wählen Sie dann Installieren aus. Dieser Vorgang installiert die Benachrichtigungshubs-Bibliothek zum Senden von Benachrichtigungen vom Back-End.

Öffnen Sie im Serverprojekt Controller>TodoItemController.cs. Fügen Sie dann die folgenden "using"-Anweisungen hinzu:

using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;

Fügen Sie in der PostTodoItem-Methode den folgenden Code nach dem Aufruf von InsertAsync hinzu:

// Get the settings for the server project.
HttpConfiguration config = this.Configuration;
MobileAppSettingsDictionary settings =
    this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();

// Get the Notification Hubs credentials for the mobile app.
string notificationHubName = settings.NotificationHubName;
string notificationHubConnection = settings
    .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;

// Create a new Notification Hub client.
NotificationHubClient hub = NotificationHubClient
.CreateClientFromConnectionString(notificationHubConnection, notificationHubName);

// Send the message so that all template registrations that contain "messageParam"
// receive the notifications. This includes APNS, GCM, WNS, and MPNS template registrations.
Dictionary<string,string> templateParams = new Dictionary<string,string>();
templateParams["messageParam"] = item.Text + " was added to the list.";

try
{
    // Send the push notification and log the results.
    var result = await hub.SendTemplateNotificationAsync(templateParams);

    // Write the success result to the logs.
    config.Services.GetTraceWriter().Info(result.State.ToString());
}
catch (System.Exception ex)
{
    // Write the failure result to the logs.
    config.Services.GetTraceWriter()
        .Error(ex.Message, null, "Push.SendAsync Error");
}

Dieser Vorgang sendet eine Vorlagenbenachrichtigung, die das Element.Text enthält, wenn ein neues Element eingefügt wird.

Veröffentlichen Sie das Serverprojekt erneut.

Node.js Backend-Projekt

Richten Sie Ihr Back-End-Projekt ein.

Ersetzen Sie den vorhandenen Code in todoitem.js durch den folgenden Code:

var azureMobileApps = require('azure-mobile-apps'),
promises = require('azure-mobile-apps/src/utilities/promises'),
logger = require('azure-mobile-apps/src/logger');

var table = azureMobileApps.table();

table.insert(function (context) {
// For more information about the Notification Hubs JavaScript SDK,
// see https://aka.ms/nodejshubs.
logger.info('Running TodoItem.insert');

// Define the template payload.
var payload = '{"messageParam": "' + context.item.text + '" }';  

// Execute the insert. The insert returns the results as a promise.
// Do the push as a post-execute action within the promise flow.
return context.execute()
    .then(function (results) {
        // Only do the push if configured.
        if (context.push) {
            // Send a template notification.
            context.push.send(null, payload, function (error) {
                if (error) {
                    logger.error('Error while sending push notification: ', error);
                } else {
                    logger.info('Push notification sent successfully!');
                }
            });
        }
        // Don't forget to return the results from the context.execute().
        return results;
    })
    .catch(function (error) {
        logger.error('Error while running context.execute: ', error);
    });
});

module.exports = table;

Dieser Vorgang sendet eine Vorlagenbenachrichtigung, die den Element.text enthält, wenn ein neues Element eingefügt wird.

Wenn Sie die Datei auf Ihrem lokalen Computer bearbeiten, veröffentlichen Sie das Serverprojekt erneut.

Konfigurieren und Ausführen des Android-Projekts (optional)

Schließen Sie diesen Abschnitt ab, um Pushbenachrichtigungen für das Xamarin.Forms Droid-Projekt für Android zu aktivieren.

Aktivieren von Firebase Cloud Messaging (FCM)

Melden Sie sich bei der Firebase-Konsole an. Erstellen Sie ein neues Firebase-Projekt, falls Sie noch keins besitzen.
Klicken Sie nach der Erstellung Ihres Projekts auf Add Firebase to your Android app (Firebase der Android-App hinzufügen).
Führen Sie auf der Seite Add Firebase to your Android app (Firebase der Android-App hinzufügen) die folgenden Schritte aus:
1. Kopieren Sie für Android package name (Name des Android-Pakets) den Wert von applicationId in die Datei „build.gradle“ Ihrer Anwendung. In diesem Beispiel ist es com.fabrikam.fcmtutorial1app.
2. Wählen Sie Register app (App registrieren) aus.
Wählen Sie Download google-services.json (google-services.json herunterladen) aus, speichern Sie die Datei im Ordner app des Projekts, und klicken Sie dann auf Next (Weiter).
Nehmen Sie an Ihrem Projekt in Android Studio die folgenden Konfigurationsänderungen vor.
1. Fügen Sie der Datei „build.gradle“ auf Projektebene (<Projekt>/build.gradle) im Abschnitt dependencies die folgende Anweisung hinzu.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Fügen Sie der Datei „build.gradle“ auf App-Ebene (<Projekt>/<App-Modul>/build.gradle) im Abschnitt dependencies die folgenden Anweisungen hinzu.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Fügen Sie am Ende der Datei „build.gradle“ auf der App-Ebene hinter dem Abschnitt „dependencies“ die folgende Zeile hinzu.
```
apply plugin: 'com.google.gms.google-services'
```
4. Wählen Sie auf der Symbolleiste Sync Now (Jetzt synchronisieren) aus.
Wählen Sie Weiteraus.
Klicken Sie auf Diesen Schritt überspringen.
Klicken Sie in der Firebase-Konsole auf das Zahnrad für Ihr Projekt. Klicken Sie dann auf Projekteinstellungen.
Wenn Sie die Datei google-services.json nicht in den Ordner app Ihres Android Studio-Projekts heruntergeladen haben, können Sie dies auf dieser Seite tun.
Wechseln Sie oben zur Registerkarte Cloud Messaging.
Kopieren und speichern Sie den Serverschlüssel für eine spätere Verwendung. Verwenden Sie diesen Wert zum Konfigurieren Ihres Hubs.

Konfigurieren des Back-Ends für mobile Apps zum Senden von Pushanforderungen mithilfe von FCM

Wählen Sie im Azure-PortalAlle durchsuchen>App Services aus. Wählen Sie dann Ihr Mobile Apps-Back-End aus.
Wählen Sie unter Einstellungendie Option Pushaus. Wählen Sie dann " Pushbenachrichtigungsdienste konfigurieren" aus.
Wechseln Sie zu Google (GCM). Geben Sie den älteren FCM-Serverschlüssel ein, den Sie über die Firebase-Konsole erhalten haben, und wählen Sie dann "Speichern" aus.

Ihr Dienst ist jetzt für die Arbeit mit Firebase Cloud Messaging konfiguriert.

Hinzufügen von Pushbenachrichtigungen zum Android-Projekt

Mit dem mit FCM konfigurierten Back-End können Sie dem Client Komponenten und Codes hinzufügen, um sich bei FCM zu registrieren. Sie können sich auch über das Back-End der Mobile Apps bei Azure Notification Hubs für Pushbenachrichtigungen registrieren und Benachrichtigungen empfangen.

Klicken Sie im Droid-Projekt mit der rechten Maustaste auf Verweise > NuGet-Pakete verwalten ....
Suchen Sie im NuGet-Paket-Manager-Fenster nach dem Xamarin.Firebase.Messaging-Paket , und fügen Sie es dem Projekt hinzu.
Legen Sie in den Projekteigenschaften für das Droid-Projekt die App so fest, dass sie mit Android, Version 7.0 oder höher, kompiliert werden soll.
Fügen Sie die google-services.json Datei, die aus der Firebase-Konsole heruntergeladen wurde, zum Stamm des Droid-Projekts hinzu, und legen Sie die Buildaktion auf GoogleServicesJson fest. Weitere Informationen finden Sie unter Hinzufügen der JSON-Datei von Google Services.

Registrieren bei Firebase Cloud Messaging

Öffnen Sie die dateiAndroidManifest.xml , und fügen Sie die folgenden <receiver> Elemente in das <application> Element ein:

<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdInternalReceiver" android:exported="false" />
<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdReceiver" android:exported="true" android:permission="com.google.android.c2dm.permission.SEND">
    <intent-filter>
    <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
    <category android:name="${applicationId}" />
    </intent-filter>
</receiver>

Implementieren des Firebase-Instanz-ID-Diensts

Fügen Sie dem Droid-Projekt eine neue Klasse mit dem Namen FirebaseRegistrationServicehinzu, und stellen Sie sicher, dass die folgenden using Anweisungen am Anfang der Datei vorhanden sind:
```
using System.Threading.Tasks;
using Android.App;
using Android.Util;
using Firebase.Iid;
using Microsoft.WindowsAzure.MobileServices;
```
Ersetzen Sie die leere FirebaseRegistrationService Klasse durch den folgenden Code:
```
[Service]
[IntentFilter(new[] { "com.google.firebase.INSTANCE_ID_EVENT" })]
public class FirebaseRegistrationService : FirebaseInstanceIdService
{
    const string TAG = "FirebaseRegistrationService";

    public override void OnTokenRefresh()
    {
        var refreshedToken = FirebaseInstanceId.Instance.Token;
        Log.Debug(TAG, "Refreshed token: " + refreshedToken);
        SendRegistrationTokenToAzureNotificationHub(refreshedToken);
    }

    void SendRegistrationTokenToAzureNotificationHub(string token)
    {
        // Update notification hub registration
        Task.Run(async () =>
        {
            await AzureNotificationHubService.RegisterAsync(TodoItemManager.DefaultManager.CurrentClient.GetPush(), token);
        });
    }
}
```
Die FirebaseRegistrationService Klasse ist für das Generieren von Sicherheitstoken verantwortlich, die die Anwendung für den Zugriff auf FCM autorisieren. Die OnTokenRefresh Methode wird aufgerufen, wenn die Anwendung ein Registrierungstoken von FCM empfängt. Die Methode ruft das Token aus der FirebaseInstanceId.Instance.Token Eigenschaft ab, das asynchron von FCM aktualisiert wird. Die OnTokenRefresh Methode wird selten aufgerufen, da das Token nur aktualisiert wird, wenn die Anwendung installiert oder deinstalliert wird, wenn der Benutzer Anwendungsdaten löscht, wenn die Anwendung die Instanz-ID löscht oder wenn die Sicherheit des Tokens kompromittiert wurde. Darüber hinaus fordert der FCM-Instanz-ID-Dienst an, dass die Anwendung ihr Token regelmäßig aktualisiert, in der Regel alle 6 Monate.

Die OnTokenRefresh Methode ruft auch die SendRegistrationTokenToAzureNotificationHub Methode auf, die verwendet wird, um das Registrierungstoken des Benutzers dem Azure Notification Hub zuzuordnen.

Registrieren beim Azure Notification Hub

Fügen Sie dem Droid-Projekt eine neue Klasse mit dem Namen AzureNotificationHubServicehinzu, und stellen Sie sicher, dass die folgenden using Anweisungen am Anfang der Datei vorhanden sind:
```
using System;
using System.Threading.Tasks;
using Android.Util;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;
```

Ersetzen Sie die leere AzureNotificationHubService Klasse durch den folgenden Code:

public class AzureNotificationHubService
{
    const string TAG = "AzureNotificationHubService";

    public static async Task RegisterAsync(Push push, string token)
    {
        try
        {
            const string templateBody = "{\"data\":{\"message\":\"$(messageParam)\"}}";
            JObject templates = new JObject();
            templates["genericMessage"] = new JObject
            {
                {"body", templateBody}
            };

            await push.RegisterAsync(token, templates);
            Log.Info("Push Installation Id: ", push.InstallationId.ToString());
        }
        catch (Exception ex)
        {
            Log.Error(TAG, "Could not register with Notification Hub: " + ex.Message);
        }
    }
}

Die RegisterAsync Methode erstellt eine einfache Benachrichtigungsmeldungsvorlage als JSON und registriert, um Vorlagenbenachrichtigungen vom Benachrichtigungshub mithilfe des Firebase-Registrierungstokens zu empfangen. Dadurch wird sichergestellt, dass alle vom Azure Notification Hub gesendeten Benachrichtigungen auf das Gerät abzielen, das durch das Registrierungstoken dargestellt wird.

Anzeigen des Inhalts einer Pushbenachrichtigung

Fügen Sie dem Droid-Projekt eine neue Klasse mit dem Namen FirebaseNotificationServicehinzu, und stellen Sie sicher, dass die folgenden using Anweisungen am Anfang der Datei vorhanden sind:
```
using Android.App;
using Android.Content;
using Android.Media;
using Android.Support.V7.App;
using Android.Util;
using Firebase.Messaging;
```

Ersetzen Sie die leere FirebaseNotificationService Klasse durch den folgenden Code:

[Service]
[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
public class FirebaseNotificationService : FirebaseMessagingService
{
    const string TAG = "FirebaseNotificationService";

    public override void OnMessageReceived(RemoteMessage message)
    {
        Log.Debug(TAG, "From: " + message.From);

        // Pull message body out of the template
        var messageBody = message.Data["message"];
        if (string.IsNullOrWhiteSpace(messageBody))
            return;

        Log.Debug(TAG, "Notification message body: " + messageBody);
        SendNotification(messageBody);
    }

    void SendNotification(string messageBody)
    {
        var intent = new Intent(this, typeof(MainActivity));
        intent.AddFlags(ActivityFlags.ClearTop);
        //Unique request code to avoid PendingIntent collision.
        var requestCode = new Random().Next();
        var pendingIntent = PendingIntent.GetActivity(this, requestCode, intent, PendingIntentFlags.OneShot);
        var notificationBuilder = new NotificationCompat.Builder(this)
            .SetSmallIcon(Resource.Drawable.ic_stat_ic_notification)
            .SetContentTitle("New Todo Item")
            .SetContentText(messageBody)
            .SetContentIntent(pendingIntent)
            .SetSound(RingtoneManager.GetDefaultUri(RingtoneType.Notification))
            .SetAutoCancel(true);

        var notificationManager = NotificationManager.FromContext(this);
        notificationManager.Notify(0, notificationBuilder.Build());
    }
}

Die OnMessageReceived Methode, die aufgerufen wird, wenn eine Anwendung eine Benachrichtigung von FCM empfängt, extrahiert den Nachrichteninhalt und ruft die SendNotification Methode auf. Diese Methode konvertiert den Nachrichteninhalt in eine lokale Benachrichtigung, die während der Ausführung der Anwendung gestartet wird, wobei die Benachrichtigung im Infobereich angezeigt wird.

Jetzt können Sie Pushbenachrichtigungen in der App testen, die auf einem Android-Gerät oder dem Emulator ausgeführt wird.

Testen von Pushbenachrichtigungen in Ihrer Android-App

Die ersten beiden Schritte sind nur erforderlich, wenn Sie einen Emulator testen.

Stellen Sie sicher, dass Sie auf einem Gerät oder Emulator, das mit Google Play Services konfiguriert ist, bereitstellen oder debuggen. Dies kann überprüft werden, indem überprüft wird, ob die Play-Apps auf dem Gerät oder Emulator installiert sind.
Fügen Sie dem Android-Gerät ein Google-Konto hinzu, indem Sie auf Apps, Einstellungen und schließlich Konto hinzufügen klicken. Folgen Sie dann den Anweisungen zum Hinzufügen eines vorhandenen Google-Kontos zum Gerät oder zum Erstellen eines neuen Kontos.
Klicken Sie in Visual Studio oder Xamarin Studio mit der rechten Maustaste auf das Droid-Projekt , und klicken Sie dann auf "Als Startprojekt festlegen".
Klicken Sie auf "Ausführen ", um das Projekt zu erstellen und die App auf Ihrem Android-Gerät oder Emulator zu starten.
Geben Sie in der App eine Aufgabe ein, und klicken Sie dann auf das Plussymbol (+).
Stellen Sie sicher, dass eine Benachrichtigung empfangen wird, wenn ein Element hinzugefügt wird.

Konfigurieren und Ausführen des iOS-Projekts (optional)

Dieser Abschnitt dient zum Ausführen des Xamarin iOS-Projekts für iOS-Geräte. Sie können diesen Abschnitt überspringen, wenn Sie nicht mit iOS-Geräten arbeiten.

Eine Zertifikatsignierantrag-Datei erstellen

Der Apple Push Notification Service (APNs) verwendet Zertifikate, um Ihre Pushbenachrichtigungen zu authentifizieren. Befolgen Sie diese Anweisungen, um das erforderliche Pushzertifikat zum Senden und Empfangen von Benachrichtigungen zu erstellen. Weitere Informationen zu diesen Konzepten finden Sie in der offiziellen Dokumentation zum Apple Push Notification Service.

Generieren Sie die CSR-Datei (Certificate Signing Request), die Apple zum Generieren eines signierten Pushzertifikats verwendet.

Führen Sie auf Ihrem Mac das Tool "Schlüsselbundverwaltung" aus. Es kann im Ordner Dienstprogramme oder im Ordner Andere auf dem Launchpad geöffnet werden.
Wählen Sie die Option Schlüsselbundverwaltung aus, erweitern Sie Zertifikatsassistent, und wählen Sie dann Zertifikat einer Zertifizierungsinstanz anfordern aus.

Hinweis

Die Schlüsselbundverwaltung wählt standardmäßig das erste Element in der Liste aus. Dies kann ein Problem darstellen, wenn Sie sich in der Kategorie Zertifikate befinden und Zertifizierungsstelle der Apple Worldwide Developer Relations nicht das erste Element in der Liste ist. Stellen Sie sicher, dass Sie über ein Element verfügen, das kein Schlüssel ist, bzw. dass der Schlüssel Zertifizierungsstelle der Apple Worldwide Developer Relations ausgewählt ist, bevor Sie die Zertifikatsignieranforderung (Certificate Signing Request, CSR) generieren.
Wählen Sie Ihre E-Mail-Adresse des Benutzers aus, und geben Sie den Wert für Allgemeiner Name ein. Vergewissern Sie sich, dass Saved to disk (Auf Datenträger gespeichert) aktiviert ist, und wählen Sie dann Weiter aus. Lassen Sie das Feld CA Email Address (E-Mail der Zertifizierungsstelle) leer, da dieser Wert nicht erforderlich ist.
Geben Sie im Feld Speichern unter einen Namen für die CSR-Datei ein, und wählen Sie unter Where (Ort) den Speicherort und anschließend Speichern aus.

Dadurch wird die CSR-Datei am ausgewählten Speicherort gespeichert. Der Standardspeicherort lautet Desktop. Merken Sie sich den für diese Datei festgelegten Speicherort.

Registrieren Sie als Nächstes Ihre App bei Apple, aktivieren Sie Pushbenachrichtigungen, und laden Sie die exportierte CSR-Datei hoch, um ein Pushzertifikat zu erstellen.

Registrieren der App für Pushbenachrichtigungen

Zum Senden von Pushbenachrichtigungen an eine iOS-App registrieren Sie Ihre Anwendung bei Apple, und registrieren Sie sie auch für Pushbenachrichtigungen.

Falls Sie Ihre App noch nicht registriert haben, navigieren Sie im Apple Developer Center zum iOS-Bereitstellungsportal. Melden Sie sich mit Ihrer Apple-ID beim Portal an, und wählen Sie Identifikatoren aus. Wählen Sie dann + aus, um eine neue App zu registrieren.
Auf dem Bildschirm zum Registrieren eines neuen Bezeichners aktivieren Sie das Optionsfeld App-IDs. Wählen Sie dann Weiter aus.
Aktualisieren Sie die folgenden drei Werte für Ihre neue App, und wählen Sie dann Weiter aus:
- Beschreibung: Geben Sie einen aussagekräftigen Namen für Ihre App ein.
- Paket-ID: Geben Sie eine Paket-ID im Format Organisationsbezeichner.Produktname ein, wie im Leitfaden zur App-Verteilung erwähnt. Die unter Organization Identifier (Organisationskennung) und Product Name (Produktname) eingegebenen Werte müssen der Organisationskennung und dem Produktnamen entsprechen, die Sie beim Erstellen des Xcode-Projekts verwenden. Im folgenden Screenshot wird der Wert NotificationHubs als Organisationskennung und GetStarted als Produktname verwendet. Stellen Sie sicher, dass der Wert für den Paketbezeichner mit dem Wert in Ihrem Xcode-Projekt übereinstimmt, sodass Xcode das richtige Veröffentlichungsprofil verwendet.
- Push Notifications (Pushbenachrichtigungen): Aktivieren Sie die Option Pushbenachrichtigungen im Bereich Funktionen.
  
  Hierdurch wird Ihre App-ID generiert, und Sie werden zur Bestätigung der Daten aufgefordert. Wählen Sie Weiter und dann Registrieren aus, um die neue App-ID zu bestätigen.
  
  Nachdem Sie "Registrieren" ausgewählt haben, wird die neue App-ID als Zeilenelement auf der Seite "Zertifikate, Bezeichner und Profile " angezeigt.
Suchen Sie auf der Seite Zertifikate, Bezeichner und Profile unter Bezeichner den soeben erstellten App-ID-Eintrag und wählen Sie die entsprechende Zeile aus, um den Bildschirm zum Bearbeiten Ihrer App-ID-Konfiguration anzuzeigen.

Erstellen eines Zertifikats für Benachrichtigungshubs

Damit der Notification Hub mit APNs funktioniert, ist ein Zertifikat erforderlich. Dies kann auf eine von zwei Arten erfolgen:

Erstellen Sie eine .p12, die direkt in den Notification Hub hochgeladen werden kann.
Erstellen Sie eine P8 , die für die tokenbasierte Authentifizierung verwendet werden kann (der neuere Ansatz).

Der neuere Ansatz bietet eine Reihe von Vorteilen (im Vergleich zur Verwendung von Zertifikaten), die in der tokenbasierten Authentifizierung (HTTP/2) für APNS dokumentiert sind. Für beide Ansätze wurden jedoch Schritte bereitgestellt.

OPTION 1: Erstellen eines P12-Pushzertifikats, das direkt in den Benachrichtigungshub hochgeladen werden kann

Scrollen Sie nach unten zur aktivierten Option Pushbenachrichtigungen, und wählen Sie dann Konfigurieren aus, um das Zertifikat zu erstellen.
Das Fenster für die SSL-Zertifikate von Apple Push Notification Service wird angezeigt. Wählen Sie die Schaltfläche " Zertifikat erstellen " im Abschnitt " SSL-Zertifikat für Die Entwicklung " aus.

Der Bildschirm Ein neues Zertifikat erstellen wird angezeigt.

Hinweis

In diesem Tutorial wird ein Entwicklungszertifikat verwendet. Derselbe Prozess wird auch zum Registrieren eines Produktionszertifikats durchgeführt. Stellen Sie einfach sicher, dass Sie beim Senden von Benachrichtigungen denselben Zertifikattyp verwenden.
Wählen Sie "Datei auswählen" aus, navigieren Sie zu dem Speicherort, an dem Sie die CSR-Datei aus der ersten Aufgabe gespeichert haben, und doppelklicken Sie dann auf den Zertifikatnamen, um sie zu laden. Wählen Sie dann Weiter aus.
Wählen Sie nach der Erstellung des Zertifikats im Portal die Schaltfläche Herunterladen aus. Speichern Sie das Zertifikat, und merken Sie sich den Speicherort.

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

Hinweis

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

Hinweis

Obwohl der Name in Ihrem Zertifikat möglicherweise anders ist, wird dem Apple Development iOS Push Services der Name vorangestellt.
Klicken Sie in der Kategorie Zertifikate in der Schlüsselbundverwaltung mit der rechten Maustaste auf das neu erstellte Pushzertifikat. Wählen Sie die Option Exportieren, benennen Sie die Datei, wählen Sie das Format .p12 aus, und wählen Sie dann die Option Speichern.

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

Hinweis

Dateiname und Speicherort Ihrer P12-Datei können sich von den in diesem Tutorial abgebildeten Informationen unterscheiden.

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

Notieren Sie sich folgende Angaben:
- App-ID-Präfix (dies ist eine Team-ID)
- Bundle-ID
Klicken Sie in Zertifikate, Bezeichner und Profile auf Schlüssel.

Hinweis

Wenn Sie bereits einen Schlüssel für APNs konfiguriert haben, können Sie das P8-Zertifikat wiederverwenden, das Sie direkt nach der Erstellung heruntergeladen haben. Wenn ja, können Sie die Schritte 3 bis 5 ignorieren.
Klicken Sie auf die Schaltfläche + (oder die Schaltfläche Schlüssel erstellen), um einen neuen Schlüssel zu erstellen.
Geben Sie einen geeigneten Schlüsselnamenwert 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 "Herunterladen ", und verschieben Sie dann die P8-Datei (mit dem Präfix "AuthKey_") in ein sicheres lokales Verzeichnis, und klicken Sie dann auf "Fertig".

Hinweis

Bewahren Sie die P8-Datei an einem sicheren Ort auf (und speichern Sie eine Sicherungskopie). Nach dem Herunterladen des Schlüssels kann er nicht erneut heruntergeladen werden, wenn die Serverkopie entfernt wird.
Klicken Sie unter Schlüssel auf den gerade erstellten Schlüssel (oder auf einen vorhandenen Schlüssel, falls Sie stattdessen einen solchen verwenden möchten).
Notieren Sie sich den Wert der Schlüssel-ID.
Öffnen Sie Ihr P8-Zertifikat in einer geeigneten Anwendung Ihrer Wahl, z. B. Visual Studio Code , und notieren Sie sich dann den Schlüsselwert. Dies ist der Wert zwischen -----BEGIN PRIVATE KEY----- und -----END PRIVATE KEY----- .
```
-----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----
```
Hinweis

Dies ist der Tokenwert , der später zum Konfigurieren des Benachrichtigungshubs verwendet wird.

Am Ende dieser Schritte sollten Sie die folgenden Informationen zur späteren Nutzung unter Configuration des Benachrichtigungshubs mit APNs-Informationen haben:

Team-ID (siehe Schritt 1)
Bundle-ID (siehe Schritt 1)
Schlüssel-ID (siehe Schritt 7)
Tokenwert , d. h. der P8-Schlüsselwert (siehe Schritt 8)

Erstellen eines Bereitstellungsprofils für die App

Wechseln Sie zurück zum iOS-Bereitstellungsportal, wählen Sie Zertifikate, Bezeichner und Profile aus, wählen Sie im Menü auf der linken Seite Profile und dann + aus, um ein neues Profil zu erstellen. Der Bildschirm zum Registrieren eines neuen Bereitstellungsprofils wird angezeigt.
Wählen Sie unter Entwicklung, die Option iOS-App-Entwicklung als Bereitstellungsprofiltyp aus, und wählen Sie anschließend Weiter.
Wählen Sie als Nächstes die App-ID aus, die Sie in der Dropdownliste "App-ID " erstellt haben, und wählen Sie "Weiter" aus.
Wählen Sie im Fenster Certifikates auswählen (Select certificates) das Entwicklungszertifikat aus, das Sie für die Code-Signierung verwenden, und wählen Sie dann Weiter (Continue). Dieses Zertifikat ist nicht das Pushzertifikat, das Sie erstellt haben. Wenn keines vorhanden ist, müssen Sie es erstellen. Wenn ein Zertifikat vorhanden ist, fahren Sie mit dem nächsten Schritt fort. Erstellen eines Entwicklungszertifikat, wenn noch keines vorhanden ist:
1. Wenn No Certificates are available (Keine Zertifikate verfügbar) angezeigt wird, wählen Sie Create Certificate (Zertifikat erstellen) aus.
2. Wählen Sie im Abschnitt Software die Option Apple Development (Apple-Entwicklung) aus. Wählen Sie dann Weiter aus.
3. Wählen Sie auf dem Bildschirm Neues Zertifikat erstellen die Option Datei auswählen.
4. Navigieren Sie zum Zertifikat Zertifikatsignieranforderung, das Sie zuvor erstellt haben, wählen Sie es aus, und wählen Sie dann Öffnen aus.
5. Wählen Sie Weiter aus.
6. Laden Sie das Entwicklungszertifikat herunter, und merken Sie sich den Speicherort, an dem es gespeichert ist.
Wechseln Sie zurück zur Seite Zertifikate, Bezeichner und Profile, wählen Sie im Menü auf der linken Seite Profile und dann + aus, um ein neues Profil zu erstellen. Der Bildschirm zum Registrieren eines neuen Bereitstellungsprofils wird angezeigt.
Wählen Sie im Fenster Select certificates (Zertifikate auswählen) das soeben erstellte Entwicklungszertifikat aus. Wählen Sie dann Weiter aus.
Wählen Sie nun die Geräte aus, die zum Testen verwendet werden sollen, und wählen Sie dann Weiter aus.
Wählen Sie schließlich einen Namen für das Profil im Bereitstellungsprofilnamen aus, und wählen Sie "Generieren" aus.
Nachdem das neue Bereitstellungsprofil erstellt wurde, wählen Sie Herunterladen aus. Denken Sie an den Speicherort, an dem sie gespeichert ist.
Navigieren Sie zum Speicherort des Bereitstellungsprofils, und doppelklicken Sie darauf, um es auf dem Xcode-Entwicklungscomputer zu installieren.

Erstellen eines Benachrichtigungshubs

In diesem Abschnitt erstellen Sie einen Benachrichtigungshub und konfigurieren die Authentifizierung mit APNs mithilfe des P12-Pushzertifikats oder der tokenbasierten Authentifizierung. Wenn Sie einen bereits erstellten Notification Hub verwenden möchten, können Sie mit Schritt 5 fortfahren.

Melden Sie sich beim Azure-Portal an.
Wählen Sie im Menü auf der linken Seite die Option Alle Dienste und dann im Abschnitt Mobil die Option Notification Hubs aus. Wählen Sie das Sternsymbol neben dem Dienstnamen aus, um den Dienst im linken Menü zum Abschnitt FAVORITEN hinzuzufügen. Nachdem Sie Benachrichtigungshubs zu FAVORITEN hinzugefügt haben, wählen Sie sie im linken Menü aus.
Wählen Sie auf der Seite Notification Hubs in der Symbolleiste die Option Hinzufügen.
Führen Sie auf der Seite "Notification Hub " die folgenden Schritte aus:
1. Geben Sie ins Feld Notification Hub einen Namen ein.
2. Geben Sie ins Feld Neuen Namespace erstellen einen Namen ein. Ein Namespace enthält einen oder mehrere Hubs.
3. Wählen Sie im Dropdown-Listenfeld Standort einen Wert aus. Dieser Wert gibt den Standort an, an dem der Hub erstellt werden soll.
4. Wählen Sie eine vorhandene Ressourcengruppe in der Ressourcengruppe aus, oder erstellen Sie einen Namen für eine neue Ressourcengruppe.
5. Klicken Sie auf Erstellen.
Wählen Sie Benachrichtigungen (Glockensymbol) und dann Zu Ressource wechseln aus. Sie können auch die Liste auf der Seite Notification Hubs aktualisieren und Ihren Hub auswählen.
Wählen Sie in der Liste die Option Zugriffsrichtlinien aus. Beachten Sie, dass Ihnen die beiden Verbindungszeichenfolgen zur Verfügung stehen. Sie werden später für die Behandlung von Pushbenachrichtigungen benötigt.

Von Bedeutung

Verwenden Sie die DefaultFullSharedAccessSignature-Richtlinienicht in Ihrer Anwendung. Diese ist nur für die Verwendung in Ihrem Back-End vorgesehen.

Konfigurieren des Benachrichtigungshubs mit APNs-Informationen

Wählen Sie unter BenachrichtigungsdiensteApple (APNS) aus, und führen Sie dann die entsprechenden Schritte basierend auf dem Ansatz aus, den Sie zuvor im Abschnitt "Erstellen eines Zertifikats für Benachrichtigungshubs " ausgewählt haben.

Hinweis

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

OPTION 1: Verwenden eines .p12-Push-Zertifikats

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

OPTION 2: Verwenden der tokenbasierten Authentifizierung

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

Sie haben nun Ihren Benachrichtigungshub mit APNs konfiguriert. Außerdem verfügen Sie über die Verbindungszeichenfolgen, um Ihre App zu registrieren und Pushbenachrichtigungen zu senden.

Konfigurieren des Benachrichtigungshubs für APNS

Starten Sie auf Ihrem Mac Keychain Access. Öffnen Sie auf der linken Navigationsleiste unter KategorieMeine Zertifikate. Suchen Sie das SSL-Zertifikat, das Sie im vorherigen Abschnitt heruntergeladen haben, und geben Sie dann deren Inhalte offen. Wählen Sie nur das Zertifikat aus (nicht den privaten Schlüssel auswählen). dannexportieren.
Wählen Sie im Azure-PortalAlle durchsuchen>App Services aus. Wählen Sie dann Ihr Mobile Apps-Back-End aus.
Unter Einstellungenwählen Sie App Service Push-aus. Wählen Sie dann Ihren Benachrichtigungshubnamen aus.
Wechseln Sie zu Apple Push Notification Services>Hochladen des Zertifikats. Laden Sie die .p12-Datei hoch, und wählen Sie den richtigen Modus aus (je nachdem, ob Ihr Client-SSL-Zertifikat zuvor für die Produktion oder die Sandbox verwendet wurde). Speichern Sie alle Änderungen.

Ihr Dienst ist jetzt für die Arbeit mit Pushbenachrichtigungen unter iOS konfiguriert.

Als Nächstes konfigurieren Sie die iOS-Projekteinstellung in Xamarin Studio oder Visual Studio.

Konfigurieren des iOS-Projekts in Xamarin Studio

Öffnen Sie in Xamarin.Studio Info.plist, und aktualisieren Sie den Bündelbezeichner mit der Bündel-ID, die Sie zuvor mit Ihrer neuen App-ID erstellt haben.
Scrollen Sie nach unten zu Hintergrundmodi. Aktivieren Sie das Feld "Hintergrundmodi aktivieren " und das Feld "Remotebenachrichtigungen ".
Doppelklicken Sie im Projektmappenbereich auf Ihr Projekt, um Projektoptionen zu öffnen.
Wählen Sie unter "Build" die Option "iOS Bundle Signing" aus, und wählen Sie das entsprechende Identitäts- und Bereitstellungsprofil aus, das Sie soeben für dieses Projekt eingerichtet haben.

Dadurch wird sichergestellt, dass das Projekt das neue Profil für die Code-Signierung verwendet. Die offizielle Xamarin-Gerätebereitstellungsdokumentation finden Sie unter Xamarin Device Provisioning.

Konfigurieren des iOS-Projekts in Visual Studio

Klicken Sie in Visual Studio mit der rechten Maustaste auf das Projekt, und klicken Sie dann auf "Eigenschaften".
Klicken Sie auf den Eigenschaftenseiten auf die Registerkarte "iOS-Anwendung ", und aktualisieren Sie den Bezeichner mit der ID, die Sie zuvor erstellt haben.
Wählen Sie auf der Registerkarte "iOS Bundle Signing " das entsprechende Identitäts- und Bereitstellungsprofil aus, das Sie soeben für dieses Projekt eingerichtet haben.

Dadurch wird sichergestellt, dass das Projekt das neue Profil für die Code-Signierung verwendet. Die offizielle Xamarin-Gerätebereitstellungsdokumentation finden Sie unter Xamarin Device Provisioning.
Doppelklicken Sie auf "Info.plist", um sie zu öffnen, und aktivieren Sie remoteNotifications unter "Hintergrundmodi".

Hinzufügen von Pushbenachrichtigungen zu Ihrer iOS-App

Öffnen Sie im iOS-Projekt AppDelegate.cs, und fügen Sie die folgende Anweisung am Anfang der Codedatei hinzu.
```
using Newtonsoft.Json.Linq;
```

Fügen Sie in der AppDelegate-Klasse eine Außerkraftsetzung für das RegisteredForRemoteNotifications-Ereignis hinzu, um sich für Benachrichtigungen zu registrieren:

public override void RegisteredForRemoteNotifications(UIApplication application,
    NSData deviceToken)
{
    const string templateBodyAPNS = "{\"aps\":{\"alert\":\"$(messageParam)\"}}";

    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
        {
            {"body", templateBodyAPNS}
        };

    // Register for push with your mobile app
    Push push = TodoItemManager.DefaultManager.CurrentClient.GetPush();
    push.RegisterAsync(deviceToken, templates);
}

Fügen Sie in AppDelegate auch die folgende Überschreibung für den DidReceiveRemoteNotification-Ereignishandler hinzu:

public override void DidReceiveRemoteNotification(UIApplication application,
    NSDictionary userInfo, Action<UIBackgroundFetchResult> completionHandler)
{
    NSDictionary aps = userInfo.ObjectForKey(new NSString("aps")) as NSDictionary;

    string alert = string.Empty;
    if (aps.ContainsKey(new NSString("alert")))
        alert = (aps[new NSString("alert")] as NSString).ToString();

    //show alert
    if (!string.IsNullOrEmpty(alert))
    {
        UIAlertView avAlert = new UIAlertView("Notification", alert, null, "OK", null);
        avAlert.Show();
    }
}

Diese Methode behandelt eingehende Benachrichtigungen, während die App ausgeführt wird.

Fügen Sie in der AppDelegate-Klasse der FinishedLaunching-Methode den folgenden Code hinzu:

// Register for push notifications.
var settings = UIUserNotificationSettings.GetSettingsForTypes(
    UIUserNotificationType.Alert
    | UIUserNotificationType.Badge
    | UIUserNotificationType.Sound,
    new NSSet());

UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
UIApplication.SharedApplication.RegisterForRemoteNotifications();

Dies ermöglicht die Unterstützung für Remotebenachrichtigungen und fordert Push-Registrierungen an.

Ihre App wird jetzt aktualisiert, um Pushbenachrichtigungen zu unterstützen.

Testen von Pushbenachrichtigungen in Ihrer iOS-App

Klicken Sie mit der rechten Maustaste auf das iOS-Projekt, und klicken Sie dann auf "Als Startprojekt festlegen".
Drücken Sie die Schaltfläche "Ausführen " oder F5 in Visual Studio, um das Projekt zu erstellen und die App auf einem iOS-Gerät zu starten. Klicken Sie dann auf "OK ", um Pushbenachrichtigungen zu akzeptieren.

Hinweis

Sie müssen Pushbenachrichtigungen explizit von Ihrer App akzeptieren. Diese Anforderung tritt nur bei der ersten Ausführung der App auf.
Geben Sie in der App eine Aufgabe ein, und klicken Sie dann auf das Plussymbol (+).
Überprüfen Sie, ob eine Benachrichtigung empfangen wurde, und klicken Sie dann auf "OK ", um die Benachrichtigung zu schließen.

Konfigurieren und Ausführen von Windows-Projekten (optional)

In diesem Abschnitt werden die Projekte "Xamarin.Forms WinApp" und "WinPhone81" für Windows-Geräte ausgeführt. Diese Schritte unterstützen auch UWP-Projekte (Universelle Windows-Plattform). Sie können diesen Abschnitt überspringen, wenn Sie nicht mit Windows-Geräten arbeiten.

Registrieren Ihrer Windows-App für Pushbenachrichtigungen mit dem Windows-Benachrichtigungsdienst (Windows Notification Service, WNS)

Klicken Sie im Projektmappen-Explorer von Visual Studio mit der rechten Maustaste auf das Windows Store-App-Projekt. Wählen Sie dann Store>App mit dem Store verknüpfen.
Wählen Sie im Assistenten Weiter aus. Melden Sie sich dann mit Ihrem Microsoft-Konto an. Geben Sie unter "Neuen App-Namen reservieren" einen Namen für Ihre App ein, und wählen Sie dann " Reservieren" aus.
Nachdem die App-Registrierung erfolgreich erstellt wurde, wählen Sie den neuen App-Namen aus. Wählen Sie "Weiter" und dann "Zuordnen" aus. Dieser Vorgang fügt dem Anwendungsmanifest die erforderlichen Windows Store-Registrierungsinformationen hinzu.
Wiederholen Sie die Schritte 1 und 3 für das Windows Phone Store-App-Projekt, indem Sie dieselbe Registrierung verwenden, die Sie zuvor für die Windows Store-App erstellt haben.
Wechseln Sie zum Windows Dev Center, und melden Sie sich dann mit Ihrem Microsoft-Konto an. Wählen Sie in "Meine Apps" die neue App-Registrierung aus. Erweitern Sie dann Dienste>Pushbenachrichtigungen.
Wählen Sie auf der Seite "Pushbenachrichtigungen" unter Windows-Pushbenachrichtigungsdienste(Windows Push Notification Services, WNS) und Microsoft Azure Mobile Apps die Website "Live Services" aus. Notieren Sie sich die Werte der Paket-SID und den aktuellen Wert im Geheimen Anwendungsschlüssel.

Von Bedeutung

Das Anwendungsgeheimnis und die Paket-SID sind wichtige Sicherheitsanmeldeinformationen. Teilen Sie diese Werte nicht mit anderen Personen, oder verteilen Sie sie mit Ihrer App.

Konfigurieren des Benachrichtigungshubs für WNS

Wählen Sie im Azure-PortalAlle durchsuchen>App Services aus. Wählen Sie dann Ihr Mobile Apps-Back-End aus. Unter Einstellungenwählen Sie App Service Push-aus. Wählen Sie dann Ihren Benachrichtigungshubnamen aus.
Wechseln Sie zu Windows (WNS). Geben Sie dann den Sicherheitsschlüssel (geheimer Clientschlüssel) und die Paket-SID ein, die Sie von der Live Services-Website erhalten haben. Wählen Sie als Nächstes "Speichern" aus.

Ihr Back-End ist jetzt für die Verwendung von WNS zum Senden von Pushbenachrichtigungen konfiguriert.

Hinzufügen von Pushbenachrichtigungen zu Ihrer Windows-App

Öffnen Sie in Visual Studio App.xaml.cs in einem Windows-Projekt, und fügen Sie die folgenden Anweisungen hinzu.
```
using Newtonsoft.Json.Linq;
using Microsoft.WindowsAzure.MobileServices;
using System.Threading.Tasks;
using Windows.Networking.PushNotifications;
using <your_TodoItemManager_portable_class_namespace>;
```
Ersetzen Sie <your_TodoItemManager_portable_class_namespace> durch den Namespace Ihres portablen Projekts, das die TodoItemManager Klasse enthält.

Fügen Sie in App.xaml.cs die folgende InitNotificationsAsync-Methode hinzu:

private async Task InitNotificationsAsync()
{
    var channel = await PushNotificationChannelManager
        .CreatePushNotificationChannelForApplicationAsync();

    const string templateBodyWNS =
        "<toast><visual><binding template=\"ToastText01\"><text id=\"1\">$(messageParam)</text></binding></visual></toast>";

    JObject headers = new JObject();
    headers["X-WNS-Type"] = "wns/toast";

    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
    {
        {"body", templateBodyWNS},
        {"headers", headers} // Needed for WNS.
    };

    await TodoItemManager.DefaultManager.CurrentClient.GetPush()
        .RegisterAsync(channel.Uri, templates);
}

Diese Methode ruft den Push-Benachrichtigungskanal ab und registriert eine Vorlage zum Empfangen von Vorlagenbenachrichtigungen vom Benachrichtigungs-Hub. Eine Vorlagenbenachrichtigung, die messageParam unterstützt, wird an diesen Client übermittelt.

Aktualisieren Sie in App.xaml.cs die OnLaunched-Ereignishandlermethodendefinition , indem Sie den async Modifizierer hinzufügen. Fügen Sie dann die folgende Codezeile am Ende der Methode hinzu:
```
await InitNotificationsAsync();
```
Dadurch wird sichergestellt, dass die Pushbenachrichtigungsregistrierung bei jedem Start der App erstellt oder aktualisiert wird. Dies ist wichtig, um sicherzustellen, dass der WNS-Pushkanal immer aktiv ist.
Öffnen Sie im Projektmappen-Explorer für Visual Studio die Datei "Package.appxmanifest", und legen Sie "Toast-fähig" unter "Benachrichtigungen" auf "Ja" fest.
Erstellen Sie die App, und vergewissern Sie sich, dass keine Fehler aufgetreten sind. Ihre Client-App sollte sich jetzt für die Vorlagenbenachrichtigungen aus dem Back-End mobiler Apps registrieren. Wiederholen Sie diesen Abschnitt für jedes Windows-Projekt in Ihrer Projektmappe.

Testen von Pushbenachrichtigungen in Ihrer Windows-App

Klicken Sie in Visual Studio mit der rechten Maustaste auf ein Windows-Projekt, und klicken Sie dann auf "Als Startprojekt festlegen".
Drücken Sie die Schaltfläche "Ausführen ", um das Projekt zu erstellen und die App zu starten.
Geben Sie in der App einen Namen für ein neues Todoitem ein, und klicken Sie dann auf das Plussymbol (+), um es hinzuzufügen.
Überprüfen Sie, ob eine Benachrichtigung empfangen wird, wenn das Element hinzugefügt wird.

Nächste Schritte

Weitere Informationen zu Pushbenachrichtigungen finden Sie unter:

Senden von Pushbenachrichtigungen von Azure Mobile Apps
Firebase Cloud Messaging
Remotebenachrichtigungen mit Firebase Cloud Messaging
Diagnostizieren von Problemen mit Pushbenachrichtigungen
Es gibt verschiedene Gründe, warum Benachrichtigungen gelöscht werden oder nicht auf Geräten enden. In diesem Thema erfahren Sie, wie Sie die Ursache von Pushbenachrichtigungsfehlern analysieren und ermitteln.

Sie können auch mit einem der folgenden Lernprogramme fortfahren:

Hinzufügen der Authentifizierung zu Ihrer App
Erfahren Sie, wie Sie Benutzer Ihrer App mit einem Identitätsanbieter authentifizieren.
Aktivieren der Offlinesynchronisierung für Ihre App
Erfahren Sie, wie Sie Offlineunterstützung für Ihre App mithilfe eines Back-Ends für mobile Apps hinzufügen. Bei der Offlinesynchronisierung können Benutzer mit einer mobilen App interagieren – Anzeigen, Hinzufügen oder Ändern von Daten – auch wenn keine Netzwerkverbindung vorhanden ist.

Last updated on 2019-06-25

Freigeben über