Oktatóanyag: Leküldéses értesítések küldése Android-eszközökre a Firebase SDK 0.6-os verziójával

Cikk
03/05/2024

Ez az oktatóanyag bemutatja, hogyan használhatja az Azure Notification Hubsot és a Firebase Cloud Messaging (FCM) SDK 0.6-os verzióját leküldéses értesítések androidos alkalmazásba való küldéséhez. Ebben az oktatóanyagban létrehoz egy üres Android-alkalmazást, amely leküldéses értesítéseket fogad a Firebase Cloud Messaging (FCM) használatával.

Fontos

A Google 2024. június 20-án nem támogatja az FCM örökölt HTTP-t. További információ: Azure Notification Hubs és Google Firebase Cloud Messaging migrálása.

Az oktatóanyag befejezett kódja letölthető a GitHubról.

Ebben az oktatóanyagban a következő lépéseket hajtja végre:

Android Studio-projekt létrehozása.
A Firebase Cloud Messaginget támogató Firebase-projekt létrehozása.
Hozzon létre egy központot.
Csatlakoztassa az alkalmazást a központhoz.
Az alkalmazás tesztelése.

Előfeltételek

Az oktatóanyag elvégzéséhez egy aktív Azure-fiókra lesz szüksége. Ha nincs fiókja, néhány perc alatt létrehozhat egy ingyenes próbafiókot. További információ: Ingyenes Azure-próbafiók létrehozása.

A következő elemekre is szüksége van:

Az Android Studio legújabb verziója
Android 2.3 vagy újabb a Firebase Cloud Messaginghez
A Firebase Cloud Messaging 27-re vagy újabb verziójára vonatkozó Google-adattár
Google Play Services 9.0.2 vagy újabb a Firebase Cloud Messaginghez

Az oktatóanyag elvégzése előfeltétele az összes többi Notification Hubs-oktatóanyag elvégzésének Android-alkalmazásokhoz.

Android Studio-projekt létrehozása

Indítsa el az Android Studiót.
Válassza a Fájl lehetőséget, mutasson az Új pontra, majd válassza az Új projekt lehetőséget.
A Projekt kiválasztása lapon válassza az Üres tevékenység, majd a Tovább gombot.
A projekt konfigurálása lapon hajtsa végre a következő lépéseket:
1. Adja meg az alkalmazás nevét.
2. Adja meg azt a helyet, ahová menteni szeretné a projektfájlokat.
3. Válassza a Befejezés lehetőséget.

Az FCM-et támogató Firebase-projekt létrehozása

Jelentkezzen be a Firebase konzoljába. Hozzon létre egy új Firebase-projektet, ha nem rendelkezik még ilyennel.
A projekt létrehozása után válassza az Add Firebase to your Android app (A Firebase hozzáadása az Android-alkalmazáshoz) lehetőséget.
Az Android-alkalmazáshoz a Firebase hozzáadása lapon hajtsa végre a következő lépéseket:
1. Android-csomagnév esetén másolja az applicationId értékét az alkalmazás build.gradle fájljában. Ebben a példában ez a következő com.fabrikam.fcmtutorial1app: .
2. Válassza az Alkalmazás regisztrálása lehetőséget.
Válassza a Letöltés google-services.json lehetőséget, mentse a fájlt a projekt alkalmazásmappájába, majd válassza a Tovább gombot.
Végezze el az alábbi konfigurációs módosításokat a projekten az Android Studióban.
1. A projektszintű build.gradle fájlban (<project>/build.gradle) adja hozzá a következő utasítást a függőségek szakaszhoz.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Az alkalmazásszintű build.gradle fájlban (<project>/<app-module>/build.gradle) adja hozzá a következő utasításokat a függőségek szakaszhoz.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Adja hozzá a következő sort az alkalmazásszintű build.gradle fájl végéhez a függőségek szakasz után.
```
apply plugin: 'com.google.gms.google-services'
```
4. Válassza a Szinkronizálás lehetőséget az eszköztáron.
Válassza a Tovább lehetőséget.
Válassza a Lépés kihagyása lehetőséget.
A Firebase konzolján kattintson a projektjéhez tartozó fogaskerékre. Ezután kattintson a Project Settings (Projektbeállítások) elemre.
Ha még nem töltötte le a google-services.json fájlt az Android Studio-projekt alkalmazásmappájába , ezt ezen a lapon teheti meg.
Váltson a felső Cloud Messaging lapra.
Másolja és mentse a kiszolgálókulcsot későbbi használatra. Ezt az értéket használja a központ konfigurálásához.
Ha nem látja a kiszolgálókulcsot a firebase Cloud Messaging lapon, kövesse az alábbi további lépéseket.
1. Kattintson a "Cloud Messaging API (Legacy) 🚫 Disabled" címsor három pontos menüjére
2. Kövesse az "API kezelése a Google Cloud Console-ban" hivatkozásra mutató hivatkozást.
3. A Google Cloud Consoleban nyomja le a gombot a googlecloudmessaging API engedélyezéséhez.
4. Várjon néhány percet.
5. Térjen vissza a firebase-konzol Cloud Messaging (Felhőüzenetek) projektjéhez, és frissítse a lapot.
6. Láthatja, hogy a Cloud Messaging API fejléce "Cloud Messaging API (Örökölt) ✅ engedélyezve" értékre módosult, és most egy kiszolgálókulcsot jelenít meg.

