Tutorial: Senden von Pushbenachrichtigungen an Android-Geräte mit Firebase SDK-Version 0.6

Artikel
03/07/2024

In diesem Tutorial erfahren Sie, wie Sie mithilfe von Azure Notification Hubs und Firebase Cloud Messaging (FCM) SDK-Version 0.6 Pushbenachrichtigungen an eine Android-Anwendung senden. In diesem Tutorial erstellen Sie eine leere Android-App, die Pushbenachrichtigungen mithilfe von Firebase Cloud Messaging (FCM) empfängt.

Wichtig

Google stellt die Unterstützung von FCM Legacy HTTP am 20. Juni 2024 ein. Weitere Informationen finden Sie unter Azure Notification Hubs und die Migration von Google Firebase Cloud Messaging.

Den vollständigen Code für dieses Tutorial können Sie von GitHub herunterladen.

In diesem Tutorial führen Sie die folgenden Schritte aus:

Erstellen eines Android Studio-Projekts.
Erstellen eines Firebase-Projekts, das Firebase Cloud Messaging unterstützt.
Erstellen Sie einen Hub.
Verbinden Sie Ihre App mit dem Hub.
Testen der App.

Voraussetzungen

Sie benötigen ein aktives Azure-Konto, um dieses Lernprogramm abzuschließen. Wenn Sie über kein Konto verfügen, können Sie in nur wenigen Minuten ein kostenloses Testkonto erstellen. Ausführliche Informationen finden Sie unter Einen Monat kostenlos testen.

Sie benötigen außerdem folgende Elemente:

Aktuelle Version von Android Studio
Android 2.3 oder höher für Firebase Cloud Messaging
Google Repository Version 27 oder höher für Firebase Cloud Messaging
Google Play Services 9.0.2 oder höher für Firebase Cloud Messaging

Das Abschließen dieses Tutorial ist eine Voraussetzung für alle anderen Notification Hubs-Tutorials für Android-Apps.

Erstellen eines Android Studio-Projekts

Starten Sie Android Studio.
Wählen Sie File (Datei), zeigen Sie auf New (Neu), und wählen Sie dann New Project (Neues Projekt).
Wählen Sie auf der Seite Choose your project (Projekt auswählen) die Option Empty Activity (Leere Aktivität) und dann Next (Weiter) aus.
Führen Sie auf der Seite Configure your project (Projekt konfigurieren) die folgenden Schritte aus:
1. Geben Sie einen Namen für die Anwendung ein.
2. Geben Sie einen Speicherort an, in dem die Projektdateien gespeichert werden.
3. Wählen Sie Fertig stellen aus.

Erstellen eines Firebase-Projekts, das FCM unterstützt

Melden Sie sich bei der Firebase-Konsole an. Erstellen Sie ein neues Firebase-Projekt, falls Sie noch keins besitzen.
Klicken Sie nach der Erstellung Ihres Projekts auf Add Firebase to your Android app (Firebase der Android-App hinzufügen).
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 lautet er com.fabrikam.fcmtutorial1app.
2. Wählen Sie Register app (App registrieren) aus.
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).
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 App-Ebene hinter dem Abschnitt „dependenices“ die folgende Zeile hinzu.
```
apply plugin: 'com.google.gms.google-services'
```
4. Wählen Sie auf der Symbolleiste Sync Now (Jetzt synchronisieren) aus.
Wählen Sie Weiter aus.
Klicken Sie auf Diesen Schritt überspringen.
Klicken Sie in der Firebase-Konsole auf das Zahnrad für Ihr Projekt. Klicken Sie dann auf Projekteinstellungen.
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.
Wechseln Sie oben zur Registerkarte Cloud Messaging.
Kopieren und speichern Sie den Serverschlüssel für eine spätere Verwendung. Verwenden Sie diesen Wert zum Konfigurieren Ihres Hubs.
Wenn auf der Registerkarte „Cloud Messaging“ von Firebase kein Serverschlüssel angezeigt wird, befolgen Sie diese zusätzlichen Schritte.
1. Klicken Sie auf das Dreipunktmenü der Überschrift „Cloud Messaging API (Legacy) 🚫 Deaktiviert“.
2. Folgen Sie dem angebotenen Link zu „API in der Google Cloud Console verwalten“.
3. Klicken Sie in der Google Cloud Console auf die Schaltfläche, um die googlecloudmessaging-API zu aktivieren.
4. Warten Sie ein paar Minuten.
5. Wechseln Sie zurück zur Registerkarte Cloud Messaging Ihres Firebase-Konsolenprojekts und aktualisieren Sie die Seite.
6. Beachten Sie, dass sich der Header der Cloud Messaging-API in „Cloud Messaging-API (Legacy) ✅ Aktiviert“ geändert hat und jetzt einen Serverschlüssel anzeigt.

