Erste Schritte mit Android Studio und Pushbenachrichtigungen

Übersicht

Dieses Tutorial wurde entwickelt, um Ihnen den Einstieg in die Android PlayFab-Integration mit Pushbenachrichtigungen zu erleichtern.

Pushbenachrichtigungen erfordern eine Konfiguration in mehreren Systemen. Bevor Wir beginnen, sprechen wir über die Funktionsweise der Infrastruktur. Es gibt 4 Entitäten, die am Prozess beteiligt sind:

1. Google Play-Dienste
2. Firebase Cloud Messaging Services (FCM, basiert auf dem alten Google Cloud Messaging.)
3. PlayFab-Dienste
4. Clientanwendungen

1. Google Play-Dienste

Google Play Services identifiziert Ihre Seite auf dem Play-Markt mithilfe eines Paketnamens.

Ein Beispiel hierfür wäre : com.bob.games.matchthree.

Wenn er in Google Play registriert wird, wird der Paketname zu einer eindeutigen Anwendungs-ID und dient vielen Zwecken, von der Installation über den Play Store bis hin zur Verhinderung von Identitätswechseln.

2. Firebase Cloud Messaging (FCM)

Firebase Cloud Messaging-Dienste bieten Ihnen ein cloudbasiertes System zum Senden, Weiterleiten und Übermitteln Von Pushbenachrichtigungen.

Es ermöglicht auch anderen Diensten (wie PlayFab), Pushbenachrichtigungen in Ihrem Namen mithilfe des FCM-Serverschlüssels zu senden.

3. PlayFab-Dienste

PlayFab Services verwendet dann den FCM-Serverschlüssel, um Pushbenachrichtigungen an Ihre Clients zu senden.

4. Kundendienste

Schließlich kann Ihre Clientanwendung Benachrichtigungen empfangen und bei Bedarf verarbeiten.

Vier-Wege-Teilung

Daher müssen wir 4 verschiedene Systeme einrichten. Zu diesem Ziel ist unser Tutorial in 4 Kapitel unterteilt, die die Konfiguration für die einzelnen Teile behandeln.

Notiz

Die Reihenfolge , die Sie zum Konfigurieren der Systeme verwenden, ist wichtig.

Voraussetzungen

• Sie müssen über ein Google-Konto verfügen.
• Sie benötigen ein PlayFab-Konto.
• Ein generiertes Benachrichtigungssymbol mithilfe des Android Asset Studio-Benachrichtigungssymbol-Generators.

Szenario

In diesem Abschnitt unseres Tutorials erstellen wir eine Anwendung namens Foo PlayFab App. Es handelt sich um eine Android-App mit den folgenden Funktionen:

• Es meldet sich mit einer Android-Geräte-ID bei PlayFab an.
• Er empfängt Pushbenachrichtigungen von PlayFab.

Unser Paketname wird com.foo.playfab.app.

Wichtig

Stellen Sie sicher, dass Sie ihren eigenen Paketnamen und -titel verwenden, wenn Sie dieses Tutorial ausführen.

Kapitel 1: Konfigurieren von Firebase

Sie beginnen mit der Konfiguration von Firebase, indem Sie die offizielle Konsolenseite verwenden. Es wird eine Seite angezeigt, auf der Sie ein neues Projekt hinzufügen können.

• Wählen Sie dazu den Bereich Projekt hinzufügen aus, wie in der folgenden Abbildung dargestellt.

• Sie werden aufgefordert, einen Projektnamen anzugeben (in diesem Tutorial verwenden wir unsere Foo PlayFab-App, aber stellen Sie sicher, dass Sie ihren eigenen Namen angeben, wenn Sie dieses Tutorial befolgen).

• Wählen Sie die Schaltfläche Projekt erstellen aus, um mit dem nächsten Schritt fortzufahren.

Sie werden zum Dashboard "Neues Projekt" umgeleitet.

• Fügen Sie dem Projekt eine neue Android-Anwendung hinzu, indem Sie den Bereich auswählen, wie in der folgenden Abbildung dargestellt.

Für eine neue Anwendung müssen drei Schritte hinzugefügt werden.

1. Zuerst müssen Sie einen Android-Paketnamen angeben. Wir verwenden com.foo.playfab.app, aber stellen Sie sicher, dass Sie ihren eigenenPaketnamen verwenden, wenn Sie dieses Tutorial befolgen.