Központ konfigurálása

Jelentkezzen be az Azure Portalra.
Válassza az Összes szolgáltatás lehetőséget a bal oldali menüben.
Írja be a Notification Hubs kifejezést a Szűrőszolgáltatások szövegmezőbe. A szolgáltatás neve melletti csillag ikonnal felveheti a szolgáltatást a kedvencek szakaszba a bal oldali menüben. Válassza a Notification Hubs lehetőséget.
A Notification Hubs lapon válassza a Létrehozás lehetőséget az eszköztáron.
Az Értesítési központ lap Alapismeretek lapján hajtsa végre a következő lépéseket:
1. Az Előfizetésben válassza ki a használni kívánt Azure-előfizetés nevét, majd válasszon ki egy meglévő erőforráscsoportot, vagy hozzon létre egy újat.
2. Adja meg az új névtér egyedi nevét a Névtér részletei mezőben.
3. A névtér egy vagy több értesítési központot tartalmaz, ezért írja be a központ nevét a Notification Hub Részletei szakaszba.
4. Válasszon egy értéket a Hely legördülő listából. Ez az érték határozza meg azt a helyet, ahol létre szeretné hozni a központot.
5. Tekintse át a Rendelkezésre állási zónák lehetőséget. Ha olyan régiót választott, amely rendelkezésre állási zónákkal rendelkezik, a jelölőnégyzet alapértelmezés szerint be van jelölve. A rendelkezésre állási zónák fizetős funkciók, ezért további díjakat adnak hozzá a szinthez.
6. Válasszon vészhelyreállítási lehetőséget: Nincs, Párosított helyreállítási régió vagy Rugalmas helyreállítási régió. Ha a Párosított helyreállítási régiót választja, megjelenik a feladatátvételi régió. Ha a rugalmas helyreállítási régiót választja, a legördülő listából választhat a helyreállítási régiók listájából.
7. Válassza a Létrehozás lehetőséget.
Ha az üzembe helyezés befejeződött, válassza az Erőforrás megnyitása lehetőséget.

A központ Firebase Cloud Messaging-beállításainak konfigurálása

A bal oldali panel Beállítások csoportjában válassza a Google (GCM/FCM) lehetőséget.
Adja meg a korábban mentett FCM-projekt kiszolgálókulcsát .
Az eszköztáron válassza a Mentés lehetőséget.
Az Azure Portal riasztásokban jelenít meg egy üzenetet, amely szerint a központ sikeresen frissült. A Mentés gomb le van tiltva.

A központ mostantól úgy van konfigurálva, hogy működjön a Firebase Cloud Messaging szolgáltatással. Emellett rendelkezik azokkal a kapcsolati sztring is, amelyek szükségesek ahhoz, hogy értesítéseket küldjön egy eszközre, és regisztráljon egy alkalmazást az értesítések fogadásához.

Az alkalmazás csatlakoztatása az értesítési központhoz

Google Play-szolgáltatások felvétele a projektbe

Az Android Studióban válassza az Eszközök lehetőséget a menüben, majd válassza az SDK Manager lehetőséget.
Válassza ki a projektben használt Android SDK célverzióját. Ezután válassza a Csomag részleteinek megjelenítése lehetőséget.
Ha még nincs telepítve, válassza a Google API-kat.
Váltson az SDK-eszközök lapra. Ha még nem telepítette a Google Play Services szolgáltatást, válassza a Google Play Servicest az alábbi képen látható módon. Ezután válassza az Alkalmaz elemet a telepítéshez. Jegyezze fel az SDK elérési útját, mert szükség lesz rá egy későbbi lépésben.
Ha megjelenik a Módosítás megerősítése párbeszédpanel, válassza az OK gombot. A Komponenstelepítő telepíti a kért összetevőket. Válassza a Befejezés lehetőséget az összetevők telepítése után.
Az OK gombra kattintva zárja be az Új projektek beállításai párbeszédpanelt.

