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

Článek
04/21/2022
12 min ke čtení

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 GitHub.

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řipojení aplikaci do centra.
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 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 centra oznámení 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ý Project.
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ší.
Proveďte následující změny konfigurace projektu v Android Studiu.
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. Na konec souboru build.gradle na úrovni aplikace přidejte následující řádek 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 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 Cloud Messaging .
Zkopírujte a uložte klíč serveru pro pozdější použití. Tuto hodnotu použijete ke konfiguraci centra.

Konfigurace centra

Přihlaste se k webu Azure Portal.
V nabídce vlevo vyberte Všechny služby a pak v části Mobilní služba vyberte Notification Hubs. Výběrem ikony hvězdičky vedle názvu služby přidáte službu do části OBLÍBENÉ V levé nabídce. Po přidání centra oznámení do oblíbených položek ji vyberte v levé nabídce.
Na stránce Notification Hubs vyberte Vytvořit na panelu nástrojů.
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 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 zadejte název centra v podrobnostech centra oznámení. Nebo v rozevíracím seznamu vyberte existující obor názvů.
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. Vyberte Vytvořit.
Vyberte Oznámení (ikona zvonku) a pak vyberte Přejít k prostředku. Seznam můžete také aktualizovat na stránce Notification Hubs a vybrat centrum.
Vyberte ze seznamu Zásady přístupu. Všimněte si, že jsou vám k dispozici dva připojovací řetězce. Později je budete potřebovat ke zpracování nabízených oznámení.

Důležité

Nepoužívejte ve své aplikaci zásady DefaultFullSharedAccessSignature. To je určené jenom pro použití v back-endu.

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ě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 Nástroje v nabídce a pak vyberte Správce sady SDK.
Vyberte cílovou verzi sady Android SDK, která se používá v projektu. Pak vyberte Zobrazit podrobnosti balíčku.
Vyberte rozhraní API Google, pokud ještě není nainstalovaná.
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 komponenty nainstaluje požadované součásti. Po instalaci komponent vyberte Dokončit .
Výběrem možnosti 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

Do souboru Build.Gradle pro aplikaci přidejte do části závislostí 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

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

implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'

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é IntentServiceRegistrationIntentService. 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í 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řidání kódu

V zobrazení Project rozbalte appsrcmainjava>>>. 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 tři zástupné symboly v následujícím kódu pro třídu NotificationSettings:
- HubListenConnectionString: připojovací řetězec DefaultListenAccessSignature pro rozbočovač. 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 následující import 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ý před voláním registračního tokenu IntentService FCM zkontroluje služby Google Play Services a zaregistruje se v 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 hlášení stavu a oznámení trvale v aplikaci. Do rozloženíactivity_main.xmlpřekryvné>>activity_main.xmlpřidejte následující ID tohoto ovládacího prvku.
```
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 FirebaseMessagingServicetřídy .

Tento kód přepíše metodu onMessageReceived a hlásí oznámení, která jsou přijata. odešle také nabízené oznámení správci oznámení pro Android pomocí sendNotification() metody. Zavolejte 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 BuildRebuild> Project, abyste měli jistotu, že v kódu nejsou žádné chyby. Pokud se zobrazí chyba ic_launcher ikony, odeberte z AndroidManifest.xml souboru 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 během počátečního spuštění selhat, dokud onTokenRefresh() se nevyvolá 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 Azure Portal provedením následujících kroků:

V 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 zatím nezobrazuje 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í knihovna pro váš back-end dostupná, můžete také použít rozhraní REST API přímo k odesílání zpráv s oznámením.

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 vaše image nepodporuje nativní rozhraní GOOGLE API, můžete získat výjimku SERVICE_NOT_AVAILABLE .

Ujistěte se také, že jste do spuštěné emulátoru v části Nastavení>Accounts přidali svůj účet Google. Jinak se vaše pokusy o registraci v FCM můžou stát výjimkou AUTHENTICATION_FAILED .

Další kroky

V tomto kurzu jste použili Firebase Cloud Messaging k vysílání 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