Samouczek: wysyłanie powiadomień wypychanych do urządzeń z systemem Android przy użyciu zestawu Firebase SDK w wersji 0.6

Artykuł
03/05/2024

W tym samouczku pokazano, jak używać usługi Azure Notification Hubs i zestawu SDK Firebase Cloud Messaging (FCM) w wersji 0.6 do wysyłania powiadomień wypychanych do aplikacji systemu Android. W tym samouczku tworzysz pustą aplikację dla systemu Android służącą do odbierania powiadomień push przy użyciu usługi Firebase Cloud Messaging (FCM).

Ważne

Firma Google przestanie obsługiwać starsze protokoły HTTP FCM 20 czerwca 2024 r. Aby uzyskać więcej informacji, zobacz Migracja usługi Azure Notification Hubs i Google Firebase Cloud Messaging.

Ukończony kod tego samouczka można pobrać z usługi GitHub.

W tym samouczku wykonasz następujące kroki:

Tworzenie projektu programu Android Studio.
Tworzenie projektu Firebase obsługującego usługę Firebase Cloud Messaging.
Utwórz koncentrator.
Połącz aplikację z centrum.
Testowanie aplikacji.

Wymagania wstępne

Do wykonania kroków tego samouczka potrzebne jest aktywne konto platformy Azure. Jeśli go nie masz, możesz utworzyć bezpłatne konto próbne w zaledwie kilka minut. Aby uzyskać szczegółowe informacje, zobacz Bezpłatna wersja próbna platformy Azure.

Potrzebne są również następujące elementy:

Najnowsza wersja programu Android Studio
System Android 2.3 lub nowszy dla usługi Firebase Cloud Messaging
Repozytorium Google w wersji 27 lub nowszej dla usługi Firebase Cloud Messaging
Usługi Google Play w wersji 9.0.2 lub nowszej dla usługi Firebase Cloud Messaging

Ukończenie tego samouczka jest wymaganiem wstępnym do wykonywania wszystkich innych samouczków usługi Notification Hubs dla aplikacji systemu Android.

Tworzenie projektu programu Android Studio

Uruchom program Android Studio.
Wybierz pozycję Plik, wskaż pozycję Nowy, a następnie wybierz pozycję Nowy projekt.
Na stronie Wybieranie projektu wybierz pozycję Puste działanie, a następnie wybierz pozycję Dalej.
Na stronie Konfigurowanie projektu wykonaj następujące czynności:
1. Wprowadź nazwę aplikacji.
2. Określ lokalizację, w której mają być zapisywane pliki projektu.
3. Wybierz Zakończ.

Tworzenie projektu Firebase obsługującego usługę FCM

Zaloguj się do konsoli Firebase. Utwórz nowy projekt Firebase, jeśli jeszcze go nie masz.
Po utworzeniu projektu wybierz pozycję Dodaj Firebase do swojej aplikacji dla systemu Android.
Na stronie Dodawanie bazy danych Firebase do aplikacji systemu Android wykonaj następujące kroki:
1. W polu Nazwa pakietu systemu Android skopiuj wartość applicationId w pliku build.gradle aplikacji. W tym przykładzie jest to com.fabrikam.fcmtutorial1app.
2. Wybierz pozycję Zarejestruj aplikację.
Wybierz pozycję Pobierz google-services.json, zapisz plik w folderze aplikacji projektu, a następnie wybierz pozycję Dalej.
Wprowadź następujące zmiany konfiguracji w projekcie w programie Android Studio.
1. W pliku build.gradle na poziomie projektu (<project>/build.gradle) dodaj następującą instrukcję do sekcji zależności .
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. W pliku build.gradle na poziomie aplikacji (<project>/<app-module>/build.gradle) dodaj następujące instrukcje do sekcji zależności .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Dodaj następujący wiersz na końcu pliku build.gradle na poziomie aplikacji po sekcji zależności.
```
apply plugin: 'com.google.gms.google-services'
```
4. Wybierz pozycję Synchronizuj teraz na pasku narzędzi.
Wybierz Dalej.
Wybierz pozycję Pomiń ten krok.
W konsoli usługi Firebase wybierz koło zębate dla projektu. Następnie wybierz pozycję Ustawienia projektu.
Jeśli plik google-services.json nie został pobrany do folderu aplikacji projektu programu Android Studio, możesz to zrobić na tej stronie.
Przejdź do karty Cloud Messaging (Obsługa komunikatów w chmurze) u góry strony.
Skopiuj i zapisz klucz serwera do późniejszego użycia. Ta wartość służy do konfigurowania centrum.
Jeśli nie widzisz klucza serwera na karcie Firebase Cloud Messaging, wykonaj następujące dodatkowe kroki.
1. Kliknij menu z trzema kropkami nagłówka "Wyłączony interfejs API obsługi komunikatów w chmurze (starsza wersja) 🚫
2. Postępuj zgodnie z oferowanym linkiem do sekcji "Zarządzanie interfejsem API w konsoli Google Cloud Console".
3. W konsoli google cloud naciśnij przycisk , aby włączyć interfejs API googlecloudmessaging.
4. Zaczekaj kilka minut.
5. Wróć do karty Cloud Messaging w konsoli firebase i odśwież stronę.
6. Zobacz, że nagłówek interfejsu API usługi Cloud Messaging został zmieniony na "Włączony interfejs API obsługi komunikatów w chmurze (starsza wersja) ✅ i teraz jest wyświetlany klucz serwera.

