Freigeben über

Hinzufügen von Pushbenachrichtigungen zu Ihrer Android-App

Überblick

In diesem Lernprogramm fügen Sie dem Android-Schnellstartprojekt Pushbenachrichtigungen hinzu, sodass jedes Mal, wenn ein Datensatz eingefügt wird, 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 unter Arbeiten mit dem .NET-Back-End-Server-SDK für Azure Mobile Apps.

Voraussetzungen

Sie benötigen Folgendes:

  • Eine IDE, abhängig vom Back-End Ihres Projekts:

  • Android 2.3 oder höher, Google Repository Revision 27 oder höher, und Google Play Services 9.0.2 oder höher für Firebase Cloud Messaging.

  • Schließen Sie den Android-Schnellstart ab.

Erstellen eines Projekts, das Firebase Cloud Messaging unterstützt

  1. Melden Sie sich bei der Firebase-Konsole an. Erstellen Sie ein neues Firebase-Projekt, falls Sie noch keins besitzen.

  2. Klicken Sie nach der Erstellung Ihres Projekts auf Add Firebase to your Android app (Firebase der Android-App hinzufügen).

    Hinzufügen von Firebase zu Ihrer Android-App

  3. 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.

      Angeben des Paketnamens

    2. Wählen Sie Register app (App registrieren) aus.

  4. 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).

    Herunterladen von „google-services.json“

  5. 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.

      Konfigurationsänderungen an „build.gradle“

  6. Wählen Sie Weiteraus.

  7. Klicken Sie auf Diesen Schritt überspringen.

    Den letzten Schritt überspringen

  8. Klicken Sie in der Firebase-Konsole auf das Zahnrad für Ihr Projekt. Klicken Sie dann auf Projekteinstellungen.

    Klicken auf „Projekteinstellungen“

  9. 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.

  10. Wechseln Sie oben zur Registerkarte Cloud Messaging.

  11. Kopieren und speichern Sie den Serverschlüssel für eine spätere Verwendung. Verwenden Sie diesen Wert zum Konfigurieren Ihres Hubs.

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.

  1. Wechseln Sie im Azure-Portalzu App Services, und wählen Sie dann Ihr App-Back-End aus. Wählen Sie unter Einstellungendie Option Pushaus.

  2. 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.

    Konfigurieren eines Hub-

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.

Konfigurieren von Azure zum Senden von Pushbenachrichtigungen

  1. 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.

  2. 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".

    Festlegen des API-Schlüssels im Portal

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.

Aktivieren von Pushbenachrichtigungen für das Serverprojekt

Verwenden Sie die Prozedur, die Ihrem Back-End-Projekttyp entspricht – entweder .NET Back-End oder Node.js Back-End.

.NET-Back-End-Projekt

  1. Klicken Sie in Visual Studio mit der rechten Maustaste auf das Serverprojekt, und klicken Sie auf "NuGet-Pakete verwalten". Suchen Sie Microsoft.Azure.NotificationHubs und klicken Sie dann auf Installieren. Dadurch wird die Clientbibliothek für Benachrichtigungshubs installiert.

  2. Öffnen Sie im Ordner "Controller" TodoItemController.cs, und fügen Sie die folgenden using Anweisungen hinzu:

    using Microsoft.Azure.Mobile.Server.Config;
using Microsoft.Azure.NotificationHubs;

  3. Ersetzen Sie die PostTodoItem-Methode durch folgenden Code:

    public async Task<IHttpActionResult> PostTodoItem(TodoItem item)
{
    TodoItem current = await InsertAsync(item);
    // 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);

    // Android payload
    var androidNotificationPayload = "{ \"data\" : {\"message\":\"" + item.Text + "\"}}";

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

        // 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");
    }
    return CreatedAtRoute("Tables", new { id = current.Id }, current);
}

  4. Veröffentlichen Sie das Serverprojekt erneut.

Node.js Backend-Projekt

  1. Richten Sie Ihr Back-End-Projekt ein.

  2. Ersetzen Sie den vorhandenen Code in der datei todoitem.js durch Folgendes:

    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 GCM payload.
