Tutorial: Enviar notificações por push para dispositivos Android usando o Firebase SDK versão 0.6

Artigo
03/05/2024

Este tutorial mostra como usar os Hubs de Notificação do Azure e o SDK do Firebase Cloud Messaging (FCM) versão 0.6 para enviar notificações por push para um aplicativo Android. Neste tutorial, irá criar uma aplicação Android em branco que recebe notificações push através do Firebase Cloud Messaging (FCM).

Importante

O Google deixará de oferecer suporte a HTTP herdado do FCM em 20 de junho de 2024. Para obter mais informações, consulte Azure Notification Hubs e Migração do Google Firebase Cloud Messaging.

O código completo para este tutorial pode ser baixado do GitHub.

Neste tutorial, siga os seguintes passos:

Criar um projeto do Android Studio.
Criar um projeto do Firebase que suporte o Firebase Cloud Messaging.
Crie um hub.
Conecte seu aplicativo ao hub.
Testar a aplicação.

Pré-requisitos

Para concluir este tutorial, tem de ter uma conta ativa do Azure. Se não tiver uma conta, pode criar uma conta de avaliação gratuita em apenas alguns minutos. Para obter mais detalhes, veja Avaliação Gratuita do Azure.

Você também precisa dos seguintes itens:

A última versão do Android Studio
Android 2.3 ou superior para Firebase Cloud Messaging
Revisão 27 ou superior do Google Repository para Firebase Cloud Messaging
Google Play Services 9.0.2 ou superior para Firebase Cloud Messaging

Concluir este tutorial é um pré-requisito para fazer todos os outros tutoriais dos Hubs de Notificação para aplicativos Android.

Criar um projeto do Android Studio

Inicie o Android Studio.
Selecione Arquivo, aponte para Novo e selecione Novo Projeto.
Na página Escolha seu projeto, selecione Atividade vazia e, em seguida, selecione Avançar.
Na página Configurar seu projeto, execute as seguintes etapas:
1. Insira um nome para o aplicativo.
2. Especifique um local no qual salvar os arquivos de projeto.
3. Selecione Concluir.

Criar um projeto do Firebase que suporte o FCM

Inicie sessão na consola Firebase. Crie um novo projeto Firebase se ainda não tiver um.
Depois de criar o projeto, selecione Adicionar Firebase à aplicação Android.
Na página Adicionar o Firebase ao seu aplicativo Android, execute as seguintes etapas:
1. Para o nome do pacote Android, copie o valor do seu applicationId no arquivo build.gradle do aplicativo. Neste exemplo, é com.fabrikam.fcmtutorial1app.
2. Selecione Registrar aplicativo.
Selecione Download google-services.json, salve o arquivo na pasta do aplicativo do seu projeto e selecione Avançar.
Faça as seguintes alterações de configuração no seu projeto no Android Studio.
1. No arquivo build.gradle no nível do projeto (<project>/build.gradle), adicione a seguinte instrução à seção dependencies .
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. No arquivo build.gradle no nível do aplicativo (<project>/<app-module>/build.gradle), adicione as instruções a seguir à seção dependencies.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Adicione a seguinte linha ao final do arquivo build.gradle no nível do aplicativo após a seção dependencies.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selecione Sincronizar agora na barra de ferramentas.
Selecione Seguinte.
Selecione Ignorar esta etapa.
Na consola da Firebase, selecione o cog do seu projeto. Em seguida, selecione Definições do projeto.
Se você não baixou o arquivo google-services.json para a pasta do aplicativo do seu projeto do Android Studio, você pode fazê-lo nesta página.
Mude para o separador Cloud Messaging na parte superior.
Copie e salve a chave do servidor para uso posterior. Você usa esse valor para configurar seu hub.
Se você não vir uma chave Server na guia Firebase Cloud Messaging, siga estas etapas adicionais.
1. Clique no menu de três pontos do título "Cloud Messaging API (Legacy) 🚫 Disabled"
2. Siga o link oferecido para "Gerenciar API no Google Cloud Console".
3. No console do Google Cloud, pressione o botão para ativar a API do googlecloudmessaging.
4. Aguarde alguns minutos.
5. Volte para a guia Cloud Messaging do projeto do console do firebase e atualize a página.
6. Veja que o cabeçalho da API do Cloud Messaging foi alterado para "Cloud Messaging API (Legacy) ✅ Enabled" e agora mostra uma chave do servidor.

Configurar um hub

