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

Článek
05/05/2023

V tomto kurzu se dozvíte, jak používat Azure Notification Hubs a sadu Firebase Cloud Messaging (FCM) SDK verze 0.6 k odesílání nabízených 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).

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. Pokud účet nemáte, můžete si během několika minut vytvořit bezplatný zkušební účet. 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 novější for Firebase Cloud Messaging
Služby Google Play 9.0.2 nebo novější 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 Nový a pak vyberte Nový projekt.
Na stránce Zvolte projekt vyberte Prázdná aktivita 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 Add Firebase to your Android app (Přidat Firebase do 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 app vašeho projektu a pak vyberte Další.
V Android Studiu proveďte následující změny konfigurace projektu.
1. Do souboru build.gradle (<project>/build.gradle) na úrovni projektu přidejte do oddílu dependencies 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 dependencies následující příkazy.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Následující řádek přidejte na konec souboru build.gradle na úrovni aplikace za oddíl závislostí.
```
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 si nestáhli soubor google-services.json do složky app vašeho projektu Android Studia, můžete to udělat na této stránce.
Přepněte na kartu Cloud Messaging v horní části.
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 v nadpisu Zakázané rozhraní API pro zasílání zpráv v cloudu (starší verze). 🚫
2. Použijte nabízený odkaz na "Správa rozhraní API v Google Cloud Console".
3. V cloudové konzole Google aktivujte stisknutím tlačítka rozhraní API googlecloudmessaging.
4. Počkejte několik minut.
5. Zpět na kartu Cloud Messaging projektu firebase konzoly a aktualizujte stránku.
6. Podívejte se, že hlavička rozhraní API pro zasílání zpráv cloudu se změnila na "Rozhraní API pro zasílání zpráv cloudu (starší verze) ✅ povoleno" a zobrazuje klíč serveru.

Konfigurace centra

Přihlaste se k webu Azure Portal.
V nabídce vlevo vyberte Všechny služby a pak vyberte Notification Hubs v části Mobilní . Výběrem ikony star vedle názvu služby přidejte službu do části OBLÍBENÉ v nabídce vlevo. Jakmile přidáte Notification Hubs k oblíbeným položkám, vyberte ho v nabídce vlevo.
Na stránce Notification Hubs vyberte na panelu nástrojů Vytvořit .
Na kartě Základy na stránce Centrum oznámení proveďte následující kroky:
1. V části Předplatné 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 pole Podrobnosti 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í, takže zadejte název centra do části Podrobnosti centra oznámení. Nebo vyberte existující obor názvů z rozevíracího seznamu.
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á obsahuje zóny dostupnosti, je políčko ve výchozím nastavení zaškrtnuté. Zóny dostupnosti jsou placená funkce, takže se k vaší úrovni 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árovaná oblast obnovení, zobrazí se oblast převzetí služeb při selhání. Pokud vyberete Flexibilní oblast obnovení, pomocí rozevíracího seznamu vyberte ze seznamu oblastí obnovení.
7. Vyberte Vytvořit.
Vyberte Oznámení (ikona zvonku) a pak vyberte Přejít k prostředku. Můžete také aktualizovat seznam na stránce Notification Hubs a vybrat centrum.
Vyberte ze seznamu Zásady přístupu. Máte k dispozici dva připojovací řetězce. Budete je potřebovat později, abyste mohli zpracovávat nabízená oznámení.

Důležité

Nepoužívejte ve své aplikaci zásadu DefaultFullSharedAccessSignature. To se má používat jenom v back-endu.

Konfigurace nastavení služby Firebase Cloud Messaging pro centrum

V levém podokně v části Nastavení vyberteGoogle (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ězce, 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 v nabídce Nástroje 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 o 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 komponent nainstaluje požadované součásti. Po instalaci komponent vyberte Dokončit .
Kliknutím na 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 Služby Azure Notification Hubs

Do souboru Build.Gradle pro aplikaci přidejte následující řádky v části závislosti.
```
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

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

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

Po obdržení registračního tokenu FCM ho použijete k registraci ve službě Azure Notification Hubs. Tuto registraci na pozadí podporujete pomocí IntentService s názvem RegistrationIntentService. Tato služba také aktualizuje registrační token FCM. Vytvoříte také třídu s názvem 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í potřebná 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řidat kód

V zobrazení projektu rozbalte hlavníjavuapp>src>>. Klikněte pravým tlačítkem na složku balíčku v javě, vyberte Nový a pak vyberte Třída 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č. Tento připojovací řetězec můžete zkopírovat kliknutím na Zásady přístupu v centru v Azure Portal.
- HubName: Použijte název centra, který se zobrazí na stránce centra v 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 import následující příkazy nad deklaraci třídy.

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ý zkontroluje služby Google Play, než zavoláte IntentService , abyste získali registrační token FCM a zaregistrovali se ve svém centru:

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

OnCreate V metodě 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 stav sestav v aplikaci, přidejte do MainActivityaplikace tyto další metody:

@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. Dorozložení>res>activity_main.xml přidejte následující ID tohoto ovládacího prvku.
```
android:id="@+id/text_hello"
```
Dále přidáte podtřídu pro příjemce, kterou 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 pro třídu následující kód FirebaseService , který z ní vytvoří podtřídu FirebaseMessagingService.

Tento kód přepíše metodu onMessageReceived a hlásí přijatá oznámení. Odešle také nabízená oznámení správci oznámení androidu sendNotification() pomocí metody . Volejte metodu, sendNotification() když aplikace není spuštěná a obdrží 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 ze 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 selhat během počátečního spuštění, dokud onTokenRefresh() se nezavolá 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í z Azure Portal můžete odesílat pomocí následujících kroků:

V Azure Portal vyberte na stránce Centrum oznámení pro vaše centrum v části Řešení potížímožnost Testovací odeslání.
V položce Platformy vyberte Android.
Vyberte Odeslat. Na zařízení s Androidem se oznámení zatím nezobrazuje, protože jste na něm nespustili 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 pro váš back-end není dostupná knihovna, můžete také k odesílání zpráv s oznámeními použít přímo 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 svou aplikaci. Pokud vaše image nepodporuje nativní rozhraní Google API, může se zobrazit výjimka SERVICE_NOT_AVAILABLE .

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

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í jenom 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