var payload = {
    "data": {
        "message": 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 GCM native notification.
            context.push.gcm.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;

    Dadurch wird eine GCM-Benachrichtigung gesendet, die den Element.text enthält, wenn ein neues Todo-Element eingefügt wird.

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

Hinzufügen von Pushbenachrichtigungen zu Ihrer App

In diesem Abschnitt aktualisieren Sie Ihre Android-Client-App, um Pushbenachrichtigungen zu verarbeiten.

Überprüfen der Android SDK-Version

Aufgrund der fortlaufenden Entwicklung entspricht die in Android Studio installierte Android SDK-Version möglicherweise nicht der Version im Code. Das Android SDK, auf das in diesem Lernprogramm verwiesen wird, ist Version 26, die neueste zum Zeitpunkt des Schreibens. Die Versionsnummer kann sich erhöhen, wenn neue Versionen des SDK angezeigt werden, und wir empfehlen die Verwendung der neuesten verfügbaren Version.

Zwei Symptome eines Versionskonflikts sind:

  • Wenn Sie das Projekt erstellen oder neu erstellen, erhalten Sie möglicherweise Gradle-Fehlermeldungen wie Gradle sync failed: Failed to find target with hash string 'android-XX'.
  • Standardmäßige Android-Objekte im Code, die basierend auf import Anweisungen aufgelöst werden sollen, können Fehlermeldungen generieren.

Wenn eines dieser Elemente angezeigt wird, entspricht die version des in Android Studio installierten Android SDK möglicherweise nicht dem SDK-Ziel des heruntergeladenen Projekts. Um die Version zu überprüfen, nehmen Sie die folgenden Änderungen vor:

  1. Klicken Sie in Android Studio auf "Tools>Android>SDK Manager". Wenn Sie die neueste Version der SDK-Plattform nicht installiert haben, klicken Sie, um sie zu installieren. Notieren Sie sich die Versionsnummer.

  2. Öffnen Sie auf der Registerkarte "Projekt-Explorer" unter "Gradle Scripts" die Datei "build.gradle" (Modul: App). Stellen Sie sicher, dass die compileSdkVersion und targetSdkVersion auf die neueste installierte SDK-Version festgelegt sind. Dies build.gradle könnte wie folgt aussehen:

    android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}

Ihr nächster Schritt besteht darin, Google Play-Dienste zu installieren. Firebase Cloud Messaging verfügt über einige Mindestanforderungen auf API-Ebene für die Entwicklung und Tests, die die minSdkVersion-Eigenschaft im Manifest erfüllen muss.

Wenn Sie ein älteres Gerät testen, lesen Sie "Firebase zu Ihrem Android-Projekt hinzufügen ", um zu ermitteln, wie niedrig Sie diesen Wert festlegen können, und legen Sie ihn entsprechend fest.

Hinzufügen von Firebase Cloud Messaging zum Projekt

  1. Hinzufügen von Firebase zu Ihrem Android-Projekt

  2. Wählen Sie in Android Studio dieDateiprojektstruktur> aus. Wählen Sie "Benachrichtigungen", wählen Sie "Firebase Cloud Messaging" aus, und klicken Sie dann auf "OK".

Code hinzufügen

  1. Öffnen Sie in Ihrem App-Projekt die Datei AndroidManifest.xml. Fügen Sie nach dem application öffnenden Tag den folgenden Code hinzu:

    <service android:name=".ToDoMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>
<service android:name=".ToDoInstanceIdService">
    <intent-filter>
        <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
    </intent-filter>
</service>

  2. Öffnen Sie die Datei ToDoActivity.java, und nehmen Sie die folgenden Änderungen vor:

    • Fügen Sie die Import-Anweisung hinzu:

      import com.google.firebase.iid.FirebaseInstanceId;

    • Ändern Sie die Definition von MobileServiceClient"Privat" in "Privat statisch", sodass sie jetzt wie folgt aussieht:

      private static MobileServiceClient mClient;

    • Methode hinzufügen: registerPush

      public static void registerPush() {
    final String token = FirebaseInstanceId.getInstance().getToken();
    if (token != null) {
        new AsyncTask<Void, Void, Void>() {
            protected Void doInBackground(Void... params) {
                mClient.getPush().register(token);
                return null;
            }
        }.execute();
    }
}

    • Aktualisieren Sie die onCreate-Methode der ToDoActivity Klasse. Stellen Sie sicher, dass Sie diesen Code nach der MobileServiceClient Instanziierung hinzufügen.

      registerPush();

  3. Fügen Sie eine neue Klasse zum Behandeln von Benachrichtigungen hinzu. Öffnen Sie im Project Explorer die App>java>your-project-namespace nodes, und klicken Sie mit der rechten Maustaste auf den Paketnamenknoten. Klicken Sie auf "Neu" und dann auf "Java-Klasse". Geben Sie "Name" ein ToDoMessagingService, und klicken Sie dann auf "OK". Ersetzen Sie dann die Klassendeklaration durch:

    import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class ToDoMessagingService extends FirebaseMessagingService {

    private static final int NOTIFICATION_ID = 1;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        String message = remoteMessage.getData().get("message");
        if (message != null) {
            sendNotification("Notification Hub Demo", message);
        }
    }

    private void sendNotification(String title, String messageBody) {
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, ToDoActivity.class), 0);
        Notification.Builder notificationBuilder = new Notification.Builder(this)
                .setSmallIcon(R.drawable.ic_launcher)
                .setContentTitle(title)
                .setContentText(messageBody)
                .setContentIntent(contentIntent);
        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        if (notificationManager != null) {
            notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
        }
    }
}

  4. Fügen Sie eine weitere Klasse zum Behandeln von Tokenupdates hinzu. Erstellen Sie java-Klasse, und ersetzen Sie ToDoInstanceIdService die Klassendeklaration durch:

    import com.google.firebase.iid.FirebaseInstanceIdService;

public class ToDoInstanceIdService extends FirebaseInstanceIdService {

    @Override
    public void onTokenRefresh() {
        ToDoActivity.registerPush();
    }
}

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

Testen der App mit dem veröffentlichten mobilen Dienst

Sie können die App testen, indem Sie ein Android-Smartphone direkt mit einem USB-Kabel anfügen oder ein virtuelles Gerät im Emulator verwenden.

Nächste Schritte

Nachdem Sie dieses Lernprogramm abgeschlossen haben, sollten Sie mit einem der folgenden Lernprogramme fortfahren:

  • Fügen Sie Ihrer Android-App die Authentifizierung hinzu. Erfahren Sie, wie Sie dem Schnellstartprojekt "Todolist" unter Android mithilfe eines unterstützten Identitätsanbieters Authentifizierung hinzufügen.
  • Offlinesynchronisierung für Ihre Android-Appaktivieren. Erfahren Sie, wie Sie Ihrer App Offlineunterstützung mithilfe eines Back-Ends für mobile Anwendungen 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