Inicie sessão no portal do Azure.
Selecione Todos os serviços no menu à esquerda.
Digite Hubs de Notificação na caixa de texto Serviços de filtro . Selecione o ícone de estrela ao lado do nome do serviço para adicionar o serviço à seção FAVORITOS no menu à esquerda. Selecione Hubs de Notificação.
Na página Hubs de Notificação, selecione Criar na barra de ferramentas.
Na guia Noções básicas na página Hub de Notificação, execute as seguintes etapas:
1. Em Subscrição, selecione o nome da subscrição do Azure que pretende utilizar e, em seguida, selecione um grupo de recursos existente ou crie um novo.
2. Insira um nome exclusivo para o novo namespace em Detalhes do namespace.
3. Um namespace contém um ou mais hubs de notificação, portanto, digite um nome para o hub em Detalhes do Hub de Notificação.
4. Selecione um valor na caixa de listagem suspensa Local . Esse valor especifica o local no qual você deseja criar o hub.
5. Reveja a opção Zonas de disponibilidade . Se você escolher uma região que tenha zonas de disponibilidade, a caixa de seleção será marcada por padrão. As Zonas de Disponibilidade são uma funcionalidade paga, pelo que é adicionada uma taxa adicional ao seu nível.
6. Escolha uma opção de recuperação de desastres: nenhuma, região de recuperação emparelhada ou região de recuperação flexível. Se você escolher Região de recuperação emparelhada, a região de failover será exibida. Se você selecionar Região de recuperação flexível, use a lista suspensa para escolher em uma lista de regiões de recuperação.
7. Selecione Criar.
Quando a implantação estiver concluída, selecione Ir para recurso.

Configurar as definições do Firebase Cloud Messaging para o hub

No painel esquerdo, em Configurações, selecione Google (GCM/FCM).
Insira a chave do servidor para o projeto FCM que você salvou anteriormente.
Na barra de ferramentas, selecione Salvar.
O portal do Azure exibe uma mensagem em alertas informando que o hub foi atualizado com êxito. O botão Salvar está desativado.

Seu hub agora está configurado para funcionar com o Firebase Cloud Messaging. Você também tem as cadeias de conexão necessárias para enviar notificações para um dispositivo e registrar um aplicativo para receber notificações.

Ligar a aplicação ao Notification Hub

Adicionar serviços do Google Play para o projeto

No Android Studio, selecione Ferramentas no menu e, em seguida, selecione Gerenciador SDK.
Selecione a versão de destino do SDK do Android que é usada em seu projeto. Em seguida, selecione Mostrar detalhes do pacote.
Selecione APIs do Google, se ainda não estiver instalada.
Alterne para a guia Ferramentas do SDK. Se você ainda não instalou o Google Play Services, selecione Google Play Services conforme mostrado na imagem a seguir. Em seguida, selecione Aplicar para instalar. Anote o caminho do SDK, para utilização num passo posterior.
Se vir a caixa de diálogo Confirmar alteração, selecione OK. O instalador de componentes instala os componentes solicitados. Selecione Concluir após a instalação dos componentes.
Selecione OK para fechar a caixa de diálogo Configurações para Novos Projetos .

Abra o ficheiro AndroidManifest.xml e, em seguida, adicione a seguinte etiqueta à etiqueta da aplicação .

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

Adicionar bibliotecas dos Hubs de Notificação do Azure

No arquivo Build.Gradle do aplicativo, adicione as seguintes linhas na seção dependências.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Adicione o repositório seguinte depois da secção de dependências.

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

Adicionar suporte do Google Firebase

No arquivo Build.Gradle do aplicativo, adicione as seguintes linhas na seção dependências , caso ainda não existam.

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'

Adicione o seguinte plug-in no final do arquivo, se ele ainda não estiver lá.
```
apply plugin: 'com.google.gms.google-services'
```
Selecione Sincronizar agora na barra de ferramentas.

Atualizar o arquivo AndroidManifest.xml

Depois de receber seu token de registro FCM, use-o para se registrar nos Hubs de Notificação do Azure. Você dá suporte a esse registro em segundo plano usando um IntentService nome RegistrationIntentService. Este serviço também atualiza o seu token de registo FCM. Você também cria uma classe nomeada FirebaseService como uma subclasse de FirebaseMessagingService e substitui o onMessageReceived método para receber e manipular notificações.

