Kurz: Odesílání nabízených oznámení zařízením s Androidem pomocí sady Firebase SDK verze 0.6

Článek
03/05/2024

V tomto kurzu se dozvíte, jak pomocí služby Azure Notification Hubs a sady FIREBASE Cloud Messaging (FCM) SDK verze 0.6 odesílat nabízená oznámení do aplikace pro Android. V tomto kurzu vytvoříte prázdnou aplikaci pro Android, která bude přijímat nabízená oznámení pomocí služby Firebase Cloud Messaging (FCM).

Důležité

Google přestane podporovat starší verzi HTTP FCM 20. června 2024. Další informace najdete v tématu Migrace služby Azure Notification Hubs a Google Firebase Cloud Messaging.

Dokončený kód pro tento kurz si můžete stáhnout z GitHubu.

V tomto kurzu provedete následující kroky:

Vytvoříte projekt v Android Studiu.
Vytvoříte projekt Firebase, který podporuje Firebase Cloud Messaging.
Vytvořte centrum.
Připojte aplikaci k centru.
Otestujete aplikaci.

Požadavky

K dokončení tohoto kurzu potřebujete mít aktivní účet Azure. Během několika minut si můžete vytvořit bezplatný zkušební účet, pokud ho ještě nemáte. Podrobnosti najdete v článku Bezplatná zkušební verze Azure.

Potřebujete také následující položky:

Nejnovější verze Android Studia
Android 2.3 nebo novější pro službu Firebase Cloud Messaging
Google Repository revision 27 or higher for Firebase Cloud Messaging
Služby Google Play 9.0.2 nebo vyšší pro službu Firebase Cloud Messaging

Dokončení tohoto kurzu je předpokladem pro všechny ostatní kurzy notification Hubs pro aplikace pro Android.

Vytvoření projektu v Android Studiu

Spusťte Android Studio.
Vyberte Soubor, přejděte na příkaz Nový a pak vyberte Nový projekt.
Na stránce Zvolit projekt vyberte Prázdnou aktivitu a pak vyberte Další.
Na stránce Konfigurace projektu proveďte následující kroky:
1. Zadejte název aplikace.
2. Zadejte umístění, do kterého chcete uložit soubory projektu.
3. Vyberte Dokončit.

Vytvoření projektu Firebase, který podporuje FCM

Přihlaste se ke konzole Firebase. Vytvořte nový projekt Firebase, pokud jej ještě nemáte.
Po vytvoření projektu vyberte Add Firebase to your Android app (Přidat Firebase do aplikace pro Android).
Na stránce Přidat Firebase na stránku aplikace pro Android proveďte následující kroky:
1. Jako název balíčku pro Android zkopírujte hodnotu applicationId v souboru build.gradle vaší aplikace. V tomto příkladu je com.fabrikam.fcmtutorial1appto .
2. Vyberte Zaregistrovat aplikaci.
Vyberte Stáhnout google-services.json, uložte soubor do složky aplikace projektu a pak vyberte Další.
V android Studiu proveďte následující změny konfigurace.
1. Do souboru build.gradle na úrovni projektu (<project>/build.gradle) přidejte do oddílu závislostí následující příkaz.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Do souboru build.gradle na úrovni aplikace (project/app-module>/build.gradle) přidejte do oddílu závislostí následující příkazy.<><
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Za oddíl závislostí přidejte následující řádek na konec souboru build.gradle na úrovni aplikace.
```
apply plugin: 'com.google.gms.google-services'
```
4. Na panelu nástrojů vyberte Synchronizovat .
Vyberte Další.
Vyberte Přeskočit tento krok.
V konzole Firebase vyberte kolečko pro váš projekt. Potom vyberte Project Settings (Nastavení projektu).
Pokud jste soubor google-services.json nestáhli do složky aplikace projektu Android Studio, můžete to udělat na této stránce.
V horní části přepněte na kartu Cloudové zasílání zpráv .
Zkopírujte a uložte klíč serveru pro pozdější použití. Tuto hodnotu použijete ke konfiguraci centra.
Pokud na kartě firebase Cloud Messaging nevidíte klíč serveru, postupujte podle těchto dalších kroků.
1. Klikněte na nabídku se třemi tečkami nadpisu "Rozhraní API pro zasílání zpráv cloudu (starší verze) 🚫 zakázáno".
2. Postupujte podle nabízeného odkazu na "Spravovat rozhraní API v Google Cloud Console".
3. V konzole Google Cloud Console stisknutím tlačítka povolte rozhraní API googlecloudmessaging.
4. Počkejte několik minut.
5. Vraťte se na kartu Cloudové zasílání zpráv konzoly firebase a aktualizujte stránku.
6. Podívejte se, že hlavička rozhraní API pro zasílání zpráv cloudu se změnila na Povoleno rozhraní API pro zasílání zpráv cloudu (starší verze) ✅ a teď zobrazuje klíč serveru.

