Erste Schritte mit Push-Benachrichtigungen auf Android

German (Deutsch) translation by Władysław Łucyszyn (you can also view the original English article)

Einführung

Die Installation der App durch die Benutzer ist nur die halbe Miete. Sie regelmäßig zu benutzen, ist die andere Hälfte. Es ist durchaus möglich, dass Ihre Benutzer Ihre App vollständig vergessen, nachdem Sie sie ein- oder zweimal verwendet haben. Was ist mit all den anderen neuen Apps, die um ihre Aufmerksamkeit kämpfen?

Durch die Verwendung von Push-Benachrichtigungen können Sie die Benutzer gelegentlich an Ihre App erinnern, wodurch die Wahrscheinlichkeit erhöht wird, dass Ihre App auf ihren Geräten installiert bleibt.

Google Cloud Messaging, kurz GCM, ist ein kostenloser Service, mit dem Sie Push-Benachrichtigungen an Ihre Nutzer senden können. In diesem Lernprogramm erfahren Sie, wie Sie damit eine Android-App erstellen, die Push-Benachrichtigungen erhalten kann, und ein einfaches serverseitiges Python-Skript, das sie generieren und senden kann.

Warum Google Cloud Messaging verwenden?

Für die meisten Client-Server-Kommunikationen initiiert der Client Anforderungen, um Daten vom Server zu empfangen. Der Client holt also Daten vom Server. Bei Push-Benachrichtigungen ist es jedoch der Server, der die Datenübertragung initiiert.

Dies wird normalerweise durch die Aufrechterhaltung einer permanenten TCP / IP-Verbindung zwischen dem Server und dem Client erreicht, die auf unbegrenzte Zeit offen bleibt. Das mag großartig klingen, aber wenn Sie eine beliebte App haben, kann das Aufrechterhalten Tausender dauerhafter Verbindungen zwischen Ihrem Server und den Geräten Ihrer Benutzer sehr teuer sein.

Google Cloud Messaging ist ein Dienst, der dieses Problem löst, indem er als Vermittler zwischen Ihrem Server und dem Gerät Ihres Nutzers fungiert. Mit GCM verwaltet der Cloud Connection Server von Google, der häufig als CCS bezeichnet wird, die dauerhaften Verbindungen für Sie. Außerdem wird sichergestellt, dass Ihre Push-Benachrichtigungen sicher und zuverlässig übermittelt werden.

Voraussetzungen

Um mit mir zu folgen, brauchst du:

die neueste Version von Android Studio
Python 2.7.6 oder höher
ein Gerät mit Android 4.4 oder höher mit installierten Google Play-Diensten

1. Einrichten des Android Studio-Projekts

Starten Sie Android Studio und erstellen Sie ein neues Projekt mit einer leeren Aktivität. Wenn Sie die Standardwerte verwendet haben, sollte das Projekt eine Java-Klasse in MainActivity.java enthalten.

Schritt 1: Fügen Sie die Abhängigkeiten hinzu

In diesem Projekt verwenden wir das Google Services Gradle Plugin zur Konfiguration von GCM. Fügen Sie es in das Projekt ein, indem Sie die folgende Zeile in den Abhängigkeitsbereich des build.gradle des Projekts einfügen:

1	classpath 'com.google.gms:google-services:1.5.0'

Wenden Sie anschließend das Plugin in build.gradle des App-Moduls an:

1	apply plugin: 'com.google.gms.google-services'

Um die GCM-API verwenden zu können, fügen Sie com.google.android.gms: play-services als Kompilierungsabhängigkeit in derselben Datei hinzu:

1	compile "com.google.android.gms:play-services:8.3.0"

Wenn Sie auf die Schaltfläche Jetzt synchronisieren klicken, sollte der folgende Fehler angezeigt werden:

Repository installieren und Projekt synchronisieren Klicken Sie auf den Link Repository installieren und synchronisieren, um den Fehler zu beheben.

Schritt 2: Aktualisieren Sie das Manifest