Konfigurowanie koncentratora

Zaloguj się w witrynie Azure Portal.
Wybierz pozycję Wszystkie usługi w menu po lewej stronie.
Wpisz Notification Hubs w polu tekstowym Filtruj usługi . Wybierz ikonę gwiazdki obok nazwy usługi, aby dodać usługę do sekcji ULUBIONE w menu po lewej stronie. Wybierz pozycję Notification Hubs.
Na stronie Notification Hubs wybierz pozycję Utwórz na pasku narzędzi.
Na karcie Podstawowe na stronie Centrum powiadomień wykonaj następujące czynności:
1. W obszarze Subskrypcja wybierz nazwę subskrypcji platformy Azure, której chcesz użyć, a następnie wybierz istniejącą grupę zasobów lub utwórz nową.
2. Wprowadź unikatową nazwę nowej przestrzeni nazw w obszarze Szczegóły przestrzeni nazw.
3. Przestrzeń nazw zawiera co najmniej jedno centrum powiadomień, więc wpisz nazwę centrum w obszarze Szczegóły centrum powiadomień.
4. Wybierz wartość z listy rozwijanej Lokalizacja . Ta wartość określa lokalizację, w której chcesz utworzyć centrum.
5. Przejrzyj opcję Strefy dostępności. Jeśli wybrano region ze strefami dostępności, pole wyboru jest zaznaczone domyślnie. Strefy dostępności jest funkcją płatną, dlatego do warstwy jest dodawana dodatkowa opłata.
6. Wybierz opcję Odzyskiwania po awarii: Brak, Sparowany region odzyskiwania lub Elastyczny region odzyskiwania. Jeśli wybierzesz region odzyskiwania sparowanego, zostanie wyświetlony region trybu failover. Jeśli wybierzesz pozycję Elastyczny region odzyskiwania, użyj listy rozwijanej, aby wybrać z listy regionów odzyskiwania.
7. Wybierz pozycję Utwórz.
Po zakończeniu wdrażania wybierz pozycję Przejdź do zasobu.

Konfigurowanie ustawień usługi Firebase Cloud Messaging na potrzeby centrum

W okienku po lewej stronie w obszarze Ustawienia wybierz pozycję Google (GCM/FCM).
Wprowadź klucz serwera dla zapisanego wcześniej projektu usługi FCM.
Na pasku narzędzi wybierz pozycję Zapisz.
W witrynie Azure Portal zostanie wyświetlony komunikat w alertach o pomyślnym zaktualizowaniu centrum. Przycisk Save (Zapisz) będzie wyłączony.

Twoje centrum jest teraz skonfigurowane do pracy z usługą Firebase Cloud Messaging. Masz również parametry połączenia, które są niezbędne do wysyłania powiadomień do urządzenia i rejestrowania aplikacji w celu odbierania powiadomień.

Łączenie aplikacji z centrum powiadomień

Dodawanie usług Google Play do projektu

W programie Android Studio wybierz pozycję Narzędzia w menu, a następnie wybierz pozycję Menedżer zestawów SDK.
Wybierz docelową wersję zestawu Android SDK, która jest używana w projekcie. Następnie wybierz pozycję Pokaż szczegóły pakietu.
Wybierz pozycję Interfejsy API Google, jeśli nie zostały jeszcze zainstalowane.
Przejdź do karty Narzędzia zestawu SDK. Jeśli jeszcze nie zainstalowano usług Google Play, wybierz pozycję Usługi Google Play, jak pokazano na poniższej ilustracji. Następnie wybierz pozycję Zastosuj , aby zainstalować. Zanotuj ścieżkę zestawu SDK, która będzie potrzebna w kolejnym kroku.
Jeśli zobaczysz okno dialogowe Potwierdzanie zmiany, wybierz przycisk OK. Instalator składników zainstaluje żądane składniki. Wybierz przycisk Finish (Zakończ) po zainstalowaniu składników.
Wybierz przycisk OK, aby zamknąć okno dialogowe Settings for New Projects (Ustawienia nowego projektu).