Konfigurace centra

Přihlaste se k portálu Azure.
V nabídce vlevo vyberte Všechny služby .
Do textového pole Filtrovat služby zadejte Notification Hubs. Výběrem ikony hvězdičky vedle názvu služby přidejte službu do oddílu OBLÍBENÉ V levé nabídce. Vyberte Notification Hubs.
Na stránce Notification Hubs vyberte vytvořit na panelu nástrojů.
Na kartě Základy na stránce Centra oznámení proveďte následující kroky:
1. V předplatném vyberte název předplatného Azure, které chcete použít, a pak vyberte existující skupinu prostředků nebo vytvořte novou.
2. Do podrobností oboru názvů zadejte jedinečný název nového oboru názvů.
3. Obor názvů obsahuje jedno nebo více center oznámení, proto do podrobností centra oznámení zadejte název centra.
4. V rozevíracím seznamu Umístění vyberte hodnotu. Tato hodnota určuje umístění, ve kterém chcete centrum vytvořit.
5. Zkontrolujte možnost Zóny dostupnosti. Pokud jste vybrali oblast, která má zóny dostupnosti, je ve výchozím nastavení zaškrtnuté políčko. Zóny dostupnosti je placená funkce, takže do vaší úrovně se přidá další poplatek.
6. Zvolte možnost zotavení po havárii: Žádná, Spárovaná oblast obnovení nebo Flexibilní oblast obnovení. Pokud zvolíte spárovanou oblast obnovení, zobrazí se oblast převzetí služeb při selhání. Pokud vyberete flexibilní oblast obnovení, vyberte si z rozevíracího seznamu oblastí obnovení.
7. Vyberte Vytvořit.
Po dokončení nasazení vyberte Přejít k prostředku.

Konfigurace nastavení služby Firebase Cloud Messaging pro centrum

V levém podokně v části Nastavení vyberte Google (GCM/FCM).
Zadejte klíč serveru pro projekt FCM, který jste si uložili dříve.
Na panelu nástrojů vyberte Uložit.
Azure Portal zobrazí zprávu v upozorněních, že centrum bylo úspěšně aktualizováno. Tlačítko Uložit je zakázané.

Vaše centrum je teď nakonfigurované tak, aby fungovalo se službou Firebase Cloud Messaging. Máte také připojovací řetězec, které jsou nezbytné k odesílání oznámení do zařízení a registraci aplikace pro příjem oznámení.

Připojte aplikaci k centru oznámení

Přidejte do projektu služby Google Play

V Android Studiu vyberte Nástroje v nabídce a pak vyberte Správce sady SDK.
Vyberte cílovou verzi sady Android SDK, která se používá ve vašem projektu. Pak vyberte Zobrazit podrobnosti balíčku.
Pokud ještě není nainstalovaná, vyberte rozhraní API Google.
Přepněte na kartu Nástroje sady SDK. Pokud jste ještě nenainstalovali služby Google Play, vyberte služby Google Play, jak je znázorněno na následujícím obrázku. Pak vyberte Použít k instalaci. Poznamenejte si cestu k sadě SDK, abyste ji mohli použít později.
Pokud se zobrazí dialogové okno Potvrdit změnu , vyberte OK. Instalační program součásti nainstaluje požadované součásti. Po instalaci komponent vyberte Dokončit .
Kliknutím na tlačítko OK zavřete dialogové okno Nastavení pro nové projekty .

