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

Überblick

In diesem Lernprogramm fügen Sie dem Schnellstartprojekt Xamarin.Android Pushbenachrichtigungen hinzu, sodass bei jedem Einfügen eines Datensatzes eine Pushbenachrichtigung an das Gerät gesendet wird.

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

Voraussetzungen

Für dieses Lernprogramm ist das Setup erforderlich:

Ein aktives Google-Konto. Sie können sich bei accounts.google.com für ein Google-Konto registrieren.
Google Cloud Messaging-Clientkomponente.

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-Portal zu App Services, und wählen Sie dann Ihr App-Back-End aus. Wählen Sie unter "Einstellungen" "Push" aus.
Um der App eine Benachrichtigungshubressource hinzuzufügen, wählen Sie "Verbinden" aus. 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.

Aktivieren von Firebase Cloud Messaging

Melden Sie sich bei der Firebase-Konsole an. Erstellen Sie ein neues Firebase-Projekt, falls Sie noch keins besitzen.
Nachdem Sie Ihr Projekt erstellt haben, wählen Sie "Firebase zu Ihrer Android-App hinzufügen" aus.
Führen Sie auf der Seite "Firebase hinzufügen" zu Ihrer Android-App die folgenden Schritte aus:
1. Kopieren Sie für den Namen des Android-Pakets den Wert Ihrer applicationId in der Datei "build.gradle" Ihrer Anwendung. In diesem Beispiel ist es com.fabrikam.fcmtutorial1app.
2. Wählen Sie "App registrieren" aus.
Wählen Sie "google-services.jsonherunterladen " aus, speichern Sie die Datei im App-Ordner Ihres Projekts, und wählen Sie dann "Weiter" aus.
Nehmen Sie die folgenden Konfigurationsänderungen an Ihrem Projekt in Android Studio vor.
1. Fügen Sie in der Datei "build.gradle" auf Projektebene (<Project>/build.gradle) die folgende Anweisung zum Abschnitt "Abhängigkeiten" hinzu.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Fügen Sie in der Datei "build.gradle" auf App-Ebene (<Project>/<app-module>/build.gradle) die folgenden Anweisungen zum Abschnitt "Abhängigkeiten" 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 "Jetzt synchronisieren" auf der Symbolleiste aus.
Wählen Sie "Weiter" aus.
Wählen Sie "Diesen Schritt überspringen" aus.
Klicken Sie in der Firebase-Konsole auf das Zahnrad für Ihr Projekt. Wählen Sie dann "Projekteinstellungen" aus.
Wenn Sie die google-services.json Datei nicht in den App-Ordner 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 die spätere Verwendung. Verwenden Sie diesen Wert zum Konfigurieren Ihres Hubs.

Konfigurieren von Azure zum Senden von Pushanforderungen

Klicken Sie im Azure-Portal auf "Alle>App-Dienste durchsuchen", und klicken Sie dann auf Das Back-End Ihrer mobilen Apps. Klicken Sie unter "Einstellungen" auf "App Service Push" und dann auf den Namen des Benachrichtigungshubs.
Wechseln Sie zu Google (GCM), geben Sie den Serverschlüsselwert ein, den Sie aus Firebase im vorherigen Verfahren erhalten haben, und klicken Sie dann auf "Speichern".

Das Backend der mobilen Apps ist jetzt für die Verwendung des Firebase Cloud Messaging konfiguriert. Auf diese Weise können Sie Pushbenachrichtigungen mithilfe des Benachrichtigungshubs an Ihre App senden, die auf einem Android-Gerät ausgeführt wird.

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 des Clientprojekts für Pushbenachrichtigungen

Klicken Sie in der Projektmappenansicht (oder im Projektmappen-Explorer in Visual Studio) mit der rechten Maustaste auf den Ordner "Komponenten ", klicken Sie auf " Weitere Komponenten abrufen", suchen Sie nach der Komponente "Google Cloud Messaging Client ", und fügen Sie sie dem Projekt hinzu.
Öffnen Sie die ToDoActivity.cs Projektdatei, und fügen Sie der Klasse die folgende using-Anweisung hinzu:
```
using Gcm.Client;
```