Erstellen und verwenden Sie in der Datei AndroidManifest.xml des Projekts eine benutzerdefinierte C2D_MESSAGE-Berechtigung, die auf dem Paketnamen des Projekts basiert. Stellen Sie sicher, dass die ProtectionLevel der Berechtigung auf Signatur gesetzt ist.

<permission
    android:name="com.github.hathibelagal.pn.permission.C2D_MESSAGE"
    android:protectionLevel="signature" />
<uses-permission
  android:name="com.github.hathibelagal.pn.permission.C2D_MESSAGE" />

Die Benachrichtigungen werden in Form von Sendungen empfangen. Für diese Broadcasts benötigt unsere App einen BroadcastReceiver. Wir müssen es jedoch nicht manuell erstellen. Wir können stattdessen die GcmReceiver-Klasse als BroadcastReceiver verwenden.

Der BroadcastReceiver muss über einen Intent-Filter verfügen, der auf die Aktion com.google.android.c2dm.intent.RECEIVE reagiert, und der Name der Kategorie muss mit dem Paketnamen des Projekts übereinstimmen. Fügen Sie dem Manifest den folgenden Code hinzu:

<receiver
    android:name="com.google.android.gms.gcm.GcmReceiver"
    android:exported="true"
    android:permission="com.google.android.c2dm.permission.SEND" >
    <intent-filter>
        <action android:name="com.google.android.c2dm.intent.RECEIVE" />
        <category android:name="com.github.hathibelagal.pn" />
    </intent-filter>
</receiver>

2. Rufen Sie einen Server-API-Schlüssel und eine Absender-ID ab

Bei der Kommunikation mit dem Cloud Connection Server müssen wir uns anhand eines API-Schlüssels auf der Serverseite und einer Absenderkennung auf der Clientseite identifizieren. Um den API-Schlüssel und die Absender-ID zu erhalten, erstellen Sie ein neues Projekt in der Entwicklerkonsole.

Klicken Sie anschließend unten auf die Schaltfläche Dienste auswählen und konfigurieren. Sie können jetzt die Google-Dienste auswählen, die Sie der App hinzufügen möchten. Wenn Sie dies tun, werden Sie aufgefordert, einen Namen und einen Android-Paketnamen für Ihre App anzugeben. Stellen Sie sicher, dass der von Ihnen angegebene Android-Paketname mit dem Paketnamen übereinstimmt, den Sie beim Erstellen des Android Studio-Projekts eingegeben haben.

Klicken Sie anschließend unten auf die Schaltfläche Dienste auswählen und konfigurieren. Sie können jetzt die Google-Dienste auswählen, die Sie der App hinzufügen möchten.

Klicken Sie zunächst auf die Schaltfläche Cloud Messaging und anschließend auf Google Cloud Messaging aktivieren. Nach wenigen Sekunden erhalten Sie den Server-API-Schlüssel und die Absender-ID. Notieren Sie sich den Server-API-Schlüssel, und drücken Sie Schließen.

Das zuvor hinzugefügte Google Services-Plugin benötigt eine Konfigurationsdatei, um ordnungsgemäß zu funktionieren. Generieren Sie die Datei, indem Sie auf die Schaltfläche Konfigurationsdateien generieren klicken.

Laden Sie die erstellte Datei herunter und speichern Sie sie im App-Verzeichnis Ihres Android Studio-Projekts.

3. Den Client registrieren

GCM identifiziert Android-Geräte mithilfe von Registrierungstoken. Daher muss sich unsere App von jedem Android-Gerät, auf dem sie installiert ist, registrieren können.

Schritt 1: Erstellen Sie einen Registrierungsdienst

Die Registrierung muss in einem Hintergrund-Thread erfolgen, da der Vorgang je nach Netzwerkverbindung eine Weile dauern kann. Da für die Registrierung keine Eingaben vom Benutzer erforderlich sind, ist ein IntentService ideal für diese Aufgabe.

Erstellen Sie eine neue Java-Klasse mit dem Namen RegistrationService.java, machen Sie diese zu einer Unterklasse von IntentService und überschreiben Sie die onHandleIntent-Methode.

