Självstudie: Skicka push-meddelanden till Android-enheter med Firebase SDK version 0.6

2025-05-04

I den här självstudien beskrivs hur du använder Azure Notification Hubs och Firebase Cloud Messaging (FCM) SDK version 0.6 för att skicka push-meddelanden till ett Android-program. I den här självstudien skapar du en tom Android-app som tar emot push-meddelanden med hjälp av Firebase Cloud Messaging (FCM).

Viktigt!

Google slutar stödja FCM äldre HTTP den 20 juni 2024. Mer information finns i Azure Notification Hubs och Google Firebase Cloud Messaging-migrering.

Den färdiga koden för den här självstudien kan laddas ned från GitHub.

I den här självstudien gör du följande:

Skapa ett Android Studio-projekt.
Skapa ett Firebase-projekt som stöder Firebase Cloud Messaging.
Skapa en hubb.
Anslut din app till hubben.
Testa appen.

Förutsättningar

Du måste ha ett aktivt Azure-konto för att slutföra den här självstudiekursen. Om du inte har något konto kan skapa du ett kostnadsfritt utvärderingskonto på bara några minuter. Mer information finns i Kostnadsfri utvärderingsversion av Azure.

Du behöver också följande:

Den senaste versionen av Android Studio
Android 2.3 eller senare för Firebase Cloud Messaging
Google Repository revision 27 eller senare för Firebase Cloud Messaging
Google Play Services 9.0.2 eller senare för Firebase Cloud Messaging

Att slutföra den här självstudien är en förutsättning för att göra alla andra Notification Hubs-självstudier för Android-appar.

Skapa ett Android Studio-projekt

Starta Android Studio.
Välj Arkiv, peka på Nytt och välj sedan Nytt projekt.
På sidan Välj projekt väljer du Tom aktivitet och sedan Nästa.
På sidan Konfigurera projektet utför du följande steg:
1. Ange ett namn för applikationen.
2. Ange en plats där projektfilerna ska sparas.
3. Välj Slutför.

Skapa ett Firebase-projekt som stöder FCM

Logga in på Firebase-konsolen. Skapa ett nytt Firebase-projekt om du inte redan har ett.
När du har skapat ett projekt väljer du Lägg till Firebase till din Android-app.
På sidan Lägg till Firebase i din Android-app utför du följande steg:
1. För Android-paketnamn kopierar du värdet för ditt applicationId i programmets build.gradle-fil. I det här exemplet är det com.fabrikam.fcmtutorial1app.
2. Välj Registrera app.
Välj Ladda ned google-services.json, spara filen i appmappen för projektet och välj sedan Nästa.
Gör följande konfigurationsändringar i projektet i Android Studio.
1. I din build.gradle-fil på projektnivå (<project>/build.gradle) lägger du till följande sats i avsnittet beroenden.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. I filen build.gradle på appens nivå (<project>/<app-module>/build.gradle) lägger du till följande uttalanden i avsnittet dependencies.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Lägg till följande rad i slutet av filen build.gradle på appnivå efter avsnittet beroenden.
```
apply plugin: 'com.google.gms.google-services'
```
4. Välj Synkronisera nu i verktygsfältet.
Välj Nästa.
Välj Hoppa över det här steget.
Välj kugghjulet för ditt projekt i Firebase-konsolen. Välj sedan Projektinställningar.
Om du inte har laddat ned google-services.json-filen till appmappen för ditt Android Studio-projekt kan du göra det på den här sidan.
Växla till fliken Cloud Messaging längst upp.
Kopiera och spara servernyckeln för senare användning. Du använder det här värdet för att konfigurera din hubb.
Om du inte ser någon servernyckel på fliken Cloud Messaging för firebase följer du dessa ytterligare steg.
1. Klicka på menyn med tre punkter bredvid rubriken "Cloud Messaging API (Äldre) 🚫 inaktiverad"
2. Följ den länk som erbjuds till "Hantera API i Google Cloud Console".
3. I Google Cloud Console trycker du på knappen för att aktivera API:et för googlecloudmessaging.
4. Vänta några minuter.
5. Gå tillbaka till fliken Cloud Messaging för firebase-konsolprojektet och uppdatera sidan.
6. Se till att API-huvudet för Cloud Messaging har ändrats till "Cloud Messaging API (Legacy) ✅ Enabled" och nu visar en servernyckel.

Konfigurera en hubb