Fügen Sie in der ToDoActivity-Klasse den folgenden neuen Code hinzu:

// Create a new instance field for this activity.
static ToDoActivity instance = new ToDoActivity();

// Return the current activity instance.
public static ToDoActivity CurrentActivity
{
    get
    {
        return instance;
    }
}
// Return the Mobile Services client.
public MobileServiceClient CurrentClient
{
    get
    {
        return client;
    }
}

Auf diese Weise können Sie über den Pushhandlerdienstprozess auf die mobile Clientinstanz zugreifen.

Fügen Sie der OnCreate-Methode den folgenden Code hinzu, nachdem der MobileServiceClient erstellt wurde:

// Set the current instance of TodoActivity.
instance = this;

// Make sure the GCM client is set up correctly.
GcmClient.CheckDevice(this);
GcmClient.CheckManifest(this);

// Register the app for push notifications.
GcmClient.Register(this, ToDoBroadcastReceiver.senderIDs);

Ihre ToDoActivity ist jetzt für das Hinzufügen von Pushbenachrichtigungen vorbereitet.

Hinzufügen von Pushbenachrichtigungscode zu Ihrer App

Erstellen Sie eine neue Klasse im Projekt namens ToDoBroadcastReceiver.

Fügen Sie die folgenden using-Anweisungen zur ToDoBroadcastReceiver-Klasse hinzu :

using Gcm.Client;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;

Fügen Sie die folgenden Berechtigungsanforderungen zwischen den using-Anweisungen und der Namespacedeklaration hinzu:

[assembly: Permission(Name = "@PACKAGE_NAME@.permission.C2D_MESSAGE")]
[assembly: UsesPermission(Name = "@PACKAGE_NAME@.permission.C2D_MESSAGE")]
[assembly: UsesPermission(Name = "com.google.android.c2dm.permission.RECEIVE")]
//GET_ACCOUNTS is only needed for android versions 4.0.3 and below
[assembly: UsesPermission(Name = "android.permission.GET_ACCOUNTS")]
[assembly: UsesPermission(Name = "android.permission.INTERNET")]
[assembly: UsesPermission(Name = "android.permission.WAKE_LOCK")]

Ersetzen Sie die vorhandene ToDoBroadcastReceiver-Klassendefinition durch Folgendes:

[BroadcastReceiver(Permission = Gcm.Client.Constants.PERMISSION_GCM_INTENTS)]
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_MESSAGE }, 
    Categories = new string[] { "@PACKAGE_NAME@" })]
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_REGISTRATION_CALLBACK }, 
    Categories = new string[] { "@PACKAGE_NAME@" })]
[IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_LIBRARY_RETRY }, 
Categories = new string[] { "@PACKAGE_NAME@" })]
public class ToDoBroadcastReceiver : GcmBroadcastReceiverBase<PushHandlerService>
{
    // Set the Google app ID.
    public static string[] senderIDs = new string[] { "<PROJECT_NUMBER>" };
}

Im obigen Code müssen Sie "<PROJECT_NUMBER>" durch die Projektnummer ersetzen, die Google Ihnen zugewiesen hat, als Sie Ihre App im Google-Entwicklerportal eingerichtet haben.

Fügen Sie in der projektdatei ToDoBroadcastReceiver.cs den folgenden Code hinzu, der die PushHandlerService-Klasse definiert:
```
// The ServiceAttribute must be applied to the class.
[Service]
public class PushHandlerService : GcmServiceBase
{
    public static string RegistrationID { get; private set; }
    public PushHandlerService() : base(ToDoBroadcastReceiver.senderIDs) { }
}
```
Beachten Sie, dass diese Klasse von GcmServiceBase abgeleitet ist und dass das Service-Attribut auf diese Klasse angewendet werden muss.

Hinweis

Die GcmServiceBase-Klasse implementiert die Methoden OnRegistered(), OnUnRegistered(), OnMessage() und OnError(). Sie müssen diese Methoden in der PushHandlerService-Klasse überschreiben.