2. Wählen Sie die Schaltfläche App registrieren aus, um mit dem nächsten Schritt fortzufahren.

In Schritt 2 können Sie eine Einstellungsdatei namens google-services.json herunterladen. Es wird später in der App verwendet, um Google-Dienste automatisch zu konfigurieren.

• Wählen Sie nach dem Herunterladen die Schaltfläche Weiter aus, um mit dem nächsten Schritt fortzufahren.

3. Der letzte Schritt enthält Informationen dazu, wie Sie Ihren Buildprozess einrichten, um die Firebase- und Google Play-SDKs zu verknüpfen.

Notiz

Sie können diese Informationen ignorieren, da wir ein automatisiertes Tool verwenden, das in Android Studio integriert ist und dieses Setup automatisch ausführt.

• Wählen Sie die Schaltfläche Fertig stellen aus, um fortzufahren.

• Nachdem die Anwendung hinzugefügt wurde, wird sie im Dashboard angezeigt.

• An diesem Punkt ist die Konfiguration abgeschlossen, und wir müssen den FCM-Serverschlüssel extrahieren (den wir zum Verknüpfen von PlayFab-Pushbenachrichtigungen verwenden).

• Wechseln Sie zu den Projekteinstellungen , wie in der folgenden Abbildung gezeigt.

• Navigieren Sie unter Projekteinstellungen zur Registerkarte Cloud Messaging .

• Suchen Sie den Bereich Serverschlüssel (den roten Bereich in der abbildung unten gezeigten Abbildung).

• Kopieren Sie diesen Schlüssel , und speichern Sie ihn an einem sicheren und leicht zugänglichen Ort.

An diesem Punkt haben wir alles getan, was wir in Firebase benötigen, um Pushbenachrichtigungen zu aktivieren.

Kapitel 2: Konfigurieren der Google Play-Konsole

Wenn Ihre App bereit ist, erstellen Sie höchstwahrscheinlich ein Google-Konsolenprojekt, um eine Play Store-Produktseite zu verwalten. Lassen Sie uns den Prozess der Erstellung eines GooglePlay-Projekts und der Verknüpfung mit dem Firebase-Projekt durchgehen.

Öffnen Sie zunächst die Google Play Console-Seite , und erstellen Sie ein neues Projekt, wie in der folgenden Abbildung dargestellt.

• Weisen Sie den Titel zu.

Notiz

In diesem Beispiel wird die Foo PlayFab-App verwendet. Stellen Sie sicher, dass Sie ihren eigenen Titel und Paketnamen finden, während Sie dieses Tutorial befolgen.

• Wählen Sie die Schaltfläche Erstellen aus, um den Vorgang fortzusetzen.

• Die Seite Google Play Console-Projekt wird geöffnet.

• Wählen Sie im seitlichen Menü Dienste & APIs aus.

• Die Konfigurationsseite Dienste wird geöffnet.
• Suchen Sie den Bereich Firebase Cloud Messaging .
• Wählen Sie die Schaltfläche Absender-ID verknüpfen aus, wie in der folgenden Abbildung dargestellt.

So verknüpfen Sie die Absender-ID:

• Verwenden Sie den FCM-Serverschlüssel, den Sie bei der Verwendung der Firebase-Konsole im vorherigen Kapitel erhalten (und gespeichert haben).
• Wenn Sie fertig sind, wählen Sie die Schaltfläche Verknüpfen aus, wie in unserem Beispiel gezeigt.

• Nehmen Sie sich einen Moment Zeit, um zu überprüfen, ob die absender-ID , die in der Google Play-Konsole angezeigt wird, mit der in der Firebase-Konsole übereinstimmt, wie im folgenden Beispiel gezeigt.

An diesem Punkt wurde das Google Play-Konsolenprojekt erfolgreich mit dem Firebase-Projekt verknüpft.

Kapitel 3: Konfigurieren des PlayFab-Titels

Dieses Kapitel soll Ihnen zeigen, wie Sie PlayFab-Dienste so konfigurieren, dass sie Pushbenachrichtigungen in Ihrem Namen an den Spieler senden können.

• Zuerst müssen Sie im Menü Einstellungen Ihres Titels zu Titeleinstellungen wechseln.

• Wählen Sie die Registerkarte Pushbenachrichtigungen aus.

• Wählen Sie für die Option Android das Symbol Einstellungen aus.

• Sie werden nach Ihrem Google-Server-API-Schlüssel gefragt.

