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

Artikel
03/05/2024

Den här självstudien visar 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 via 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 har stöd för 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 på programmet.
2. Ange en plats där projektfilerna ska sparas.
3. Välj Slutför.

Skapa ett Firebase-projekt som har stöd för 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 com.fabrikam.fcmtutorial1appdet .
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 filen build.gradle på projektnivå (<project/build.gradle) lägger du till följande instruktion i avsnittet beroenden.>
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. I filen build.gradle på appnivå (project/app-module>/build.gradle) lägger du till följande instruktioner i avsnittet beroenden.<><
```
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 i 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 alternativ för haveriberedskap : Ingen, Länkad återställningsregion eller Flexibel återställningsregion. Om du väljer Länkad återställningsregion visas redundansregionen. 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äng 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 till 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. Anteckna SDK-sökvägen för användning i ett senare steg.
Om du ser dialogrutan Bekräfta ändringen väljer du OK. De begärda komponenterna installeras. 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ägg 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 AndroidManifest.xml-filen

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änstedefinition i filen AndroidManifest.xml inuti 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

Expandera app>src>main>java i projektvyn. Högerklicka på paketmappen under java, välj Ny och välj sedan Java-klass. Ange Meddelande Inställningar för namnet 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 din hubb. Du kan kopiera den anslutningssträng 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 och ge den 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 högst upp i klassen. Du använder de här fälten för att kontrollera tillgängligheten för Google Play-tjänster, enligt rekommendationer från 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;

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 söker efter Google Play-tjänster innan du IntentService anropar 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);
        }
    });
}

I metoden ToastNotify används kontrollen ”Hello World”TextView för att rapportera status och meddelanden på ett beständigt sätt i appen. Lägg till följande ID för den kontrollen i layouten res>layout>activity_main.xml.
```
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 och ge den namnet FirebaseService.

Lägg till följande importuttryck längst upp i FirebaseService.java:

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 instruktion från filen AndroidManifest.xml:
```
    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:
Kör appen på den valda enheten och kontrollera att den har registrerats med hubben.

Kommentar

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 hos meddelandehubben.

Testa att skicka ett 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 .
Välj Android under Plattformar.
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.
Visa åtgärdens resultat i listan längst ned.
Du ser meddelandet på enheten.

Push-meddelanden skickas vanligtvis via en serverdelstjänst, till exempel 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 självstudier som du kanske vill granska för att skicka 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 push-meddelanden till användare.
Azure Notification Hub Java SDK: Se Använda Notification Hubs från Java för information om att skicka meddelanden från Java. Det här har testats i Eclipse för Android-utveckling.
PHP: Använda Notification Hubs från PHP.

Kör mobilappen i 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 bild 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ällningar> Konton. Annars kan dina försök att registrera dig med FCM leda till AUTHENTICATION_FAILED undantag.

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. Information om hur du skickar meddelanden till specifika enheter finns i följande självstudie:

Självstudie: Skicka meddelanden till specifika Android-enheter