Fügen Sie der PushHandlerService-Klasse den folgenden Code hinzu, der den OnRegistered-Ereignishandler überschreibt.

protected override void OnRegistered(Context context, string registrationId)
{
    System.Diagnostics.Debug.WriteLine("The device has been registered with GCM.", "Success!");

    // Get the MobileServiceClient from the current activity instance.
    MobileServiceClient client = ToDoActivity.CurrentActivity.CurrentClient;
    var push = client.GetPush();

    // Define a message body for GCM.
    const string templateBodyGCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";

    // Define the template registration as JSON.
    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
    {
        {"body", templateBodyGCM }
    };

    try
    {
        // Make sure we run the registration on the same thread as the activity, 
        // to avoid threading errors.
        ToDoActivity.CurrentActivity.RunOnUiThread(

            // Register the template with Notification Hubs.
            async () => await push.RegisterAsync(registrationId, templates));

        System.Diagnostics.Debug.WriteLine(
            string.Format("Push Installation Id", push.InstallationId.ToString()));
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(
            string.Format("Error with Azure push registration: {0}", ex.Message));
    }
}

Diese Methode verwendet die zurückgegebene GCM-Registrierungs-ID, um sich bei Azure für Pushbenachrichtigungen zu registrieren. Tags können erst nach der Erstellung der Registrierung hinzugefügt werden. Weitere Informationen finden Sie unter So fügen Sie einer Geräteinstallation Tags hinzu, um "Push-to-Tags" zu aktivieren.

Überschreiben Sie die OnMessage-Methode in PushHandlerService mit dem folgenden Code:

protected override void OnMessage(Context context, Intent intent)
{
    string message = string.Empty;

    // Extract the push notification message from the intent.
    if (intent.Extras.ContainsKey("message"))
    {
        message = intent.Extras.Get("message").ToString();
        var title = "New item added:";

        // Create a notification manager to send the notification.
        var notificationManager = 
            GetSystemService(Context.NotificationService) as NotificationManager;

        // Create a new intent to show the notification in the UI. 
        PendingIntent contentIntent =
            PendingIntent.GetActivity(context, 0,
            new Intent(this, typeof(ToDoActivity)), 0);

        // Create the notification using the builder.
        var builder = new Notification.Builder(context);
        builder.SetAutoCancel(true);
        builder.SetContentTitle(title);
        builder.SetContentText(message);
        builder.SetSmallIcon(Resource.Drawable.ic_launcher);
        builder.SetContentIntent(contentIntent);
        var notification = builder.Build();

        // Display the notification in the Notifications Area.
        notificationManager.Notify(1, notification);

    }
}

Überschreiben Sie die Methoden OnUnRegistered() und OnError() mit dem folgenden Code.

protected override void OnUnRegistered(Context context, string registrationId)
{
    throw new NotImplementedException();
}

protected override void OnError(Context context, string errorId)
{
    System.Diagnostics.Debug.WriteLine(
        string.Format("Error occurred in the notification: {0}.", errorId));
}

Testen von Pushbenachrichtigungen in Ihrer App

Sie können die App mithilfe eines virtuellen Geräts im Emulator testen. Es sind zusätzliche Konfigurationsschritte erforderlich, wenn sie auf einem Emulator ausgeführt werden.

Das virtuelle Gerät muss Google-APIs als Ziel im AvD-Manager (Android Virtual Device) festlegen.
Fügen Sie dem Android-Gerät ein Google-Konto hinzu, indem Sie auf Apps>Einstellungen>Konto hinzufügen klicken und dann den Anweisungen folgen.
Führen Sie die To-do-Liste-App wie vorher aus, und fügen Sie eine neue Aufgabe ein. Dieses Mal wird im Infobereich ein Benachrichtigungssymbol angezeigt. Sie können die Benachrichtigungsschublade öffnen, um den vollständigen Text der Benachrichtigung anzuzeigen.

Last updated on 2019-06-25

Freigeben über