Handhabung von Push-Benachrichtigungen in Android

Übersicht

Sie müssen Unterstützung für Google Play Services konfigurieren, damit Android-Anwendungen empfangene Push-Benachrichtigungen handhaben können. Wenn eine Anwendung konfiguriert ist, kann die MobileFirst-API für Benachrichtigungen verwendet werden, um Geräte zu registrieren und Geräteregistrierungen aufzuheben und um Tags zu abonnieren und Tagabonnements zu beenden. In diesem Lernprogramm werden Sie lernen, wie Push-Benachrichtigungen in Android-Anwendungen gehandhabt werden.

Voraussetzungen:

Stellen Sie sicher, dass Sie die folgenden Lernprogramme durchgearbeitet haben:
MobileFirst Server wird lokal oder fern ausgeführt.
Die MobileFirst CLI ist auf der Entwicklerworkstation installiert.

Fahren Sie mit folgenden Abschnitten fort:

Benachrichtigungskonfiguration
API für Benachrichtigungen
Handhabung von Push-Benachrichtigungen
Beispielanwendung
Clientanwendungen für Android auf FCM umstellen

Benachrichtigungskonfiguration

Erstellen Sie ein neues Android-Studio-Projekt oder verwenden Sie ein vorhandenes Projekt.
Wenn das native MobileFirst-Android-SDK noch nicht im Projekt enthalten ist, folgen Sie den Anweisungen im Lernprogramm SDK der Mobile Foundation zu Android-Anwendungen hinzufügen.

Projekt-Setup

Google Cloud Messaging (GCM) wird nicht mehr verwendet und wurde in Firebase Cloud Messaging (FCM) integriert.

Die Einrichtung einer Anwendung in FCM unterscheidet sich vom alten GCM-Modell.

Wenn Sie das Firebase-Messaging nutzen möchten, benötigen Sie die Datei google-services.json. Klicken Sie hier für eine Dokumentation zum Abrufen dieser Datei.
- Verwenden Sie im Fenster “Firebase zu Ihrer Android-App hinzufügen” den Paketnamen com.ibm.mobilefirstplatform.clientsdk.android.push.
Wählen Sie unter Android → Gradle-Scripts die Datei build.gradle (Module: app) aus und fügen Sie zu dependencies die folgenden Zeilen hinzu: xml implementation group: 'com.ibm.mobile.foundation', name: 'ibmmobilefirstplatformfoundationpush', version: '8.0.+', ext: 'aar', transitive: true

Oder in einer einzelnen Zeile: xml implementation 'com.ibm.mobile.foundation:ibmmobilefirstplatformfoundationpush:8.0.+'