Konfigurieren eines Hubs

Melden Sie sich beim Azure-Portal an.
Wählen Sie im Menü links Alle Dienste aus.
Geben Sie Notification Hubs in das Textfeld Dienste filtern ein. Wählen Sie das Sternsymbol neben dem Dienstnamen aus, um den Dienst im linken Menü zum Abschnitt FAVORITEN hinzuzufügen. Wählen Sie Notification Hubs aus.
Wählen Sie auf der Seite Notification Hubs in der Symbolleiste die Option Erstellen aus.
Führen Sie auf der Registerkarte Grundlagen der Seite Notification Hub die folgenden Schritte aus:
1. Wählen Sie unter Abonnement den Namen des Azure-Abonnements aus, das Sie verwenden möchten, und wählen Sie dann eine vorhandene Ressourcengruppe aus, oder erstellen Sie eine neue Ressourcengruppe.
2. Geben Sie unter Namespacedetails einen eindeutigen Namen für den neuen Namespace ein.
3. Ein Namespace enthält mindestens einen Notification Hub. Geben Sie daher unter Notification Hub-Details einen Namen für den Hub ein.
4. Wählen Sie im Dropdown-Listenfeld Standort einen Wert aus. Dieser Wert gibt den Standort an, an dem der Hub erstellt werden soll.
5. Überprüfen Sie die Option Verfügbarkeitszonen. Wenn Sie eine Region mit Verfügbarkeitszonen ausgewählt haben, ist das Kontrollkästchen standardmäßig aktiviert. Verfügbarkeitszonen sind ein kostenpflichtiges Feature, für das in Ihrem Tarif zusätzliche Gebühren anfallen.
6. Wählen Sie Ihre Option für die Notfallwiederherstellung aus: Keine, Gekoppelte Wiederherstellungsregion oder Flexible Wiederherstellungsregion. Wenn Sie Gekoppelte Wiederherstellungsregion auswählen, wird die Failoverregion angezeigt. Wenn Sie Flexible Wiederherstellungsregion auswählen, verwenden Sie die Dropdownliste, um aus einer Liste mit Wiederherstellungsregionen auszuwählen.
7. Klicken Sie auf Erstellen.
Wählen Sie nach Abschluss der Bereitstellung die Option Zu Ressourcengruppe wechseln.

Konfigurieren von Firebase Cloud Messaging-Einstellungen für den Hub

Wählen Sie im linken Bereich unter Einstellungen die Option Google (GCM/FCM) aus.
Geben Sie den Serverschlüssel für das FCM-Projekt ein, den Sie zuvor gespeichert haben.
Wählen Sie auf der Symbolleiste Save (Speichern) aus.
Im Azure-Portal wird in den Warnungen in einer Meldung angezeigt, dass der Hub aktualisiert wurde. Die Schaltfläche Save (Speichern) ist deaktiviert.

Der Hub ist jetzt für die Verwendung mit Firebase Cloud Messaging konfiguriert. Sie verfügen außerdem über die Verbindungszeichenfolgen, die erforderlich sind, um Benachrichtigungen an ein Gerät zu senden und eine App für den Empfang von Benachrichtigungen zu registrieren.

Verbinden Ihrer App mit dem Notification Hub

Hinzufügen von Google Play Services zum Projekt

Wählen Sie in Android Studio im Menü die Option Tools und dann SDK Manager aus.
Wählen Sie die Zielversion des Android SDK aus, das in Ihrem Projekt verwendet wird. Wählen Sie dann Paketdetails anzeigen aus.
Wählen Sie die Option Google-APIs, falls diese Installation noch nicht durchgeführt wurde.
Wechseln Sie auf die Registerkarte SDK Tools (SDK-Tools). Wählen Sie wie in der folgenden Abbildung dargestellt die Option Google Play Services, falls Google Play Services noch nicht installiert ist. Wählen Sie dann Anwenden aus, um die Installation auszuführen. Notieren Sie den SDK-Pfad, den Sie in einem späteren Schritt angeben müssen.
Wählen Sie OK, wenn das Dialogfeld Änderung bestätigen angezeigt wird. Die gewünschten Komponenten werden mit dem entsprechenden Installationsprogramm installiert. Wählen Sie Fertig stellen, wenn die Installation der Komponenten abgeschlossen ist.
Wählen Sie OK, um das Dialogfeld Settings for New Projects (Einstellungen für neue Projekte) zu schließen.

Öffnen Sie die Datei „AndroidManifest.xml“, und fügen Sie dann das folgende Tag zum Tag application hinzu.

<meta-data android:name="com.google.android.gms.version"
     android:value="@integer/google_play_services_version" />

Hinzufügen von Azure Notification Hubs-Bibliotheken

Fügen Sie in der Datei „Build.Gradle“ der App im Abschnitt „dependencies“ die folgenden Zeilen hinzu.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Fügen Sie nach dem Abschnitt „dependencies“ das folgende Repository hinzu:

repositories {
    maven {
        url "https://dl.bintray.com/microsoftazuremobile/SDK"
    }
}

Hinzufügen von Unterstützung für Google Firebase

Fügen Sie in der Datei „Build.Gradle“ für die App im Abschnitt dependencies die folgenden Zeilen hinzu, sofern sie noch nicht vorhanden sind.

implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
implementation 'com.google.firebase:firebase-iid:21.1.0'

Fügen Sie am Ende der Datei das folgende Plug-In hinzu, sofern es noch nicht vorhanden ist.
```
apply plugin: 'com.google.gms.google-services'
```
Wählen Sie auf der Symbolleiste Sync Now (Jetzt synchronisieren) aus.

Aktualisieren der Datei „AndroidManifest.xml“

Nachdem Sie das FCM-Registrierungstoken erhalten haben, verwenden Sie es für die Registrierung bei Azure Notification Hubs. Sie unterstützen diese Registrierung im Hintergrund mit einem IntentService mit dem Namen RegistrationIntentService. Mit diesem Dienst wird auch das FCM-Registrierungstoken aktualisiert. Darüber hinaus erstellen Sie eine Klasse namens FirebaseService als Unterklasse von FirebaseMessagingService und überschreiben die Methode onMessageReceived, um Benachrichtigungen zu erhalten und zu verarbeiten.

Fügen Sie der Datei „AndroidManifest.xml“ im Tag <application> die unten angegebene Dienstdefinition hinzu.
```
<service
    android:name=".RegistrationIntentService"
    android:exported="false">
</service>
<service
    android:name=".FirebaseService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>
```

Fügen Sie unterhalb des Tags </application> die folgenden erforderlichen FCM-bezogenen Berechtigungen hinzu.

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.GET_ACCOUNTS"/>
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />

Code hinzufügen

Erweitern Sie in der Projektansicht die Knoten app>src>main>java. Klicken Sie mit der rechten Maustaste unter java auf Ihren Paketordner. Wählen Sie Neu und dann Java-Klasse aus. Geben Sie NotificationSettings als Name ein, und wählen Sie OK aus.

Aktualisieren Sie diese zwei Platzhalter im weiter unten angegebenen Code für die NotificationSettings-Klasse:
- HubListenConnectionString: Die DefaultListenAccessSignature-Verbindungszeichenfolge für Ihren Hub. Sie können diese Verbindungszeichenfolge kopieren, indem Sie im Azure portal im Hub auf Zugriffsrichtlinien klicken.
- HubName: Verwenden Sie den Namen des Hubs, der im Azure portal auf der Hubseite angezeigt wird.
  
  NotificationSettings -Code:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Wichtig
  
  Geben Sie für den Hub den Namen und einen Wert für DefaultListenSharedAccessSignature ein, bevor Sie fortfahren.

Fügen Sie dem Projekt eine weitere neue Klasse namens RegistrationIntentServicehinzu. Diese Klasse implementiert die IntentService-Schnittstelle. Außerdem wird mit dieser Klasse die Aktualisierung des FCM-Tokens und die Registrierung beim Notification Hub verarbeitet.

Verwenden Sie für diese Klasse den folgenden Code.

import android.app.IntentService;
import android.content.Intent;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import android.util.Log;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.InstanceIdResult;
import com.microsoft.windowsazure.messaging.NotificationHub;
import java.util.concurrent.TimeUnit;

public class RegistrationIntentService extends IntentService {

    private static final String TAG = "RegIntentService";
    String FCM_token = null;

    private NotificationHub hub;

    public RegistrationIntentService() {
        super(TAG);
    }

    @Override
    protected void onHandleIntent(Intent intent) {

        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
        String resultString = null;
        String regID = null;
        String storedToken = null;

        try {
            FirebaseInstanceId.getInstance().getInstanceId().addOnSuccessListener(new OnSuccessListener<InstanceIdResult>() { 
                @Override 
                public void onSuccess(InstanceIdResult instanceIdResult) { 
                    FCM_token = instanceIdResult.getToken(); 
                    Log.d(TAG, "FCM Registration Token: " + FCM_token); 
                } 
            }); 
            TimeUnit.SECONDS.sleep(1);

            // Storing the registration ID that indicates whether the generated token has been
            // sent to your server. If it is not stored, send the token to your server.
            // Otherwise, your server should have already received the token.
            if (((regID=sharedPreferences.getString("registrationID", null)) == null)){

                NotificationHub hub = new NotificationHub(NotificationSettings.HubName,
                        NotificationSettings.HubListenConnectionString, this);
                Log.d(TAG, "Attempting a new registration with NH using FCM token : " + FCM_token);
                regID = hub.register(FCM_token).getRegistrationId();

                // If you want to use tags...
                // Refer to : https://azure.microsoft.com/documentation/articles/notification-hubs-routing-tag-expressions/
                // regID = hub.register(token, "tag1,tag2").getRegistrationId();

                resultString = "New NH Registration Successfully - RegId : " + regID;
                Log.d(TAG, resultString);

                sharedPreferences.edit().putString("registrationID", regID ).apply();
                sharedPreferences.edit().putString("FCMtoken", FCM_token ).apply();
            }

            // Check to see if the token has been compromised and needs refreshing.
           else if (!(storedToken = sharedPreferences.getString("FCMtoken", "")).equals(FCM_token)) {

                NotificationHub hub = new NotificationHub(NotificationSettings.HubName,
                        NotificationSettings.HubListenConnectionString, this);
                Log.d(TAG, "NH Registration refreshing with token : " + FCM_token);
                regID = hub.register(FCM_token).getRegistrationId();

                // If you want to use tags...
                // Refer to : https://azure.microsoft.com/documentation/articles/notification-hubs-routing-tag-expressions/
                // regID = hub.register(token, "tag1,tag2").getRegistrationId();

                resultString = "New NH Registration Successfully - RegId : " + regID;
                Log.d(TAG, resultString);

                sharedPreferences.edit().putString("registrationID", regID ).apply();
                sharedPreferences.edit().putString("FCMtoken", FCM_token ).apply();
            }

            else {
                resultString = "Previously Registered Successfully - RegId : " + regID;
            }
        } catch (Exception e) {
            Log.e(TAG, resultString="Failed to complete registration", e);
            // If an exception happens while fetching the new token or updating registration data
            // on a third-party server, this ensures that we'll attempt the update at a later time.
        }

        // Notify UI that registration has completed.
        if (MainActivity.isVisible) {
            MainActivity.mainActivity.ToastNotify(resultString);
        }
    }
}

Fügen Sie in der MainActivity-Klasse oberhalb der Klassendeklaration die folgenden import-Anweisungen hinzu.

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import android.content.Intent;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;

Fügen Sie im oberen Bereich der Klasse die folgenden Member hinzu. Sie verwenden diese Felder zum Überprüfen der Verfügbarkeit von Google Play Services gemäß Empfehlung von Google.

public static MainActivity mainActivity;
public static Boolean isVisible = false;
private static final String TAG = "MainActivity";
private static final int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;

Fügen Sie in der MainActivity-Klasse die folgende Methode hinzu, um die Verfügbarkeit von Google Play Services zu überprüfen.

/**
* Check the device to make sure it has the Google Play Services APK. If
* it doesn't, display a dialog box that enables  users to download the APK from
* the Google Play Store or enable it in the device's system settings.
*/

private boolean checkPlayServices() {
    GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
    int resultCode = apiAvailability.isGooglePlayServicesAvailable(this);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (apiAvailability.isUserResolvableError(resultCode)) {
            apiAvailability.getErrorDialog(this, resultCode, PLAY_SERVICES_RESOLUTION_REQUEST)
                    .show();
        } else {
            Log.i(TAG, "This device is not supported by Google Play Services.");
            ToastNotify("This device is not supported by Google Play Services.");
            finish();
        }
        return false;
    }
    return true;
}

Fügen Sie in der MainActivity-Klasse den folgenden Code hinzu, mit dem eine Überprüfung auf Google Play Services durchgeführt wird, bevor Sie IntentService aufrufen, um Ihr FCM-Registrierungstoken abzurufen und die Registrierung beim Hub vorzunehmen:

public void registerWithNotificationHubs()
{
    if (checkPlayServices()) {
        // Start IntentService to register this application with FCM.
        Intent intent = new Intent(this, RegistrationIntentService.class);
        startService(intent);
    }
}

Fügen Sie in der OnCreate-Methode der MainActivity-Klasse den folgenden Code hinzu, um den Registrierungsprozess zu starten, wenn die Aktivität erstellt wird:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mainActivity = this;
    registerWithNotificationHubs();
    FirebaseService.createChannelAndHandleNotifications(getApplicationContext());
}

Fügen Sie dem MainActivity-Element diese zusätzlichen Methoden hinzu, um den App-Zustand zu überprüfen und den Status in Ihrer App zu melden:

@Override
protected void onStart() {
    super.onStart();
    isVisible = true;
}

@Override
protected void onPause() {
    super.onPause();
    isVisible = false;
}

@Override
protected void onResume() {
    super.onResume();
    isVisible = true;
}

@Override
protected void onStop() {
    super.onStop();
    isVisible = false;
}

public void ToastNotify(final String notificationMessage) {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            Toast.makeText(MainActivity.this, notificationMessage, Toast.LENGTH_LONG).show();
            TextView helloText = (TextView) findViewById(R.id.text_hello);
            helloText.setText(notificationMessage);
        }
    });
}

Für die ToastNotify-Methode wird das TextView-Steuerelement „Hello World“ verwendet, um Status und Benachrichtigungen dauerhaft in der App zu melden. Fügen Sie im Layout von res>layout>activity_main.xml die folgende ID für dieses Steuerelement hinzu.
```
android:id="@+id/text_hello"
```
Als Nächstes fügen Sie eine Unterklasse für den Empfänger hinzu, den Sie in „AndroidManifest.xml“ definiert haben. Fügen Sie dem Projekt eine weitere neue Klasse namens FirebaseServicehinzu.

Fügen Sie am Anfang von FirebaseService.java die folgenden Importanweisungen hinzu:

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;
import android.util.Log;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import androidx.core.app.NotificationCompat;

Fügen Sie für die FirebaseService-Klasse den folgenden Code hinzu, um sie als Unterklasse von FirebaseMessagingService festzulegen.

Dieser Code überschreibt die onMessageReceived-Methode und meldet empfangene Benachrichtigungen. Er sendet außerdem die Pushbenachrichtigung mit der sendNotification()-Methode an den Android-Benachrichtigungs-Manager. Rufen Sie die sendNotification()-Methode auf, wenn die App nicht ausgeführt wird und eine Benachrichtigung eingeht.

public class FirebaseService extends FirebaseMessagingService
{
    private String TAG = "FirebaseService";

    public static final String NOTIFICATION_CHANNEL_ID = "nh-demo-channel-id";
    public static final String NOTIFICATION_CHANNEL_NAME = "Notification Hubs Demo Channel";
    public static final String NOTIFICATION_CHANNEL_DESCRIPTION = "Notification Hubs Demo Channel";

    public static final int NOTIFICATION_ID = 1;
    private NotificationManager mNotificationManager;
    NotificationCompat.Builder builder;
    static Context ctx;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // ...

        // TODO(developer): Handle FCM messages here.
        // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
        Log.d(TAG, "From: " + remoteMessage.getFrom());

        String nhMessage;
        // Check if message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d(TAG, "Message Notification Body: " + remoteMessage.getNotification().getBody());

            nhMessage = remoteMessage.getNotification().getBody();
        }
        else {
            nhMessage = remoteMessage.getData().values().iterator().next();
        }

        // Also if you intend on generating your own notifications as a result of a received FCM
        // message, here is where that should be initiated. See sendNotification method below.
        if (MainActivity.isVisible) {
            MainActivity.mainActivity.ToastNotify(nhMessage);
        }
        sendNotification(nhMessage);
    }

    private void sendNotification(String msg) {

        Intent intent = new Intent(ctx, MainActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

        mNotificationManager = (NotificationManager)
                ctx.getSystemService(Context.NOTIFICATION_SERVICE);

        PendingIntent contentIntent = PendingIntent.getActivity(ctx, 0,
                intent, PendingIntent.FLAG_ONE_SHOT);

        Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(
                ctx,
                NOTIFICATION_CHANNEL_ID)
                .setContentText(msg)
                .setPriority(NotificationCompat.PRIORITY_HIGH)
                .setSmallIcon(android.R.drawable.ic_popup_reminder)
                .setBadgeIconType(NotificationCompat.BADGE_ICON_SMALL);

        notificationBuilder.setContentIntent(contentIntent);
        mNotificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
    }

    public static void createChannelAndHandleNotifications(Context context) {
        ctx = context;

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(
                    NOTIFICATION_CHANNEL_ID,
                    NOTIFICATION_CHANNEL_NAME,
                    NotificationManager.IMPORTANCE_HIGH);
            channel.setDescription(NOTIFICATION_CHANNEL_DESCRIPTION);
            channel.setShowBadge(true);

            NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
            notificationManager.createNotificationChannel(channel);
         }
    }
}