Logga in på Azure-portalen.
Välj Alla tjänster på den vänstra menyn.
Skriv Notification Hubs i textrutan Filtertjänster . Välj stjärnikonen bredvid tjänstnamnet för att lägga till tjänsten i avsnittet FAVORITER på den vänstra menyn. Välj Notification Hubs.
På sidan Notification Hubs väljer du Skapa i verktygsfältet.
Gör följande på fliken Grundläggande på sidan Notification Hub:
1. I Prenumeration väljer du namnet på den Azure-prenumeration som du vill använda och väljer sedan en befintlig resursgrupp eller skapar en ny.
2. Ange ett unikt namn för det nya namnområdet i Namnområdesinformation.
3. Ett namnområde innehåller en eller flera meddelandehubbar, så skriv ett namn för hubben i Meddelandehubbens information.
4. Välj ett värde i listrutan Plats . Det här värdet anger den plats där du vill skapa hubben.
5. Granska alternativet Tillgänglighetszoner. Om du väljer en region som har tillgänglighetszoner markeras kryssrutan som standard. Tillgänglighetszoner är en betald funktion, så en extra avgift läggs till på din nivå.
6. Välj ett havåterställningsalternativ: Ingen, Parvis återställningsregion eller Flexibel återställningsregion. Om du väljer parkopplad återställningsregionvisas failoverregionen. Om du väljer Flexibel återställningsregion använder du listrutan för att välja från en lista över återställningsregioner.
7. Välj Skapa.
När distributionen är klar väljer du Gå till resurs.

Konfigurera Firebase Cloud Messaging-inställningar för hubben

I den vänstra rutan under Inställningar väljer du Google (GCM/FCM).
Ange servernyckeln för FCM-projektet som du sparade tidigare.
I verktygsfältet väljer du Spara.
Azure-portalen visar ett meddelande i aviseringar om att hubben har uppdaterats. Knappen Spara är inaktiverad.

Hubben är nu konfigurerad för att fungera med Firebase Cloud Messaging. Du har också de anslutningssträngar som krävs för att skicka meddelanden till en enhet och registrera en app för att ta emot meddelanden.

Anslut appen till meddelandehubben

Lägga till Google Play-tjänster i projektet

I Android Studio väljer du Verktyg på menyn och sedan SDK Manager.
Välj målversionen av Android SDK som används i projektet. Välj sedan Visa paketinformation.
Välj Google-API:er om det inte redan är installerat.
Växla till fliken SDK-verktyg . Om du inte redan har installerat Google Play Services väljer du Google Play Services enligt följande bild. Välj sedan Använd för att installera. Observera SDK-sökvägen för användning i ett senare steg.
Om du ser dialogrutan Bekräfta ändring väljer du OK. Komponentinstallationsprogrammet installerar de begärda komponenterna. Välj Slutför när komponenterna har installerats.
Välj OK för att stänga dialogrutan Inställningar för nya projekt .

Öppna filen AndroidManifest.xml och lägg sedan till följande tagg i programtaggen .

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

Lägga till Azure Notification Hubs-bibliotek

I filen Build.Gradle för appen lägger du till följande rader i avsnittet beroenden.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Lägg till följande lagringsplats efter avsnittet beroenden.

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

Lägga till Stöd för Google Firebase

I filen Build.Gradle för appen lägger du till följande rader i avsnittet beroenden om de inte redan finns.

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'

Lägg till följande plugin-program i slutet av filen om det inte redan finns där.
```
apply plugin: 'com.google.gms.google-services'
```
Välj Synkronisera nu i verktygsfältet.

Uppdatera filen AndroidManifest.xml

När du har fått din FCM-registreringstoken använder du den för att registrera dig med Azure Notification Hubs. Du stöder den här registreringen i bakgrunden med hjälp av ett IntentService med namnet RegistrationIntentService. Den här tjänsten uppdaterar även din FCM-registreringstoken. Du skapar också en klass med namnet FirebaseService som en underklass av FirebaseMessagingService och åsidosätter onMessageReceived metoden för att ta emot och hantera meddelanden.

Lägg till följande tjänstdefinition i AndroidManifest.xml-filen i taggen <application> .
```
<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>
```

Lägg till följande nödvändiga FCM-relaterade behörigheter under taggen </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" />

Lägg till kod

I projektvyn expanderar du app>src>main>java. Högerklicka på paketmappen under java, välj Ny och välj sedan Java-klass. Ange NotificationSettings som namn och välj sedan OK.

Se till att uppdatera dessa två platshållare i följande kod för NotificationSettings klassen:
- HubListenConnectionString: Anslutningssträngen DefaultListenAccessSignature för hubben. Du kan kopiera anslutningssträngen genom att klicka på Åtkomstprinciper i din hubb i Azure-portalen.
- HubName: Använd namnet på din hubb som visas på hubbsidan i Azure-portalen.
  
  NotificationSettings kod:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Viktigt!
  
  Ange namnet och DefaultListenSharedAccessSignature för din hubb innan du fortsätter vidare.

Lägg till ytterligare en ny klass i projektet med namnet RegistrationIntentService. Den här klassen implementerar IntentService gränssnittet. Den hanterar även uppdatering av FCM-token och registrering med meddelandehubben.