Otevřete soubor AndroidManifest.xml a přidejte do značky aplikace následující značku.

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

Přidání knihoven Azure Notification Hubs

V souboru Build.Gradle pro aplikaci přidejte do části závislosti následující řádky.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Přidejte následující úložiště za část obsahující závislosti.

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

Přidání podpory Google Firebase

Pokud ještě neexistují, přidejte do souboru Build.Gradle pro aplikaci následující řádky v části závislosti.

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'

Pokud tam ještě není, přidejte na konec souboru následující modul plug-in.
```
apply plugin: 'com.google.gms.google-services'
```
Na panelu nástrojů vyberte Synchronizovat.

Aktualizace souboru AndroidManifest.xml

Jakmile obdržíte registrační token FCM, použijete ho k registraci ve službě Azure Notification Hubs. Tuto registraci na pozadí podporujete pomocí pojmenovaného IntentService RegistrationIntentService. Tato služba také aktualizuje registrační token FCM. Vytvoříte také třídu pojmenovanou FirebaseService jako podtřídu FirebaseMessagingService a přepíšete metodu onMessageReceived pro příjem a zpracování oznámení.

Přidejte následující definice služby do souboru AndroidManifest.xml uvnitř značky <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>
```

Pod značku přidejte následující nezbytná oprávnění </application> související s FCM.

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

Přidání kódu

V zobrazení projektu rozbalte app>src>main>java. Klikněte pravým tlačítkem na složku balíčku v javě, vyberte Nový a pak vyberte Třídu Java. Jako název zadejte NotificationSettings a pak vyberte OK.

Nezapomeňte aktualizovat tyto dva zástupné symboly v následujícím kódu pro NotificationSettings třídu:
- HubListenConnectionString: připojovací řetězec DefaultListenAccessSignature pro rozbočovač. Tuto připojovací řetězec můžete zkopírovat kliknutím na Zásady přístupu v centru na webu Azure Portal.
- HubName: Použijte název centra, který se zobrazí na stránce centra na webu Azure Portal.
  
  Kód NotificationSettings:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Důležité
  
  Než budete pokračovat, zadejte název a defaultListenSharedAccessSignature vašeho centra.

Přidejte další novou třídu do projektu s názvem RegistrationIntentService. Tato třída implementuje IntentService rozhraní. Zpracovává také aktualizaci tokenu FCM a registraci v centru oznámení.

Pro tuto třídu použijte následující kód.

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 Do třídy přidejte nad deklaraci třídy následující import příkazy.

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;

Do horní části třídy přidejte následující členy. Tato pole slouží ke kontrole dostupnosti Služeb Google Play, kterou doporučuje 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 Do třídy přidejte následující metodu pro kontrolu dostupnosti služeb Google Play.

/**
* 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 Do třídy přidejte následující kód, který před voláním registračního IntentService tokenu FCM zkontroluje služby Google Play a zaregistruje se ve vašem centru:

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

OnCreate Do metody MainActivity třídy přidejte následující kód, který spustí proces registrace při vytvoření aktivity:

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

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

Pokud chcete ověřit stav aplikace a nahlásit stav aplikace, přidejte do aplikace tyto další metody 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);
        }
    });
}

Metoda ToastNotify používá ovládací prvek "Hello World" TextView k trvalému hlášení stavu a oznámení v aplikaci. Do rozložení>res>activity_main.xml rozložení přidejte pro tento ovládací prvek následující ID.
```
android:id="@+id/text_hello"
```
Dále přidáte podtřídu příjemce, který jste definovali v AndroidManifest.xml. Přidejte další novou třídu do projektu s názvem FirebaseService.

Nad FirebaseService.java přidejte následující příkazy pro import:

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;

Přidejte následující kód pro FirebaseService třídu, čímž se jedná o podtřídu FirebaseMessagingService.

Tento kód přepíše metodu onMessageReceived a hlásí přijatá oznámení. také odešle nabízené oznámení správci oznámení androidu pomocí sendNotification() metody. Zavolejte metodu sendNotification() , když aplikace není spuštěná a přijme se oznámení.

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

V Android Studiu na řádku nabídek vyberte Sestavit znovu sestavit>projekt , abyste měli jistotu, že v kódu nejsou žádné chyby. Pokud se zobrazí chyba týkající se ic_launcher ikony, odeberte z souboru AndroidManifest.xml následující příkaz:
```
    android:icon="@mipmap/ic_launcher"