• Kopieren Sie die Über die Firebase-Konsole erhaltene Datei, wie im folgenden Beispiel gezeigt.

• Wenn alles richtig ist, wird eine Seite angezeigt, auf der Pushbenachrichtigungen als aktiv angezeigt werden.

Dies schließt die Konfiguration Ihres PlayFab-Titels ab.

Kapitel 4: Konfigurieren des Android Studio-Projekts

Um das PlayFab JavaSDK nutzen zu können, benötigen Sie den PlayFab-Client JavaSDK und seine Abhängigkeit Google GSON.

• Laden Sie die JavaSDK-JAR-Bibliothek des PlayFab-Clients hier herunter.

• Suchen client-sdk-*.jarSie nach , und dem entsprechenden Java-Dokument, falls Sie es benötigen.

• Laden Sie die neueste Google GSON herunter.

• gson-*.jarSuchen Sie nach .

• Die zuvor erwähnten .jar Dateien in der Nähe.

Erstellen Sie zunächst ein reguläres Android Studio-Projekt.

• Stellen Sie sicher, dass der Paketname mit dem Namen übereinstimmt, den Sie in diesem Tutorial verwendet haben (z. B. in Firebase).

  Notiz

  Für unsere Zwecke in diesem Beispiel verwenden wir com.foo.playfab.app, aber denken Sie daran, ihren eigenen Paketnamen und -titel zu erstellen, während Sie dieses Tutorial befolgen.

• Wählen Sie ein Mindest-SDK ihrer Wahl aus.

• Wählen Sie dann die Schaltfläche Weiter aus.

Für dieses Tutorial wird empfohlen, zunächst die Vorlage Leere Aktivität zu verwenden.

• Wählen Sie die Vorlage aus, die Sie verwenden möchten.

• Wählen Sie dann die Schaltfläche Weiter aus.

• Konfigurieren Sie die Vorlage nach Ihren Wünschen.

• Wählen Sie die Schaltfläche Fertig stellen aus.

Nachdem Sie das neu erstellte Projekt geöffnet haben:

• Wechseln Sie zur Registerkarte Projekt(1).

Notiz

Im vorherigen Kapitel haben Sie die google-services.json Konfigurationsdatei von der Firebase-Konsole heruntergeladen. Verwenden Sie dies für Den nächsten Schritt.

• Vergewissern Sie sich, dass sich diese Datei im Ordner App(2) befindet.
• Navigieren Sie dann zu Extras (3).
• Wählen Sie Firebase (4) aus, wie im folgenden Beispiel gezeigt.

Der Firebase-Assistent wird auf der rechten Seite des Fensters geöffnet.

• Suchen Sie den Ordner Cloud Messaging , und wählen Sie Firebase Cloud Messaging einrichten aus, wie unten gezeigt.

• Wählen Sie im Firebase-Benachrichtigungs-Assistenten die Schaltfläche FCM zu Ihrer App hinzufügen (1) aus, wie in der folgenden Abbildung dargestellt.

• Es wird ein Dialogfeld geöffnet, das angibt, dass neue Abhängigkeiten über Gradle hinzugefügt werden.

• Wählen Sie Änderungen annehmen (2) aus, um die Änderungen zu gewähren.

  Notiz

  Leider sind die Abhängigkeiten, die automatisch vom Gradle-Synchronisierungsprozess (3) hinzugefügt werden, falsch und melden Einen Fehler!

• Um die Abhängigkeiten ordnungsgemäß einzurichten, ersetzen Sie die automatisch hinzugefügten Sätze durch Folgendes:

  implementation 'com.google.firebase:firebase-core:16.0.3
implementation 'com.google.firebase:firebase-messaging:17.0.0

Sobald dieser Prozess abgeschlossen ist:

• Vergewissern Sie sich, dass der Firebase-Benachrichtigungs-Assistent angibt, dass Abhängigkeiten jetzt ordnungsgemäß eingerichtet sind (1).

Notiz

Am Anfang dieses Kapitels haben wir die erforderlichen JAR-Dateien abgerufen. Normalerweise ruft die Builddatei diese Dateien automatisch ab.

• Um sicherzustellen, dass diese JAR-Dateien im Ordner app/libs(2) aufgeführt sind, wählen Sie alle Dateien aus, und klicken Sie mit der rechten Maustaste darauf.
• Wählen Sie dann Als Bibliothek hinzufügen... aus. (3), wie im folgenden Beispiel gezeigt.