Använd följande kod för den här klassen.

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

MainActivity I klassen lägger du till följande import instruktioner ovanför klassdeklarationen.

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;

Lägg till följande medlemmar överst i klassen. Du använder de här fälten för att kontrollera tillgängligheten för Google Play-tjänster enligt Googles rekommendation.

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

MainActivity I klassen lägger du till följande metod för att kontrollera tillgängligheten för Google Play-tjänster.

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

MainActivity I klassen lägger du till följande kod som kontrollerar Google Play-tjänster innan IntentService anropas för att hämta din FCM-registreringstoken och registrera dig med din hubb.

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

OnCreate I -metoden för MainActivity klassen lägger du till följande kod för att starta registreringsprocessen när aktiviteten skapas:

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

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

Om du vill verifiera appens tillstånd och rapportstatus i din app lägger du till följande ytterligare metoder i MainActivity:

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

Metoden ToastNotify använder kontrollen "Hello World"TextView för att rapportera status och meddelanden beständigt i appen. I din res>layout>activity_main.xml-layout, lägg till följande ID för den specifika kontrollen.
```
android:id="@+id/text_hello"
```
Sedan lägger du till en underklass för mottagaren som du definierade i AndroidManifest.xml. Lägg till ytterligare en ny klass i projektet med namnet FirebaseService.

Lägg till följande importinstruktioner överst FirebaseService.javai :

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;

Lägg till följande kod för klassen, vilket gör den FirebaseService till en underklass av FirebaseMessagingService.

Den här koden åsidosätter den onMessageReceived metod och de rapporter som tas emot. den skickar även push-meddelandet till Android-meddelandehanteraren med hjälp sendNotification() av metoden . sendNotification() Anropa metoden när appen inte körs och ett meddelande tas emot.

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

I Android Studio går du till menyraden och väljer Skapa>återskapa projekt för att se till att det inte finns några fel i koden. Om du får ett felmeddelande om ic_launcher-ikonen, tar du bort följande rad från AndroidManifest.xml-filen:
```
android:icon="@mipmap/ic_launcher"
```
Se till att du har en virtuell enhet för att köra appen. Om du inte har en lägger du till en på följande sätt:
- Skapa virtuell enhet
Kör appen på den valda enheten och kontrollera att den har registrerats med hubben.

Anmärkning

Registreringen kan misslyckas under den första starten tills onTokenRefresh() metoden för instans-ID-tjänsten anropas. Uppdateringen bör initiera en lyckad registrering med meddelandehubben.

Testa skicka meddelande från meddelandehubben

Du kan skicka push-meddelanden från Azure-portalen genom att utföra följande steg:

I Azure-portalen går du till sidan Notification Hub för din hubb och väljer Testa skicka i avsnittet Felsökning .
För Plattformar väljer du Android.
Välj Skicka. Du ser inget meddelande på Android-enheten ännu eftersom du inte har kört mobilappen på den. När du har kört mobilappen väljer du knappen Skicka igen för att se meddelandet.
Se resultatet av åtgärden i listan längst ned.
Du ser meddelandet på enheten.

Push-meddelanden skickas normalt i en serverdelstjänst som Mobile Apps eller ASP.NET med hjälp av ett kompatibelt bibliotek. Om ett bibliotek inte är tillgängligt för serverdelen kan du också använda REST-API:et direkt för att skicka meddelanden.

Här är en lista över några andra handledningar som du kanske vill granska för att skickaa meddelanden:

Azure Mobile Apps: Ett exempel på hur du skickar meddelanden från en mobile apps-serverdel som är integrerad med Notification Hubs finns i Lägga till push-meddelanden i din iOS-app.
ASP.NET: Använd Notification Hubs för att skicka meddelanden till användare.
Azure Notification Hub Java SDK: Se Hur du använder Notification Hubs från Java för att skicka meddelanden från Java. Detta har testats i Eclipse för Android Development.
PHP: Hur man använder Notification Hubs från PHP.

Kör mobilappen på emulatorn

Innan du testar push-meddelanden i en emulator kontrollerar du att emulatoravbildningen stöder den Google API-nivå som du har valt för din app. Om din avbildning inte stöder interna Google-API:er kan du få SERVICE_NOT_AVAILABLE undantag.

Kontrollera också att du har lagt till ditt Google-konto i den emulator som körs under Inställningskonton>. Annars kan dina försök att registrera dig med FCM leda till undantaget AUTHENTICATION_FAILED.

Nästa steg

I den här självstudien använde du Firebase Cloud Messaging för att skicka meddelanden till alla Android-enheter som har registrerats med tjänsten. Om du vill lära dig hur du skickar notifieringar till specifika enheter går du vidare till följande guide:

Självstudie: Skicka meddelanden till specifika Android-enheter