Nyissa meg a AndroidManifest.xml fájlt, majd adja hozzá az alábbi címkét az alkalmazáscímkéhez .

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

Azure Notification Hubs-kódtárak hozzáadása

Az alkalmazás Build.Gradle fájljában adja hozzá a következő sorokat a függőségek szakaszhoz.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

A dependencies (függőségek) szakasz után vegye fel az alábbi tárhelyet.

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

Google Firebase-támogatás hozzáadása

Az alkalmazás Build.Gradle fájljában adja hozzá a következő sorokat a függőségek szakaszhoz, ha még nem léteznek.

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'

Adja hozzá a következő beépülő modult a fájl végéhez, ha még nincs ott.
```
apply plugin: 'com.google.gms.google-services'
```
Válassza a Szinkronizálás most lehetőséget az eszköztáron.

A AndroidManifest.xml fájl frissítése

Miután megkapta az FCM regisztrációs jogkivonatát, azzal regisztrálhat az Azure Notification Hubsban. Ezt a regisztrációt egy névvel RegistrationIntentServicetámogatja IntentService a háttérben. Ez a szolgáltatás az FCM regisztrációs jogkivonatát is frissíti. Emellett létrehozhat egy alosztályként elnevezett FirebaseService osztályt, és felülbírálhatja az onMessageReceived értesítések fogadásának és kezelésének FirebaseMessagingService módját.

Adja hozzá az alábbi szolgáltatásdefiníciót az AndroidManifest.xml fájlhoz, az <application> címkén belül.
```
<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>
```

Adja hozzá a következő szükséges FCM-engedélyeket a </application> címke alatt.

<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" />

Kód hozzáadása

A Projekt nézetben bontsa ki a következőt: app>src>main>java. Kattintson a jobb gombbal a csomagmappára a Java alatt, válassza az Új, majd a Java-osztály lehetőséget. Adja meg a név NotificationSettings elemét, majd kattintson az OK gombra.

Mindenképpen frissítse ezt a két helyőrzőt az osztály alábbi kódjában NotificationSettings :
- HubListenConnectionString: A központ DefaultListenAccessSignature kapcsolati sztringje. Ezt a kapcsolati sztring az Azure Portalon a hub hozzáférési szabályzataira kattintva másolhatja.
- HubName: Használja a központ nevét, amely az Azure Portal hub lapján jelenik meg.
  
  NotificationSettings kód:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Fontos
  
  A továbblépés előtt adja meg a központ nevét és DefaultListenSharedAccessSignature értékét.

Adjon hozzá a projekthez egy másik új, RegistrationIntentService nevű osztályt. Ez az osztály implementálja az interfészt IntentService . Kezeli az FCM-jogkivonat frissítését és az értesítési központban való regisztrációt is.

Ehhez az osztályhoz az alábbi kódokat használja.

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

Az osztályban MainActivity adja hozzá az alábbi import utasításokat az osztálydeklaráció fölé.

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;

Adja hozzá a következő tagokat az osztály tetején. Ezeket a mezőket a Google Play-szolgáltatások rendelkezésre állásának ellenőrzésére használja a Google által javasolt módon.

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

Az osztályban MainActivity adja hozzá a következő módszert a Google Play Services elérhetőségének ellenőrzéséhez.