• Bereiten Sie mithilfe des Android Asset Studio-Benachrichtigungssymbolgenerators die Symbole vor, und platzieren Sie sie in app/src/main/res.

• Im folgenden Beispiel wird das Symbol als ic_stat_blur_on bezeichnet.

• Wählen Sie abschließend Projekt neu erstellen aus.

Jetzt können wir mit der Implementierung von Code für den Empfang und die Verarbeitung von Benachrichtigungen beginnen. Wir werden 4 Dateien ändern (und bei Bedarf erstellen):

1. app/src/main/AndroidManifest.xml
2. app/src/main/java/.. packagePath.. /MainActivity.java
3. app/src/main/java/.. packagePath.. /FooAppFirebaseInstanceIdService.java
4. app/src/main/java/.. packagePath.. /FooAppFirebaseMessagingService.java

Notiz

Die aktuelle Implementierung ist so kurz wie möglich, um die Benachrichtigungen schnell zu testen. In den FCM-Leitfäden finden Sie bewährte Methoden von hoher Qualität und komplexere Implementierungsbeispiele.

AndroidManifest.xml

Ersetzen Sie im folgenden Code alle MY_PACKAGE_IDENTIFIER Platzhalter durch Ihren eigenen Paketbezeichner.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="MY_PACKAGE_IDENTIFIER">
    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- The following block enables our custom Firebase Instance ID Service-->
        <service android:name=".FooAppFirebaseInstanceIdService" android:exported="true">
            <intent-filter>
                <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
            </intent-filter>
        </service>

        <service
            android:name=".FooAppFirebaseMessagingService" android:exported="true">
            <intent-filter>
                <action android:name="com.google.firebase.MESSAGING_EVENT"/>
            </intent-filter>
        </service>

    </application>

</manifest>

MainActivity.java

Die folgenden Platzhalter im Code sollten gemäß Ihrem Szenario ersetzt werden.

• PLAYFAB_TITLE_ID

  • Verwenden Sie die ID für Ihren Titel, den Sie im PlayFab-Spiel-Manager erhalten haben.

• PACKAGE_IDENTIFIER

  • Verwenden Sie den Java-Paketbezeichner, der Ihrem Setup entspricht.

package PACKAGE_IDENTIFIER;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import com.playfab.PlayFabClientAPI;
import com.playfab.PlayFabClientModels.*;
import com.playfab.PlayFabErrors;
import com.playfab.PlayFabSettings;
import java.util.List;
import java.util.Map;

public class MainActivity extends AppCompatActivity {

    // Invoked when activity is started
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Set PlayFab title
        PlayFabSettings.TitleId = "PLAYFAB_TITLE_ID";

        // Start login operation
        AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                if(login()) FooAppFirebaseInstanceIdService.setAllowRegisterForPush(true); // Ready to register for push notifications
            }
        });
    }

    public boolean login(){
        LoginWithAndroidDeviceIDRequest request = new LoginWithAndroidDeviceIDRequest();
        request.CreateAccount = true;

        // There are several approaches on getting unique android device id.
        // https://stackoverflow.com/questions/2785485/is-there-a-unique-android-device-id
        request.AndroidDeviceId = "qwerty";

        PlayFabErrors.PlayFabResult<LoginResult> response = PlayFabClientAPI.LoginWithAndroidDeviceID(request);
        if(response.Error != null){
            Log.d("Foo PlayFab App",CompileErrorsFromResult(response.Error));
            return false;
        }
        return true;
    }

    // Utility method to compose an error message out of PlayFab result.
    private static String CompileErrorsFromResult(PlayFabErrors.PlayFabError error) {
        if (error == null)
            return null;

        String errorMessage = "";
        if (error.errorMessage != null)
            errorMessage += error.errorMessage;
        if (error.errorDetails != null)
            for (Map.Entry<String, List<String>> pair : error.errorDetails.entrySet())
                for (String msg : pair.getValue())
                    errorMessage += "\n" + pair.getKey() + ": " + msg;
        return errorMessage;
    }
}

FooAppFirebaseInstanceIdService.java

Der Platzhalter im unten angezeigten Code sollte gemäß Ihrem Szenario ersetzt werden.

• PACKAGE_IDENTIFIER
  • Der Java-Paketbezeichner, der ihrem Setup entspricht.

package PACKAGE_IDENTIFIER;