public class RegistrationService extends IntentService {
    public RegistrationService() {
        super("RegistrationService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {

    }
}

Innerhalb der onHandleIntent-Methode können wir die Instanz-ID-API verwenden, um das Registrierungstoken zu generieren oder abzurufen. Erstellen Sie zunächst eine Instanz der InstanceID-Klasse mit ihrer getInstance-Methode.

1	InstanceID myID = InstanceID.getInstance(this);

Wir können jetzt die getToken-Methode des InstanceID-Objekts verwenden, um das Registrierungstoken in Form eines Strings abzurufen. getToken erwartet die Absender-ID als eines seiner Argumente. Da wir unserem Projekt die Datei google-services.json hinzugefügt haben, können wir die Absender-ID mithilfe von R.string.gcm_defaultSenderID an die Methode übergeben.

String registrationToken = myID.getToken(
        getString(R.string.gcm_defaultSenderId),
        GoogleCloudMessaging.INSTANCE_ID_SCOPE,
        null
);

Wenn Sie den Inhalt des Registrierungstokens zu Debug-Zwecken anzeigen möchten, können Sie es mit der Methode Log.d als Debug-Nachricht protokollieren.

1	Log.d("Registration Token", registrationToken);

An diesem Punkt können Sie das Registrierungstoken an Ihren Webserver senden und dort in einer Datenbank speichern. Sie müssen dies jedoch nicht tun, wenn Sie Ihre Benutzer nicht individuell ansprechen möchten. Wenn Sie beabsichtigen, die gleiche Nachricht an jeden Benutzer zu senden, sollten Sie dem Publish-Subscribe-Ansatz folgen.

Ich werde Ihnen jetzt zeigen, wie Sie ein Thema mit dem Namen my_little_topic abonnieren. Es dauert nur zwei Zeilen Code. Erstellen Sie zunächst eine neue Instanz der GcmPubSub-Klasse mit ihrer getInstance-Methode. Rufen Sie als Nächstes seine Abonnementmethode auf und übergeben Sie das Registrierungstoken zusammen mit dem Namen des Themas.

1	GcmPubSub subscription = GcmPubSub.getInstance(this);
2	subscription.subscribe(registrationToken, "/topics/my_little_topic", null);

Unsere App kann jetzt jede Push-Benachrichtigung erhalten, die an my_little_topic veröffentlicht wurde.

Definieren Sie schließlich den Dienst in AndroidManifest.xml.

1	<service android:name=".RegistrationService"
2	android:exported="false" />

Der Registrierungsservice ist abgeschlossen.

Schritt 2: Erstellen Sie einen `InstanceIDListenerService`

Registrierungstoken werden regelmäßig aktualisiert. Folglich muss jede Android-App, die GCM verwendet, über einen InstanceIDListenerService verfügen, der diese Aktualisierungen verarbeiten kann. Erstellen Sie daher eine neue Java-Datei mit dem Namen TokenRefreshListenerService.java und machen Sie sie zu einer Unterklasse von InstanceIDListenerService. In der onTokenRefresh-Methode der Klasse müssen wir lediglich den Registrierungsvorgang erneut starten, indem der Registrierungsdienst mit einer Intent-Methode und der startService-Methode gestartet wird.

Fügen Sie den folgenden Code hinzu TokenRefreshListenerService.java:

public class TokenRefreshListenerService extends InstanceIDListenerService {
    @Override
    public void onTokenRefresh() {
        Intent i = new Intent(this, RegistrationService.class);
        startService(i);
    }
}

Dieser Dienst muss auf die Aktion com.google.android.gms.iid.InstanceID reagieren können. Fügen Sie beim Definieren des Dienstes in AndroidManifest.xml daher den entsprechenden Intent-Filter hinzu.

<service
    android:name=".TokenRefreshListenerService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.android.gms.iid.InstanceID" />
    </intent-filter>
</service>

Schritt 3: Starten des Registrierungsdienstes

Um sicherzustellen, dass der Registrierungsprozess beginnt, sobald die App gestartet wird, müssen Sie die RegistrationService-Klasse in der OnCreate-Methode von MainActivity starten. Erstellen Sie dazu einen Intent und verwenden Sie die Methode startService.

1	Intent i = new Intent(this, RegistrationService.class);
2	startService(i);

4. Anzeigen von Push-Benachrichtigungen

GCM zeigt Push-Benachrichtigungen automatisch im Benachrichtigungsbereich an, sobald sie empfangen werden. Dies geschieht jedoch nur, wenn die zugehörige App einen GCMListenerService enthält.

Erstellen Sie eine neue Java-Klasse namens NotificationsListenerService und machen Sie sie zu einer Unterklasse von GCMListenerService. Wenn Sie die übertragenen Daten nicht selbst behandeln möchten, müssen Sie keinen Code innerhalb dieser Klasse schreiben. Wir können diese Klasse vorerst leer lassen.

1	public class NotificationsListenerService extends GcmListenerService {
2
3	}

Stellen Sie beim Definieren des Dienstes in AndroidManifest.xml sicher, dass Sie einen Intent-Filter hinzufügen, mit dem er auf die Aktion com.google.android.c2dm.intent.RECEIVE reagieren kann.

<service
    android:name=".NotificationsListenerService"
    android:exported="false" >
    <intent-filter>
        <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    </intent-filter>
</service>

5. Hinzufügen von Push-Benachrichtigungssymbolen

Jeder Push-Benachrichtigung muss ein Symbol zugeordnet sein. Wenn Sie kein Handy zur Hand haben, können Sie es von der Material Design Icons Library von Google erhalten.

Wenn Sie das Symbol heruntergeladen haben, platzieren Sie es im Ordner res Ihres Projektes. Ich werde ic_cloud_white_48dp als Symbol verwenden.

6. Android-App ausführen

Unsere Android-App ist jetzt abgeschlossen. Nachdem Sie es kompiliert und auf einem Android-Gerät ausgeführt haben, können Sie das Registrierungstoken in den Logcat-Protokollen sehen.

Drücken Sie die Zurück-Taste an Ihrem Gerät, um die App zu beenden. Dies ist erforderlich, da GCM Push-Benachrichtigungen nur dann automatisch anzeigt, wenn der Benutzer die App nicht verwendet. Wenn Sie möchten, dass die Benachrichtigungen auch angezeigt werden, während die App ausgeführt wird, müssen Sie die Benachrichtigungen selbst in NotificationsListenerService mithilfe der Notification.Builder-Klasse erstellen.

7. Senden von Push-Benachrichtigungen

Im letzten Teil dieses Lernprogramms erstellen wir ein einfaches Python-Skript, mit dem Push-Benachrichtigungen generiert und an alle Android-Geräte gesendet werden können, auf denen unsere App installiert ist.

Sie können dieses Skript auf Ihrem lokalen Computer oder auf einem Remote-Webserver ausführen, auf den Sie SSH-Zugriff haben.

Schritt 1: Skript erstellen

Erstellen Sie eine neue Datei namens send.py und öffnen Sie sie mit Ihrem bevorzugten Texteditor.

Importieren Sie am Anfang der Datei die Module urllib2 und urllib. Wir verwenden diese Module, um Daten an den Cloud Connection Server von Google zu senden. Importieren Sie auch das Json-Modul, da die von uns gesendeten Daten gültige JSON-Werte sein müssen. Um zuletzt auf Befehlszeilenargumente zuzugreifen, importieren Sie das sys-Modul.

1	from urllib2 import *
2	import urllib
3	import json
4	import sys

Als Nächstes erstellen Sie eine Variable, die den Server-API-Schlüssel speichert, den Sie zuvor notiert haben. Der Schlüssel muss Teil jeder HTTP-Anforderung sein, die wir an das CCS senden.

1	MY_API_KEY="ABCDEF123456789ABCDE--12A"

Jede Benachrichtigung muss einen Titel und eine Nachricht haben. Anstatt sie in unserem Skript fest zu codieren, akzeptieren wir Titel und Text als Befehlszeilenargumente mit dem argv-Array.

1	messageTitle = sys.argv[1]
2	messageBody = sys.argv[2]

Erstellen Sie ein neues Python-Wörterbuchobjekt, um die Daten darzustellen, die an das CCS gesendet werden sollen. Damit unsere Android-App die Benachrichtigung erhalten kann, muss sie zu einem Thema namens my_little_topic veröffentlicht werden. Fügen Sie daher einen Schlüssel für das Wörterbuch hinzu, und setzen Sie seinen Wert auf / topics / my_little_topic.

Um den Inhalt der Benachrichtigung darzustellen, fügen Sie einen Schlüssel namens Benachrichtigung zum Wörterbuch hinzu und setzen Sie seinen Wert auf ein anderes Wörterbuchobjekt, das drei Schlüssel enthält:

Karosserie
Titel
Symbol

Stellen Sie sicher, dass der Wert des Symbolschlüssels mit dem Namen des in Ihrem Android-Projekt gezeichneten Symbols übereinstimmt.

data={
    "to" : "/topics/my_little_topic",
    "notification" : {
        "body" : messageBody,
        "title" : messageTitle,
        "icon" : "ic_cloud_white_48dp"
    }
}

Konvertieren Sie das Wörterbuch mithilfe der Dump-Funktion des Json-Moduls in einen JSON-String:

1	dataAsJSON = json.dumps(data)

Jetzt müssen Sie nur noch den JSON-String an https://gcm-http.googleapis.com/gcm/send senden. Erstellen Sie dazu ein neues Request-Objekt und setzen Sie dataAsJSON als seine Daten. Setzen Sie als nächstes den Authorization-Header auf MY_API_KEY und den Content-Type-Header auf application / json.

request = Request(
    "https://gcm-http.googleapis.com/gcm/send",
    dataAsJSON,
    { "Authorization" : "key="+MY_API_KEY,
      "Content-type" : "application/json"
    }
)

Um die Anforderung auszuführen und die Antwort abzurufen, übergeben Sie das Anforderungsobjekt schließlich an die Funktion urlopen und rufen seine Lesemethode auf.

1	print urlopen(request).read()

Das Python-Skript ist jetzt fertig und kann verwendet werden.

Schritt 2: Ausführen des Skripts

Jetzt können wir Push-Benachrichtigungen an alle Geräte senden, auf denen unsere App installiert ist. Öffnen Sie ein Terminal und geben Sie das Verzeichnis ein, in dem Sie send.py erstellt haben.

Übergeben Sie den Namen des Skripts an die ausführbare Python-Datei zusammen mit einer Zeichenfolge für den Titel der Benachrichtigung und einer für den Nachrichtentext. Hier ist ein Beispiel, das Sie verwenden können:

1	python send.py "My first push notification" "GCM API is wonderful!"

Wenn keine Fehler vorliegen, erhalten Sie eine Antwort, die wie folgt aussieht:

1	{"message_id":12345676892321}

Wenn Sie Ihr Android-Gerät überprüfen, sollte eine neue Benachrichtigung in der Benachrichtigungsleiste angezeigt werden.

Fazit

Sie wissen jetzt, wie Sie Push-Benachrichtigungen an Ihre Benutzer senden. In dieser Lektion haben Sie gelernt, wie Sie eine Android-App erstellen, die sich selbst registrieren kann und Benachrichtigungen erhält, die zu einem bestimmten Thema veröffentlicht werden. Sie haben auch gelernt, wie Sie ein Python-Skript erstellen, das Benachrichtigungen veröffentlichen kann.

Obwohl sich Push-Benachrichtigungen als eine großartige Möglichkeit für die Kommunikation mit Ihren Benutzern anfühlen, empfehle ich, sie nur sparsam zu verwenden, und nur dann, wenn Sie etwas Nützliches zu sagen haben, da das Senden zu vieler von ihnen zu oft die schnellste Möglichkeit ist, Ihre App zu erhalten deinstalliert.

Weitere Informationen zu Google Cloud Messaging finden Sie im Cloud Messaging-Handbuch.