Adicionar a seguinte definição de serviço ao ficheiro AndroidManifest.xml, no interior da etiqueta <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>
```

Adicione as seguintes permissões necessárias relacionadas ao FCM abaixo da </application> tag .

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

Adicionar código

Na vista de projeto, expanda app>src>principal>java. Clique com o botão direito do mouse na pasta do pacote em java, selecione Novo e, em seguida, selecione Classe Java. Insira NotificationSettings para o nome e selecione OK.

Certifique-se de atualizar esses dois espaços reservados no seguinte código para a NotificationSettings classe:
- HubListenConnectionString: A cadeia de ligação DefaultListenAccessSignature do seu hub. Você pode copiar essa cadeia de conexão clicando em Políticas de Acesso em seu hub no portal do Azure.
- HubName: use o nome do seu hub que aparece na página do hub no portal do Azure.
  
  Código NotificationSettings:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Importante
  
  Digite o nome e o DefaultListenSharedAccessSignature do seu hub antes de prosseguir.

Adicione outra nova classe ao projeto com o nome RegistrationIntentService. Esta classe implementa a IntentService interface. Ele também lida com a atualização do token FCM e o registro no hub de notificação.

Utilize o seguinte código para esta classe.

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 Na classe, adicione as seguintes import instruções acima da declaração de classe.

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;

Adicione os seguintes membros na parte superior da classe. Utiliza estes campos para verificar a disponibilidade dos Serviços do Google Play, tal como recomendado pela 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 Na classe, adicione o seguinte método para verificar a disponibilidade do Google Play Services.

/**
* 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 Na classe, adicione o seguinte código que verifica o Google Play Services antes de ligar para obter seu IntentService token de registro FCM e se registrar no hub:

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

OnCreate No método da classe, adicione o seguinte código para iniciar o processo de MainActivity registro quando a atividade for criada:

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

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

Para verificar o estado da aplicação e o estado do relatório na sua aplicação, adicione estes métodos adicionais a 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);
        }
    });
}

O ToastNotify método utiliza o comando "Olá, mundo"TextView para comunicar o estado e as notificações de forma permanente na aplicação. No layout >activity_main.xml layout da resolução>, adicione a seguinte ID para esse controle.
```
android:id="@+id/text_hello"
```
Em seguida, você adiciona uma subclasse para o recetor que você definiu em AndroidManifest.xml. Adicione outra nova classe ao projeto com o nome FirebaseService.

Adicione as seguintes declarações de importação no topo do ficheiro 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;

Adicione o seguinte código para a FirebaseService classe, tornando-a uma subclasse de FirebaseMessagingService.

Esse código substitui o método e relata as onMessageReceived notificações recebidas. ele também envia a notificação por push para o gerenciador de notificações do Android usando o sendNotification() método. Chame o sendNotification() método quando o aplicativo não estiver em execução e uma notificação for recebida.

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

No Android Studio, na barra de menus, selecione Build>Rebuild Project para se certificar de que não há erros no seu código. Se você receber um erro sobre o ic_launcher ícone, remova a seguinte instrução do arquivo AndroidManifest.xml:
```
    android:icon="@mipmap/ic_launcher"
```
Certifique-se de ter um dispositivo virtual para executar o aplicativo. Se não tiver um, adicione um da seguinte forma:
Execute o aplicativo no dispositivo selecionado e verifique se ele se registra com êxito no hub.

Nota

O registro pode falhar durante a inicialização inicial até que o onTokenRefresh() método do serviço de ID da instância seja chamado. A atualização deve iniciar um registo com êxito no hub de notificação.

Notificação de envio de teste a partir do hub de notificação

Você pode enviar notificações por push do portal do Azure seguindo as seguintes etapas:

No portal do Azure, na página Hub de Notificação do seu hub, selecione Testar Envio na seção Solução de Problemas .
Em Plataformas, selecione Android.
Selecione Enviar. Você ainda não verá uma notificação no dispositivo Android porque não executou o aplicativo móvel nele. Depois de executar o aplicativo móvel, selecione o botão Enviar novamente para ver a mensagem de notificação.
Veja o resultado da operação na lista na parte inferior.
Você vê a mensagem de notificação no seu dispositivo.

Normalmente, as notificações push são enviadas num serviço de back-end como Mobile Apps ou ASP.NET com uma biblioteca compatível. Se uma biblioteca não estiver disponível para seu back-end, você também poderá usar a API REST diretamente para enviar mensagens de notificação.

Aqui está uma lista de alguns outros tutoriais que você pode querer rever para enviar notificações:

Aplicativos Móveis do Azure: para obter um exemplo de como enviar notificações de um back-end de Aplicativos Móveis integrado aos Hubs de Notificação, consulte Adicionar notificações por push ao seu aplicativo iOS.
ASP.NET: utilize os Hubs de Notificação para enviar notificações push a utilizadores.
SDK Java dos Hubs de Notificação do Azure: consulte Como utilizar os Hubs de Notificação de Java para enviar notificações de Java. Este processo foi testado em Eclipse para Programação Android.
PHP: Como utilizar os Hubs de Notificação de PHP.

Execute o aplicativo móvel no emulador

Antes de testar as notificações por push dentro de um emulador, verifique se a imagem do emulador é compatível com o nível de API do Google escolhido para seu aplicativo. Se sua imagem não for compatível com APIs nativas do Google, você poderá obter a SERVICE_NOT_AVAILABLE exceção.

Certifique-se também de que adicionou a sua Conta Google ao emulador em execução em Definições>. Caso contrário, suas tentativas de registro no FCM podem resultar na AUTHENTICATION_FAILED exceção.

Próximos passos

Neste tutorial, você usou o Firebase Cloud Messaging para transmitir notificações para todos os dispositivos Android registrados no serviço. Para saber como enviar notificações push para dispositivos específicos, avance para o tutorial seguinte:

Tutorial: Notificações push para dispositivos Android específicos