import android.text.TextUtils;
import android.util.Log;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.FirebaseInstanceIdService;
import com.playfab.PlayFabClientAPI;
import com.playfab.PlayFabClientModels;
import com.playfab.PlayFabErrors;
import java.util.List;
import java.util.Map;

public class FooAppFirebaseInstanceIdService extends FirebaseInstanceIdService {

    private static String _token;

    private static boolean _allowRegistration;

    // This is invoked from activity that performs authentication.
    // Once login is complete this method is invoked.
    // If we have a pending token, we use it to register for push notifications
    public static void setAllowRegisterForPush(boolean isAllowed) {
        _allowRegistration = isAllowed;
        if (_allowRegistration && !TextUtils.isEmpty(_token)) {
            registerForPush(_token);
        }
    }

    // Invoked when firebase has fetched a token
    // If we already have logged in, we use new token to register for push
    @Override
    public void onTokenRefresh() {
        _token = FirebaseInstanceId.getInstance().getToken();
        if (_allowRegistration && !TextUtils.isEmpty(_token)) {
            registerForPush(_token);
        }
    }


    private static void registerForPush(String token) {
        PlayFabClientModels.AndroidDevicePushNotificationRegistrationRequest request = new PlayFabClientModels.AndroidDevicePushNotificationRegistrationRequest();
        request.DeviceToken = token;

        PlayFabErrors.PlayFabResult<PlayFabClientModels.AndroidDevicePushNotificationRegistrationResult> response = PlayFabClientAPI.AndroidDevicePushNotificationRegistration(request);

        if (response.Error != null) {
            Log.d("Foo PlayFab App", CompileErrorsFromResult(response.Error));
        }
    }

    // Utility method to compose an error message out of PlayFab result.
    private static String CompileErrorsFromResult(PlayFabErrors.PlayFabError error) {
        if (error == null)
            return null;

        String errorMessage = "";
        if (error.errorMessage != null)
            errorMessage += error.errorMessage;
        if (error.errorDetails != null)
            for (Map.Entry<String, List<String>> pair : error.errorDetails.entrySet())
                for (String msg : pair.getValue())
                    errorMessage += "\n" + pair.getKey() + ": " + msg;
        return errorMessage;
    }

}

FooAppFirebaseMessagingService.java

Der Platzhalter im unten gezeigten Code sollte gemäß Ihrem Szenario ersetzt werden.

• PACKAGE_IDENTIFIER
  • Der Java-Paketbezeichner, der ihrem Setup entspricht.

package com.foo.playfab.app;

import android.util.Log;
import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class FooAppFirebaseMessagingService extends FirebaseMessagingService {

    @Override
    public void onMessageReceived(RemoteMessage message) {
        // Intercept the message here
        Log.d("Foo PlayFab App","Message received: "+message.getNotification().getBody());
    }
}

Testen

An diesem Punkt sollten Sie in der Lage sein, die Anwendung auf dem Gerät bereitzustellen.

• Sobald Sie die Anwendung gestartet haben, wird sie automatisch angemeldet und für Pushbenachrichtigungen registriert.

• Wählen Sie die Schaltfläche Start auf Ihrem Gerät aus, um die Anwendung zu minimieren. Dies ist wichtig, da es uns ermöglicht, die Benachrichtigung zu testen, die in der Taskleiste eingeht.

• Wechseln Sie als Nächstes zu Ihrer PlayFab-Titelseite Game Manager, und verwenden Sie das Dashboard, um die neueste Pushregistrierung zu suchen.

• Wählen Sie die Spieler-ID (1) aus.

Dadurch wird eine Seite Pushbenachrichtigung senden für diesen Spieler geöffnet.

• Wählen Sie die Schaltfläche Pushbenachrichtigung senden(1) aus.

• Geben Sie titel (2) ein.

• Geben Sie den Text ihrer Nachricht ein (3).

• Committen Sie Ihre Änderungen, indem Sie die Schaltfläche Pushbenachrichtigung senden(4) auswählen.

• Vergewissern Sie sich, dass die Nachricht auf Ihrem Gerät eingeht.

Wenn Ihre Nachricht eingeht, werden Nachrichten erfolgreich an Ihre Anwendung übermittelt.

An diesem Punkt haben Sie erfolgreich integriert. Sie können fooAppFirebaseMessagingService verwenden, um die eingehende Nachricht zu verarbeiten, während Ihre Anwendung tatsächlich ausgeführt wird.