Hinweis: Wenn Sie das Feature [Google Dynamic Delivery] (https://developer.android.com/studio/projects/dynamic-delivery) verwenden und in einem Featuremodul MobileFirst-APIs aufrufen möchten, verwenden Sie die Deklaration api anstelle von implementation. Wenn Sie implementation verwenden, schränken Sie die Verwendung der MobileFirst-APIs in diesem Modul ein. Bei Verwendung von api machen Sie dagegen MobileFirst-APIs für alle in der App vorhandenen Module verfügbar. Dies gilt auch für Featuremodule. Ausführliche Informationen finden Sie unter [API and implementation separation] (https://docs.gradle.org/current/userguide/java_library_plugin.html#sec:java_library_separation).

 api 'com.ibm.mobile.foundation:ibmmobilefirstplatformfoundationpush:8.0.+'

Konfigurieren Sie Ihre Gradle-Datei. Fügen Sie zur App-Datei build.gradle Folgendes hinzu:
```
dependencies {
   ......
   compile 'com.google.firebase:firebase-messaging:17.6.0'
   .....
}

Wenden Sie das Plug-in 'com.google.gms.google-services' an.
```
- Fügen Sie zum Stammabschnitt buildscript der Datei build.gradle die folgende Abhängigkeit hinzu:
```
classpath 'com.google.gms:google-services:3.0.0'
```
Hinweis: Wenn Sie Android Studio bis Version 3.2 verwenden, müssen Sie sicherstellen, dass in jeder Abhängigkeitszeile nur eine Versionsnummer angegeben ist.
Öffnen Sie unter Android → app → manifests die Datei AndroidManifest.xml.
- Fügen Sie am Anfang des Tags manifest die folgenden Berechtigungen hinzu:
  
```xml

	* Fügen Sie Folgendes zum Tag `application` hinzu: 

	  ```xml
     
      		<!-- MFPPush Intent Service -->
       <service android:exported="true" android:name="com.ibm.mobilefirstplatform.clientsdk.android.push.api.MFPPushIntentService">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    	</service>

      	<!-- MFPPush Instance ID Listener Service -->
 		<service android:name="com.ibm.mobilefirstplatform.clientsdk.android.push.api.MFPPush"
            android:exported="true">
            <intent-filter>
                <action android:name="com.google.firebase.INSTANCE_ID_EVENT" />
            	</intent-filter>
   	 	</service>

     		 <activity android:name="com.ibm.mobilefirstplatform.clientsdk.android.push.api.MFPPushNotificationHandler"
           android:theme="@android:style/Theme.NoDisplay"/>
	  ```
    * Fügen Sie den folgenden `intent-filter` zur Aktivität der Anwendung hinzu. 

      ```xml
      <intent-filter>
          <action android:name="your.application.package.name.IBMPushNotification" />
          <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
      ```
	> **Hinweis:** Sie müssen `your.application.package.name` durch den Paketnamen Ihrer Anwendung ersetzen. 

5.	Öffnen Sie die App in Android Studio. Kopieren Sie die Datei `google-services.json`, die Sie in **Schritt 1** erstellt haben, in das App-Verzeichnis. Die Datei `google-service.json` enthält den Paketnamen, den Sie hinzugefügt haben.		

6. Kompilieren Sie das SDK. Erstellen Sie die Anwendung.

## API für Benachrichtigungen
{: #notifications-api }
### MFPPush-Instanz
{: #mfppush-instance }
Alle API-Aufrufe müssen für eine Instanz von `MFPPush` ausgeführt werden. Zu diesem Zweck können Sie ein Feld auf Klassenebene erstellen, z. B. `private MFPPush push = MFPPush.getInstance();`, und dann in der gesamten Klasse `push.<API-Aufruf>` aufrufen. 

Alternativ dazu können Sie `MFPPush.getInstance().<API-Aufruf>` für jede Instanz aufrufen, in der Sie auf die Push-API-Methoden zugreifen müssen. 

### Abfrage-Handler
{: #challenge-handlers }
Wenn der Bereich `push.mobileclient` einer **Sicherheitsüberprüfung** zugeordnet ist,
müssen Sie sicherstellen, dass passende **Abfrage-Handler** registriert sind, bevor Push-APIs verwendet werden. 

> Weitere Informationen zu Abfrage-Handlern enthält das Lernprogramm [Berechtigungsnachweise validieren](../../../authentication-and-security/credentials-validation/android).



### Clientseite
{: #client-side }

|Java-Methoden|Beschreibung |
|-----------------------------------------------------------------------------------|-------------------------------------------------------------------------|
|[`initialize(Context context);`](#initialization) |Initialisiert MFPPush für den angegebenen Kontext|
|[`isPushSupported();`](#is-push-supported) |Unterstützt das Gerät Push-Benachrichtigungen?|
|[`registerDevice(JSONObject, MFPPushResponseListener);`](#register-device) |Registriert das Gerät beim Push-Benachrichtigungsservice|
|[`getTags(MFPPushResponseListener)`](#get-tags) |Ruft die verfügbaren Tags einer Instanz des Push-Benachrichtigungsservice ab|
|[`subscribe(String[] tagNames, MFPPushResponseListener)`](#subscribe) |Richtet das Geräteabonnement für die angegebenen Tags ein|
|[`getSubscriptions(MFPPushResponseListener)`](#get-subscriptions) |Ruft die derzeit vom Gerät abonnierten Tags ab |
|[`unsubscribe(String[] tagNames, MFPPushResponseListener)`](#unsubscribe) |Beendet das Abonnement bestimmter Tags|
|[`unregisterDevice(MFPPushResponseListener)`](#unregister) |Hebt die Registrierung des Geräts beim Push-Benachrichtigungsservice auf|

#### Initialisierung
{: #initialization }
Die Initialisierung ist erforderlich, damit die Clientanwendung mit dem richtigen Anwendungskontext eine Verbindung zum Service MFPPush herstellen kann. 

* Die API-Methode muss aufgerufen werden, bevor andere MFPPush-APIs verwendet werden.
* Die Callback-Funktion wird für die Handhabung empfangener Push-Benachrichtigungen registriert. 

```java
MFPPush.getInstance().initialize(this);

Wird Push unterstützt?

Es wird überprüft, ob das Gerät Push-Benachrichtigungen unterstützt.

Boolean isSupported = MFPPush.getInstance().isPushSupported();

if (isSupported ) {
    // Push wird unterstützt.
} else {
    // Push wird nicht unterstützt.
}

Gerät registrieren

Registrieren Sie das Gerät beim Push-Benachrichtigungsservice.

MFPPush.getInstance().registerDevice(null, new MFPPushResponseListener<String>() {
    @Override
    public void onSuccess(String s) {
        // Erfolgreich registriert
    }

    @Override
    public void onFailure(MFPPushException e) {
        // Registrierung mit Fehler fehlgeschlagen
    }
});

Tags abrufen

Rufen Sie alle verfügbaren Tags vom Push-Benachrichtigungsservice ab.

MFPPush.getInstance().getTags(new MFPPushResponseListener<List<String>>() {
    @Override
    public void onSuccess(List<String> strings) {
        // Tags erfolgreich als Liste von Zeichenfolgen abgerufen
    }

    @Override
    public void onFailure(MFPPushException e) {
        // Empfang von Tags mit Fehler fehlgeschlagen
    }
});

Abonnieren Sie die gewünschten Tags.

String[] tags = {"Tag 1", "Tag 2"};

MFPPush.getInstance().subscribe(tags, new MFPPushResponseListener<String[]>() {
    @Override
    public void onSuccess(String[] strings) {
        // Abonnement erfolgreich
    }

    @Override
    public void onFailure(MFPPushException e) {
        // Abonnement fehlgeschlagen
    }
});

Abonnements abrufen

Rufen Sie die derzeit vom Gerät abonnierten Tags ab.

MFPPush.getInstance().getSubscriptions(new MFPPushResponseListener<List<String>>() {
    @Override
    public void onSuccess(List<String> strings) {
        // Abonnements erfolgreich als Liste von Zeichenfolgen empfangen
    }

    @Override
    public void onFailure(MFPPushException e) {
        // Abruf der Abonnements mit Fehler fehlgeschlagen
    }
});

Abonnement beenden

Beenden Sie das Tagabonnement.

String[] tags = {"Tag 1", "Tag 2"};

MFPPush.getInstance().unsubscribe(tags, new MFPPushResponseListener<String[]>() {
    @Override
    public void onSuccess(String[] strings) {
        // Beendigung des Abonnements erfolgreich
    }

    @Override
    public void onFailure(MFPPushException e) {
        // Beendigung des Abonnements fehlgeschlagen
    }
});

Registrierung aufheben

Sie können die Registrierung des Geräts bei der Instanz des Push-Benachrichtigungsservice aufheben.

MFPPush.getInstance().unregisterDevice(new MFPPushResponseListener<String>() {
    @Override
    public void onSuccess(String s) {
        disableButtons();
        // Aufhebung der Registrierung erfolgreich
    }

    @Override
    public void onFailure(MFPPushException e) {
        // Aufhebung der Registrierung fehlgeschlagen
    }
});

Handhabung von Push-Benachrichtigungen

Für die Handhabung von Push-Benachrichtigungen müssen Sie einen MFPPushNotificationListener einrichten. Zu diesem Zweck können Sie eine der folgenden Methoden implementieren.

Option eins

Führen Sie in der Aktivität, in der Sie Push-Benachrichtigungen behandeln möchten, die folgenden Schritte aus:

Fügen Sie implements MFPPushNofiticationListener zur Klassendeklaration hinzu.
Definieren Sie die Klasse als Listener, indem Sie MFPPush.getInstance().listen(this) in der Methode onCreate aufrufen.

Anschließend müssen Sie die folgende erforderliche Methode hinzufügen:

@Override
public void onReceive(MFPSimplePushNotification mfpSimplePushNotification) {
     // Hier Behandlung von Push-Benachrichtigungen
}

In dieser Methode werden Sie MFPSimplePushNotification empfangen und können für die Benachrichtigung das gewünschte Verhalten festlegen.

Option zwei

Erstellen Sie einen Listener, indem Sie wie folgt listen(new MFPPushNofiticationListener()) für eine Instanz von MFPPush aufrufen:

MFPPush.getInstance().listen(new MFPPushNotificationListener() {
    @Override
    public void onReceive(MFPSimplePushNotification mfpSimplePushNotification) {
        // Hier Behandlung von Push-Benachrichtigungen
    }
});

Migration auf FCM SDK Version 19.x

Wenn eine Anwendung, die eine alte Version des FCM-SDK nutzt, die neueste Version (FCM SDK ab Version 19.x) verwenden soll, müssen Sie das Android-Projekt auf AndroidX migrieren. Fügen Sie Folgendes zu der Anwendung hinzu:

App-Datei build.gradle:

Entfernen Sie die folgenden Abhängigkeiten aus der Datei build.gradle.

```
 		dependencies {
		...
		implementation 'com.android.support:appcompat-v7:28.0.0'
 				implementation 'com.android.support:design:28.0.0'
  		implementation 'com.android.support:support-v4:28.0.0'
      implementation 'com.google.firebase:firebase-messaging:17.6.0' 
      ...
      }   ```

Ersetzen Sie die folgenden Abhängigkeiten:

```
	dependencies {
 			 ...
		implementation "com.google.firebase:firebase-messaging:20.0.0"
      implementation "androidx.appcompat:appcompat:1.1.0'"
      implementation "androidx.legacy:legacy-support-v4:1.0.0"
      implementation "com.google.android.material:material:1.1.0"
      ...
  }   ```

Konfigurieren Sie die Android-Manifestdatei. Die folgenden Änderungen an der Datei AndroidManifest.xml sind erforderlich:

Folgende Einträge müssen modifiziert werden:

  <service android:exported="true" android:name="com.ibm.mobilefirstplatform.clientsdk.android.push.api.MFPPushIntentService">
      <intent-filter>
  		<action android:name="com.google.firebase.MESSAGING_EVENT" />
      </intent-filter>
  </service>

Nach der Modifikation müssen die Einträge wie folgt aussehen:

  <service android:exported="true" android:name="com.ibm.mobilefirstplatform.clientsdk.android.push.api.MFPPushNewIntentService">
      <intent-filter>
  		<action android:name="com.google.firebase.MESSAGING_EVENT" />
      </intent-filter>
  </service>

Beispielanwendung

Klicken Sie hier, um das Android-Studio-Projekt herunterzuladen.

Verwendung des Beispiels

Anweisungen finden Sie in der Datei README.md zum Beispiel.

▲

Inclusive terminology note: The Mobile First Platform team is making changes to support the IBM® initiative to replace racially biased and other discriminatory language in our code and content with more inclusive language. While IBM values the use of inclusive language, terms that are outside of IBM's direct influence are sometimes required for the sake of maintaining user understanding. As other industry leaders join IBM in embracing the use of inclusive language, IBM will continue to update the documentation to reflect those changes.

Last modified on June 22, 2020