Otwórz plik AndroidManifest.xml, a następnie dodaj następujący tag do tagu aplikacji .

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

Dodawanie bibliotek usługi Azure Notification Hubs

W pliku Build.Gradle dla aplikacji dodaj następujące wiersze w sekcji zależności.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Dodaj następujące repozytorium po sekcji dependencies.

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

Dodawanie obsługi usługi Google Firebase

W pliku Build.Gradle dla aplikacji dodaj następujące wiersze w sekcji zależności, jeśli jeszcze nie istnieją.

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'

Dodaj następującą wtyczkę na końcu pliku, jeśli jeszcze go nie ma.
```
apply plugin: 'com.google.gms.google-services'
```
Wybierz pozycję Sync Now (Synchronizuj teraz) na pasku narzędzi.

Aktualizowanie pliku AndroidManifest.xml

Po otrzymaniu tokenu rejestracji usługi FCM należy go użyć do zarejestrowania się w usłudze Azure Notification Hubs. Tę rejestrację można obsługiwać w tle przy użyciu IntentService nazwy RegistrationIntentService. Ta usługa odświeża również token rejestracji usługi FCM. Utworzysz również klasę o nazwie FirebaseService jako podklasę FirebaseMessagingService i zastąpisz onMessageReceived metodę w celu odbierania i obsługi powiadomień.

Dodaj następującą definicję usługi do pliku AndroidManifest.xml wewnątrz tagu <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>
```

Dodaj następujące niezbędne uprawnienia związane z usługą FCM poniżej tagu </application> .

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.GET_ACCOUNTS"/>
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />

Dodawanie kodu

W widoku projektu rozwiń węzeł app>src>main>java. Kliknij prawym przyciskiem myszy folder pakietu w obszarze java, wybierz pozycję Nowy, a następnie wybierz pozycję Klasa Języka Java. Wprowadź wartość NotificationSettings jako nazwę, a następnie wybierz przycisk OK.

Pamiętaj, aby zaktualizować te dwa symbole zastępcze w następującym kodzie dla NotificationSettings klasy:
- HubListenConnectionString: domyślne parametry połączenia DefaultListenAccessSignature dla centrum. Możesz skopiować te parametry połączenia, klikając pozycję Zasady dostępu w centrum w witrynie Azure Portal.
- HubName: użyj nazwy centrum wyświetlanej na stronie centrum w witrynie Azure Portal.
  
  NotificationSettings — kod:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Ważne
  
  Przed kontynuowaniem wprowadź nazwę i wartość DefaultListenSharedAccessSignature centrum.

Dodaj kolejną nową klasę o nazwie RegistrationIntentService do projektu. Ta klasa implementuje IntentService interfejs. Obsługuje również odświeżanie tokenu usługi FCM i rejestrowanie w centrum powiadomień.

Użyj następującego kodu dla tej klasy.

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 W klasie dodaj następujące import instrukcje powyżej deklaracji klasy.

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;

Dodaj następujące składowe u góry klasy. Pola służą do sprawdzania dostępności usług Google Play zgodnie z zaleceniami firmy 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 W klasie dodaj następującą metodę, aby sprawdzić dostępność usług 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 W klasie dodaj następujący kod, który sprawdza usługi Google Play przed wywołaniem metody , IntentService aby uzyskać token rejestracji fcM i zarejestrować się w centrum:

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

W metodzie OnCreate MainActivity klasy dodaj następujący kod, aby rozpocząć proces rejestracji po utworzeniu działania:

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

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

Aby sprawdzić stan aplikacji i stan raportu w aplikacji, dodaj następujące dodatkowe metody do :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 używa kontrolki "Hello World"TextView, aby trwale zgłaszać stan i powiadomienia w aplikacji. W układzie res>layout>activity_main.xml dodaj następujący identyfikator dla tej kontrolki.
```
android:id="@+id/text_hello"
```
Następnie dodasz podklasę dla odbiornika zdefiniowanego w AndroidManifest.xml. Dodaj kolejną nową klasę o nazwie FirebaseService do projektu.

Dodaj następujące instrukcje import u góry pliku FirebaseService.java:

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;
import android.util.Log;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import androidx.core.app.NotificationCompat;

Dodaj następujący kod dla FirebaseService klasy , co czyni go podklasą FirebaseMessagingService.

Ten kod zastępuje metodę onMessageReceived i zgłasza odebrane powiadomienia. wysyła również powiadomienie push do menedżera powiadomień systemu Android przy użyciu sendNotification() metody . Wywołaj metodę sendNotification() , gdy aplikacja nie jest uruchomiona i zostanie odebrane powiadomienie.

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

Na pasku menu programu Android Studio wybierz pozycję Kompiluj>ponownie projekt, aby upewnić się, że w kodzie nie ma żadnych błędów. Jeśli zostanie wyświetlony błąd dotyczący ic_launcher ikony, usuń następującą instrukcję z pliku AndroidManifest.xml:
```
    android:icon="@mipmap/ic_launcher"