/**
* 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 Az osztályban adja hozzá a következő kódot, amely ellenőrzi a Google Play Servicest, mielőtt meghívja az IntentService FCM regisztrációs jogkivonat lekéréséhez és a központhoz való regisztrációhoz:

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

OnCreate Az osztály metódusában MainActivity adja hozzá a következő kódot a regisztrációs folyamat elindításához a tevékenység létrehozásakor:

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

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

Ha ellenőrizni szeretné az alkalmazás állapotát és a jelentés állapotát az alkalmazásban, adja hozzá az alábbi további módszereket a következőhöz 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);
        }
    });
}

A ToastNotify metódus a "„Helló világ!” alkalmazás" TextView vezérlőt használja az állapot és az értesítések állandó jelentésére az alkalmazásban. A res>elrendezésben>activity_main.xml elrendezésben adja hozzá a vezérlő következő azonosítóját.
```
android:id="@+id/text_hello"
```
Ezután hozzáad egy alosztályt a fogadóhoz, amelyet a AndroidManifest.xml definiált. Adjon hozzá a projekthez egy másik új, FirebaseService nevű osztályt.

Vegye fel a következő importálási utasításokat a FirebaseService.java felső részén:

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;

Adja hozzá a következő kódot az FirebaseService osztályhoz, így az a következő alosztálya FirebaseMessagingServicelesz.

Ez a kód felülbírálja a onMessageReceived kapott metódust és jelentéseket. a metódus használatával a leküldéses értesítést is elküldi az sendNotification() Android értesítéskezelőjének. Hívja meg a metódust sendNotification() , ha az alkalmazás nem fut, és értesítést kap.

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

Az Android Studióban a menüsávon válassza a Build Rebuild Project (Projekt újraépítése)>lehetőséget, és győződjön meg arról, hogy nincsenek hibák a kódban. Ha hibaüzenetet kap az ic_launcher ikonnal kapcsolatban, távolítsa el a következő utasítást a AndroidManifest.xml fájlból:
```
    android:icon="@mipmap/ic_launcher"
```
Győződjön meg arról, hogy rendelkezik egy virtuális eszközzel az alkalmazás futtatásához. Ha nem rendelkezik ilyenel, az alábbiak szerint vegyen fel egyet:
Futtassa az alkalmazást a kiválasztott eszközön, és ellenőrizze, hogy sikeresen regisztrál-e a központban.

Feljegyzés

Előfordulhat, hogy a regisztráció a kezdeti indítás során meghiúsul, amíg a onTokenRefresh() példányazonosító-szolgáltatás metódusát meg nem hívja. Az értesítési központban történő regisztráció a frissítés után sikeresen megtörténik.

Értesítések küldésének tesztelése az értesítési központból

Leküldéses értesítéseket küldhet az Azure Portalról az alábbi lépések végrehajtásával:

Az Azure Portal Értesítési központ lapján válassza a Küldés tesztelése lehetőséget a Hibaelhárítás szakaszban.
A Platformok beállításnál válassza az Android lehetőséget.
Válassza az Küldés lehetőséget. Az Android-eszközön még nem jelenik meg értesítés, mert még nem futtatta rajta a mobilalkalmazást. A mobilalkalmazás futtatása után kattintson ismét a Küldés gombra az értesítési üzenet megtekintéséhez.
A művelet eredményeit a lap alján található listában láthatja.
Megjelenik az értesítési üzenet az eszközön.

A leküldéses értesítések küldése általában olyan háttérszolgáltatásokon keresztül történik egy kompatibilis könyvtár használatával, mint a Mobile Apps vagy az ASP.NET. Ha egy kódtár nem érhető el a háttérrendszerhez, a REST API-t közvetlenül is használhatja értesítési üzenetek küldéséhez.

Íme néhány további oktatóanyag, amelyeket érdemes áttekinteni az értesítések küldéséhez:

Azure Mobile Apps: Ha szeretne például értesítéseket küldeni a Notification Hubsba integrált Mobile Apps háttérrendszerből, olvassa el a Leküldéses értesítések hozzáadása az iOS-alkalmazáshoz című témakört.
ASP.NET: A Notification Hubs használata a felhasználóknak szánt leküldéses értesítések küldéséhez.
Azure Notification Hub Java SDK: A How to use Notification Hubs from Java (A Notification Hubs használata Javával) ismerteti, hogyan küldhetők értesítések a Javával. Ez az Eclipse-ben lett tesztelve Android-fejlesztéshez.
PHP: How to use Notification Hubs from PHP (A Notification Hubs használata PHP-val).

A mobilalkalmazás futtatása emulátoron

Mielőtt teszteli a leküldéses értesítéseket egy emulátoron belül, győződjön meg arról, hogy az emulátor képe támogatja az alkalmazáshoz választott Google API-szintet. Ha a kép nem támogatja a natív Google API-kat, előfordulhat, hogy a SERVICE_NOT_AVAILABLE kivételt kapja.

Győződjön meg arról is, hogy hozzáadta Google-fiókját a futó emulátorhoz a Beállítások>fiókok területen. Ellenkező esetben az FCM-ben való regisztrálási kísérletek AUTHENTICATION_FAILED kivételt eredményezhetnek.

Következő lépések

Ebben az oktatóanyagban a Firebase Cloud Messaging használatával küldött értesítéseket a szolgáltatásban regisztrált összes Android-eszközre. Ha szeretné megtudni, hogy hogyan küldhet leküldéses értesítéseket adott eszközökre, lépjen tovább a következő oktatóanyagra:

Oktatóanyag: Értesítések leküldése adott Android-eszközökre

Megosztás a következőn keresztül: