Zelfstudie: Pushmeldingen verzenden naar Android-apparaten met firebase SDK versie 0.6

Artikel
03/05/2024

In deze zelfstudie wordt gedemonstreerd hoe u met Azure Notification Hubs en de Firebase Cloud Messaging (FCM) SDK versie 0.6 en pushmeldingen verzendt naar een Android-toepassing. In deze zelfstudie gaat u een lege Android-app maken die pushmeldingen ontvangt via Firebase Cloud Messaging (FCM).

Belangrijk

Google stopt met het ondersteunen van verouderde FCM HTTP op 20 juni 2024. Zie De migratie van Azure Notification Hubs en Google Firebase Cloud Messaging voor meer informatie.

U kunt de voltooide code voor deze zelfstudie downloaden op GitHub.

In deze zelfstudie voert u de volgende stappen uit:

Een Android Studio-project maken.
Een Firebase-project maken dat Firebase Cloud Messaging ondersteunt.
Maak een hub.
Verbind uw app met de hub.
De app testen.

Vereisten

U hebt een actief Azure-account nodig om deze zelfstudie te voltooien. Als u geen account hebt, kunt u binnen een paar minuten een account voor de gratis proefversie maken. Zie Gratis proefversie van Azure voor meer informatie.

U hebt ook de volgende items nodig:

De nieuwste versie van Android Studio
Android 2.3 of hoger voor Firebase Cloud Messaging
Google Repository revisie 27 of hoger voor Firebase Cloud Messaging
Google Play-Services 9.0.2 of hoger voor Firebase Cloud Messaging

Het voltooien van deze zelfstudie is een vereiste voor alle andere Notification Hubs-zelfstudies voor Android-apps.

Een Android Studio-project maken

Start Android Studio.
Selecteer File, wijs naar New en selecteer New Project.
Selecteer Empty Activity op de pagina Choose your project en selecteer Next.
Voer op de pagina Uw project configureren de volgende stappen uit:
1. Voer bij Name een naam in voor de toepassing.
2. Geef een locatie om voor het opslaan van de projectbestanden.
3. Selecteer Voltooien.

Een Firebase-project maken dat FCM ondersteunt

Meld u aan bij de Firebase-console. Maak een nieuw Firebase-project als u er nog geen hebt.
Nadat u uw project hebt gemaakt, selecteert u Firebase toevoegen aan uw Android-app.
Voer de volgende stappen uit op de pagina Firebase toevoegen aan uw Android-app:
1. Voor Android-pakketnaam kopieert u de waarde van uw applicationId in het bestand build.gradle van uw toepassing. In dit voorbeeld is het com.fabrikam.fcmtutorial1app.
2. Selecteer App registreren.
Selecteer google-services.json downloaden, sla het bestand op in de map app van uw project, en selecteer Volgende.
Breng de volgende configuratiewijzigingen aan in uw project in Android Studio.
1. Voeg in het bestand build.gradle op projectniveau (<project>/build.gradle) de volgende instructie toe aan de sectie dependencies (afhankelijkheden).
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Voeg in het build.gradle-bestand op app-niveau (<project>/<app-module>/build.gradle) de volgende instructies toe aan de sectie afhankelijkheden .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Voeg de volgende regel toe aan het einde van het build.gradle-bestand op app-niveau na de sectie met afhankelijkheden.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selecteer Nu synchroniseren op de werkbalk.
Selecteer Volgende.
Selecteer Deze stap overslaan.
Selecteer in de Firebase-console het tandwiel van uw project. Selecteer vervolgens Projectinstellingen.
Als u het bestand google-services.json niet hebt gedownload in de map app van uw Android Studio-project, kunt u dat op deze pagina doen.
Ga naar Cloud Messaging bovenaan op het tabblad.
Kopieer de Serversleutel en sla deze op voor later gebruik. U gebruikt deze waarde om uw hub te configureren.
Als u geen serversleutel ziet op het tabblad Firebase Cloud Messaging, volgt u deze aanvullende stappen.
1. Klik op het menu met drie puntjes van de kop 'Cloud Messaging-API (verouderd) 🚫 uitgeschakeld'
2. Volg de aangeboden koppeling naar 'API beheren in Google Cloud Console'.
3. Druk in de Google Cloud-console op de knop om de googlecloudmessaging-API in te schakelen.
4. Wacht enkele minuten.
5. Ga terug naar het tabblad Cloud Messaging van de firebase-console en vernieuw de pagina.
6. Zie dat de Header van de Cloud Messaging-API is gewijzigd in 'Cloud Messaging-API (verouderd) ✅ ingeschakeld' en nu een serversleutel weergeeft.

Een hub configureren

Meld u aan bij het Azure-portaal.
Selecteer Alle services in het linkermenu.
Typ Notification Hubs in het tekstvak Filterservices . Selecteer het sterpictogram naast de servicenaam om de service toe te voegen aan de sectie FAVORIETEN in het menu aan de linkerkant. Selecteer Notification Hubs.
Selecteer Op de pagina Notification Hubs maken op de werkbalk.
Voer op het tabblad Basis op de pagina Notification Hub de volgende stappen uit:
1. Selecteer in Abonnement de naam van het Azure-abonnement dat u wilt gebruiken en selecteer vervolgens een bestaande resourcegroep of maak een nieuw abonnement.
2. Voer een unieke naam in voor de nieuwe naamruimte in Naamruimtedetails.
3. Een naamruimte bevat een of meer Notification Hubs, dus typ een naam voor de hub in Notification Hub Details.
4. Selecteer een waarde in de vervolgkeuzelijst Locatie. Deze waarde specificeert de locatie waar u de hub wilt maken.
5. Controleer de optie Beschikbaarheidszones. Als u een regio met beschikbaarheidszones hebt gekozen, is het selectievakje standaard ingeschakeld. Beschikbaarheidszones is een betaalde functie, dus er worden extra kosten aan uw laag toegevoegd.
6. Kies een optie voor herstel na noodgevallen : Geen, Gekoppelde herstelregio of Flexibele herstelregio. Als u gekoppelde herstelregio kiest, wordt de failoverregio weergegeven. Als u Flexibele herstelregio selecteert, gebruikt u de vervolgkeuzelijst om te kiezen uit een lijst met herstelregio's.
7. Selecteer Maken.
Wanneer de implementatie is voltooid, selecteert u Ga naar de resource.

Firebase Cloud Messaging-instellingen voor de hub configureren

Selecteer in het linkerdeelvenster onder Instellingen de optie Google (GCM/FCM).
Voer de serversleutel in voor het FCM-project dat u eerder hebt opgeslagen.
Selecteer Opslaan op de werkbalk.
De Azure-portal geeft een bericht weer in de waarschuwingen dat de hub is bijgewerkt. De knop Opslaan kan niet worden gekozen.

Uw hub is nu geconfigureerd om te werken met Firebase Cloud Messaging. U hebt ook de verbindingsreeksen die nodig zijn om meldingen naar een apparaat te verzenden en een app te registreren voor het ontvangen van meldingen.

Uw app verbinden met de Notification Hub

Google Play-services aan het project toevoegen

Selecteer in Android Studio in het menu de optie Hulpprogramma’s, en selecteer vervolgens SDK Manager.
Selecteer de doelversie van de Android SDK die wordt gebruikt in het project. Selecteer vervolgens Pakketdetails weergeven.
Selecteer Google API’s als dit nog niet is geïnstalleerd.
Ga naar het tabblad SDK-hulpprogramma's . Als u Google Play Services nog niet hebt geïnstalleerd, selecteert u Google Play Services , zoals wordt weergegeven in de volgende afbeelding. Selecteer vervolgens Toepassen om de installatie te starten. Noteer het SDK-pad om het in een later stadium te kunnen gebruiken.
Klik op OK zodra het dialoogvenster Wijziging bevestigen wordt weergegeven. De vereiste onderdelen worden geïnstalleerd met behulp van het installatieprogramma voor onderdelen. Selecteer Voltooien zodra de onderdelen zijn geïnstalleerd.
Selecteer OK om het dialoogvenster Instellingen voor nieuwe projecten te sluiten.

Open het bestand AndroidManifest.xml en voeg de volgende code toe aan de tag toepassing.

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