```
Upewnij się, że masz urządzenie wirtualne do uruchamiania aplikacji. Jeśli go nie masz, dodaj go w następujący sposób:
Uruchom aplikację na wybranym urządzeniu i sprawdź, czy została pomyślnie zarejestrowana w centrum.

Uwaga

Rejestracja może zakończyć się niepowodzeniem podczas początkowego uruchamiania do momentu onTokenRefresh() wywołania metody usługi identyfikatora wystąpienia. Odświeżenie powinno zainicjować pomyślną rejestrację w centrum powiadomień.

Wysyłanie testowego powiadomienia z centrum powiadomień

Powiadomienia wypychane można wysyłać z witryny Azure Portal , wykonując następujące czynności:

W witrynie Azure Portal na stronie Centrum powiadomień dla centrum wybierz pozycję Wysyłanie testowe w sekcji Rozwiązywanie problemów .
W pozycji Platformy wybierz opcję Android.
Wybierz Wyślij. Nie zobaczysz jeszcze powiadomienia na urządzeniu z systemem Android, ponieważ nie uruchomiono na nim aplikacji mobilnej. Po uruchomieniu aplikacji mobilnej ponownie wybierz przycisk Wyślij , aby wyświetlić komunikat z powiadomieniem.
Zobacz wynik operacji na liście u dołu.
Na urządzeniu zostanie wyświetlony komunikat z powiadomieniem.

Powiadomienia wypychane są zwykle wysyłane za pośrednictwem usługi wewnętrznej bazy danych, takiej jak Mobile Apps czy ASP.NET, przy użyciu zgodnej biblioteki. Jeśli biblioteka nie jest dostępna dla zaplecza, możesz również użyć interfejsu API REST bezpośrednio do wysyłania komunikatów powiadomień.

Oto lista innych samouczków, które warto przejrzeć w celu wysyłania powiadomień:

Azure Mobile Apps: aby zapoznać się z przykładem wysyłania powiadomień z zaplecza usługi Mobile Apps zintegrowanego z usługą Notification Hubs, zobacz Dodawanie powiadomień wypychanych do aplikacji systemu iOS.
ASP.NET: Używanie usługi Notification Hubs w celu wysyłania powiadomień push do użytkowników.
Zestaw Java SDK centrum Azure Notification Hub: informacje na temat wysyłania powiadomień za pomocą języka Java można znaleźć w temacie How to use Notification Hubs from Java (Używanie usługi Notification Hubs z poziomu języka Java). To rozwiązanie przetestowano w programie Eclipse pod kątem tworzenia aplikacji dla systemu Android.
PHP: How to use Notification Hubs from PHP (Używanie usługi Notification Hubs z poziomu języka PHP).

Uruchamianie aplikacji mobilnej na emulatorze

Przed przetestowaniem powiadomień wypychanych wewnątrz emulatora upewnij się, że obraz emulatora obsługuje poziom interfejsu API Google wybranego dla aplikacji. Jeśli obraz nie obsługuje natywnych interfejsów API Google, może zostać wyświetlony wyjątek SERVICE_NOT_AVAILABLE .

Upewnij się również, że konto Google zostało dodane do uruchomionego emulatora w obszarze Konta ustawień>. W przeciwnym razie próby zarejestrowania się w usłudze FCM mogą spowodować wyjątek AUTHENTICATION_FAILED .

Następne kroki

W tym samouczku użyto usługi Firebase Cloud Messaging do wysyłania powiadomień do wszystkich urządzeń z systemem Android zarejestrowanych w usłudze. Aby dowiedzieć się, jak wysyłać powiadomienia push do konkretnych urządzeń, przejdź do następującego samouczka:

Samouczek: wysyłanie powiadomień wypychanych do określonych urządzeń z systemem Android

Udostępnij za pośrednictwem