```
Ujistěte se, že máte virtuální zařízení pro spuštění aplikace. Pokud ho nemáte, přidejte ho následujícím způsobem:
Spusťte aplikaci na vybraném zařízení a ověřte, že se úspěšně zaregistruje v centru.

Poznámka:

Registrace může při počátečním spuštění selhat, dokud onTokenRefresh() se nevolá metoda služby ID instance. Obnovení by mělo zahájit úspěšnou registraci v centru oznámení.

Odeslání zkušebního oznámení z centra oznámení

Nabízená oznámení můžete odesílat z webu Azure Portal pomocí následujících kroků:

Na webu Azure Portal vyberte na stránce Centra oznámení pro vaše centrum možnost Testovací odeslání v části Řešení potíží .
V položce Platformy vyberte Android.
Vyberte Odeslat. Na zařízení s Androidem se ještě nezobrazí oznámení, protože jste na něm nespustí mobilní aplikaci. Po spuštění mobilní aplikace znovu vyberte tlačítko Odeslat , aby se zobrazila zpráva s oznámením.
Výsledek operace si můžete prohlédnout v seznamu dole v okně.
Na vašem zařízení se zobrazí zpráva s oznámením.

Nabízená oznámení se většinou posílají ve službě back-end, jako je služba Mobile Apps, nebo v technologii ASP.NET pomocí kompatibilní knihovny. Pokud není pro váš back-end k dispozici knihovna, můžete k odesílání zpráv s oznámeními použít také rozhraní REST API.

Tady je seznam některých dalších kurzů, které můžete chtít zkontrolovat pro odesílání oznámení:

Azure Mobile Apps: Příklad odesílání oznámení z back-endu Mobile Apps integrovaného se službou Notification Hubs najdete v tématu Přidání nabízených oznámení do aplikace pro iOS.
ASP.NET: Nabízení oznámení uživatelům pomocí služby Notification Hubs.
Sada Azure Notification Hub Java SDK: Informace o zasílání oznámení z Javy najdete v článku Jak používat Notification Hubs z Javy. Tato metoda prošla pro potřeby vývoje pro Android testováním v Eclipse.
PHP: Jak používat Notification Hubs z PHP.

Spuštění mobilní aplikace v emulátoru

Než otestujete nabízená oznámení v emulátoru, ujistěte se, že image emulátoru podporuje úroveň rozhraní GOOGLE API, kterou jste zvolili pro vaši aplikaci. Pokud image nepodporuje nativní rozhraní Google API, může se zobrazit výjimka SERVICE_NOT_AVAILABLE .

Ujistěte se také, že jste svůj účet Google přidali do spuštěné emulátoru v části Účty nastavení>. Jinak by vaše pokusy o registraci v FCM mohly vést k AUTHENTICATION_FAILED výjimce.

Další kroky

V tomto kurzu jste pomocí služby Firebase Cloud Messaging vysílali oznámení na všechna zařízení s Androidem zaregistrovaná ve službě. Pokud se chcete naučit posílat nabízená oznámení určitým zařízením, pokračujte následujícím kurzem:

Kurz: Nabízená oznámení konkrétním zařízením s Androidem

Sdílet prostřednictvím