Azure Notification Hubs-bibliotheken toevoegen

Voeg in het bestand Build.Gradle voor de app de volgende regels toe in het gedeelte met afhankelijkheden.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Voeg de volgende opslagplaats toe na het gedeelte met afhankelijkheden.

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

Ondersteuning voor Google Firebase toevoegen

Voeg in het bestand Build.Gradle voor de app de volgende regels toe aan het gedeelte afhankelijkheden als die er nog niet staan.

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'

Voeg de volgende invoegtoepassing toe aan het einde van het bestand als deze er nog niet staat.
```
apply plugin: 'com.google.gms.google-services'
```
Selecteer Nu synchroniseren op de werkbalk.

Het bestand AndroidManifest.xml bijwerken

Nadat u uw FCM-registratietoken hebt ontvangen, gebruikt u dit om te registreren bij Azure Notification Hubs. U ondersteunt deze registratie op de achtergrond met een IntentService met de naam RegistrationIntentService. Met deze service wordt ook uw FCM-registratietoken vernieuwd. U maakt ook een klasse met de naam FirebaseService als subklasse van FirebaseMessagingService en overschrijft de onMessageReceived-methode om meldingen te ontvangen en af te handelen.

Voeg de volgende servicedefinitie toe aan het bestand AndroidManifest.xml in de <application>-tag.
```
<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>
```

Voeg de volgende vereiste FCM-gerelateerde machtigingen toe onder de tag </application>.

<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 toevoegen

Vouw in de Project-weergave app>src>main>java uit. Klik met de rechtermuisknop op de pakketmap onder java, selecteer Nieuw en selecteer vervolgens Java-klasse. Voer NotificationSettings in voor de naam en selecteer vervolgens OK.

Zorg ervoor dat u deze twee tijdelijke aanduidingen bijwerkt in de volgende code voor de NotificationSettings klasse:
- HubListenConnectionString: de verbindingsreeks DefaultListenAccessSignature voor de hub. Kopieer deze verbindingsreeks door te klikken op Toegangsbeleid in uw hub in de Azure-portal.
- HubName: gebruik de naam van uw hub die wordt weergegeven op de hubpagina in Azure Portal.
  
  NotificationSettings-code:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Belangrijk
  
  Voer de naam en de DefaultListenSharedAccessSignature van uw hub voordat u verdergaat.

Voeg een andere nieuwe klasse toe aan uw project met de naam RegistrationIntentService. Met deze klasse wordt de IntentService-interface geïmplementeerd. Deze zorgt ook voor het vernieuwen van het GCM-token en de registratie bij de Notification Hub.

Gebruik de volgende code voor deze klasse.

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);
        }
    }
}

Voeg in de klasse MainActivity de volgende instructies voor import toe boven de klassendeclaratie.

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;

Voeg de volgende leden toe bovenaan de klasse. U gebruikt deze velden om de beschikbaarheid van Google Play Services te controleren, zoals aanbevolen door 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;

Voeg in de klasse MainActivity de volgende methode toe om de beschikbaarheid van Google Play Services te controleren.

/**
* 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;
}

Voeg in de klasse MainActivity de volgende code toe waarmee Google Play Services wordt gecontroleerd voordat u de IntentService aanroept om uw FCM-registratietoken op te halen en te registreren met uw hub:

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

In de methode OnCreate van de klasse MainActivity voegt u de volgende code toe om het registratieproces te starten wanneer de activiteit wordt gemaakt:

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

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

Voeg deze extra methoden toe aan de MainActivity om de status van de app te controleren en een rapport van de status in uw app op te nemen:

@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);
        }
    });
}

Voor de methode ToastNotify wordt het besturingselement Hallo wereld TextView gebruikt om de status en kennisgevingen permanent in de app te melden. Voeg in de indeling res>layout>activity_main.xml de volgende id toe voor het besturingselement.
```
android:id="@+id/text_hello"
```
Vervolgens gaat u een subklasse toevoegen voor de ontvanger die u hebt gedefinieerd in AndroidManifest.xml. Voeg een andere nieuwe klasse toe aan uw project met de naam FirebaseService.

Voeg boven in FirebaseService.java de volgende importinstructie toe:

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;

Voeg de volgende code toe voor de klasse FirebaseService, zodat dit een subklasse van FirebaseMessagingService wordt.

Deze code overschrijft de methode onMessageReceived, en rapporteert de ontvangen meldingen. Deze verzendt ook de pushmelding naar Android Notification Manager met de methode sendNotification(). De methode sendNotification() moet worden aangeroepen wanneer de app niet actief is en een melding is ontvangen.

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);
         }
    }
}

Klik in Android Studio in de menubalk op Bouwen>Project opnieuw opbouwen om ervoor te zorgen dat uw code geen fouten bevat. Als u een foutbericht ontvangt over het pictogram ic_launcher, verwijdert u de volgende instructie uit het bestand AndroidManifest.xml:
```
    android:icon="@mipmap/ic_launcher"
```
Zorg ervoor dat u een virtueel apparaat hebt voor het uitvoeren van de app. Als u er geen hebt, voegt u er als volgt een toe:
Voer de app uit op uw geselecteerde apparaat en controleer of dat deze correct is geregistreerd in de hub.

Notitie

De registratie kan mislukken bij de eerste keer starten totdat de methode onTokenRefresh() van de exemplaar-id-service wordt aangeroepen. De vernieuwing moet een succesvolle registratie met de Notification Hub tot stand brengen.

Testen van melding verzenden vanuit de Notification Hub

U kunt pushmeldingen verzenden vanuit de Azure-portal door de volgende stappen uit te voeren:

Ga in de Azure-portal naar de pagina Notification Hub voor uw hub en selecteer Verzenden testen in het gedeelte Probleemoplossing.
Selecteer voor Platforms de optie Android.
Selecteer Verzenden. U ziet nog geen melding op het Android-apparaat omdat u daarop de mobiele app niet hebt uitgevoerd. Nadat u de mobiele app hebt uitgevoerd, selecteert u opnieuw Verzenden om de melding weer te geven.
Bekijk het resultaat van de bewerking in de lijst onderaan.
U ziet de melding op uw apparaat.

Pushmeldingen worden gewoonlijk in een back-endservice zoals Mobile Apps of ASP.NET verzonden met een compatibele bibliotheek. U kunt de REST API ook rechtstreeks gebruiken om meldingsberichten te verzenden als er geen bibliotheek beschikbaar is voor uw back-end.

Hier volgt een lijst met andere zelfstudies die u mogelijk kunt bekijken voor het verzenden van meldingen:

Azure Mobile Apps: Zie Pushmeldingen toevoegen aan uw iOS-app voor een voorbeeld van het verzenden van meldingen vanuit een back-end van Mobile Apps die is geïntegreerd met Notification Hubs.
ASP.NET: gebruik Notification Hubs om meldingen naar gebruikers te pushen.
Azure Notification Hub Java SDK: zie How to use Notification Hubs from Java (Notification Hubs gebruiken vanuit Java) voor het verzenden van meldingen vanuit Java. Dit is getest in Eclipse voor Android-ontwikkeling.
PHP: zie How to use Notification Hubs from PHP (Notification Hubs gebruiken vanuit PHP).

De mobiele app uitvoeren in een emulator

Voordat u pushmeldingen binnen een emulator test, moet u ervoor zorgen dat de installatiekopie van de emulator het Google API-niveau ondersteunt dat u voor uw app hebt gekozen. Als uw installatiekopieën geen ondersteuning bieden voor systeemeigen Google-API's, krijgt u mogelijk de SERVICE_NOT_AVAILABLE uitzondering.

Bovendien moet uw Google-account zijn toegevoegd aan de actieve emulator onder Instellingen>Accounts. Anders kunnen uw pogingen om te registreren bij FCM leiden tot de AUTHENTICATION_FAILED uitzondering.

Volgende stappen

In deze zelfstudie hebt u Firebase Cloud Messaging gebruikt om meldingen te verzenden naar alle Android-apparaten die zijn geregistreerd bij de service. Ga verder met de volgende zelfstudie als u wilt weten hoe u pushmeldingen kunt verzenden naar specifieke apparaten:

Zelfstudie: Pushmeldingen verzenden naar specifieke Android-apparaten

Delen via