Wählen Sie in Android Studio auf der Menüleiste die Optionen Build>Rebuild Project aus, um sicherzustellen, dass im Code keine Fehler enthalten sind. Wenn eine Fehlermeldung zum Symbol ic_launcher angezeigt wird, entfernen Sie die folgende Anweisung aus der Datei „AndroidManifest.xml“:
```
    android:icon="@mipmap/ic_launcher"
```
Stellen Sie sicher, dass Sie über ein virtuelles Gerät zum Ausführen der App verfügen. Wenn Sie keines haben, fügen Sie wie folgt eines hinzu:
Führen Sie die App auf Ihrem ausgewählten Gerät aus, und vergewissern Sie sich, dass sie richtig beim Hub registriert wird.

Hinweis

Bei der Registrierung treten beim ersten Starten unter Umständen Fehler auf, bis die onTokenRefresh()-Methode des Instanz-ID-Diensts aufgerufen wird. Durch die Aktualisierung sollte eine erfolgreiche Registrierung beim Notification Hub initiiert werden.

Testsendung der Benachrichtigung über den Notification Hub

Sie können Pushbenachrichtigungen mit folgenden Schritten über das Azure portal senden:

Wählen Sie im Azure-Portal auf der Seite „Notification Hub“ für Ihren Hub im Abschnitt Problembehandlung die Option Testsendevorgang aus.
Wählen Sie für Plattformen die Option Android aus.
Wählen Sie Senden aus. Es wird noch keine Benachrichtigung auf dem Android-Gerät angezeigt, da Sie die mobile App nicht darauf ausgeführt haben. Wählen Sie nach dem Ausführen der mobilen App erneut die Schaltfläche Senden aus, um die Benachrichtigung anzuzeigen.
Sie sehen das Ergebnis des Vorgangs in der Liste unten im Fenster.
Die Benachrichtigung wird auf Ihrem Gerät angezeigt.

Pushbenachrichtigungen werden normalerweise mithilfe einer kompatiblen Bibliothek über einen Back-End-Dienst wie Mobile Apps oder ASP.NET gesendet. Falls für Ihr Back-End keine Bibliothek verfügbar ist, können Sie Benachrichtigungen auch direkt über die REST-API senden.

Es folgen einige andere Tutorials, die Informationen zum Senden von Benachrichtigungen enthalten:

Azure Mobile Apps: Ein Beispiel für das Senden von Benachrichtigungen von einem mit Notification Hubs integrierten Mobile Apps-Back-End finden Sie unter Hinzufügen von Pushbenachrichtigungen zu Ihrer iOS-App.
ASP.NET: Verwenden von Notification Hubs für Pushbenachrichtigungen an Benutzer.
Azure Notification Hub Java SDK: Informationen zum Senden von Benachrichtigungen über Java finden Sie unter Verwenden von Notification Hubs von Java aus . Dies wurde für die Android-Entwicklung in Eclipse getestet.
PHP: Verwenden von Notification Hubs von PHP aus.

Ausführen der mobilen App im Emulator

Vor dem Testen von Pushbenachrichtigungen in einem Emulator müssen Sie sicherstellen, dass das Emulatorimage die Google-API-Ebene unterstützt, die Sie für die App ausgewählt haben. Falls Ihr Image keine nativen Google-APIs unterstützt, tritt unter Umständen eine Ausnahme vom Typ SERVICE_NOT_AVAILABLE auf.

Stellen Sie zusätzlich sicher, dass Ihr Google-Konto dem ausgeführten Emulator unter Einstellungen>Konten hinzugefügt wurde. Andernfalls führt die Registrierung bei FCM möglicherweise zur Ausnahme AUTHENTICATION_FAILED.

Nächste Schritte

In diesem Tutorial haben Sie mit Firebase Cloud Messaging Benachrichtigungen an alle Android-Geräte gesendet, die bei dem Dienst registriert wurden. Um zu erfahren, wie Sie Pushbenachrichtigungen an bestimmte Geräte senden, fahren Sie mit dem folgenden Tutorial fort:

Tutorial: Senden von Pushbenachrichtigungen an bestimmte Android-Geräte

Freigeben über