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

Artigo
03/11/2024

Este tutorial mostra como usar os Hubs de Notificação do Azure e o SDK do FCM (Firebase Cloud Messaging) versão 0.6 para enviar notificações por push para um aplicativo Android. Neste tutorial, você cria um aplicativo Android em branco que recebe notificações por push usando o FCM.

Importante

O Google deixará de dar suporte ao HTTP herdado da FCM em 20 de junho de 2024. Para saber mais, confira Hubs de Notificação do Azure e a migração para o Google Firebase Cloud Messaging.

O código completo deste tutorial pode ser baixado no GitHub.

Neste tutorial, você deve executar as seguintes etapas:

Criar um projeto do Android Studio.
Criar um projeto do Firebase que ofereça suporte ao Firebase Cloud Messaging.
Criar um hub.
Conectar seu aplicativo ao hub.
Testar o aplicativo.

Pré-requisitos

Para concluir este tutorial, você precisa ter uma conta ativa do Azure. Se não tiver uma conta, você poderá criar uma conta de avaliação gratuita em apenas alguns minutos. Para obter detalhes, consulte Avaliação gratuita do Azure.

Você também precisará dos seguintes itens:

A versão mais recente do Android Studio
Android 2.3 ou superior para Firebase Cloud Messaging
A revisão 27 ou superior do Repositório do Google para o Firebase Cloud Messaging
Google Play Services 9.0.2 ou superior para Firebase Cloud Messaging

A conclusão deste tutorial é um pré-requisito para prosseguir com todos os outros tutoriais sobre 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 Escolher o projeto, selecione Atividade vazia e, em seguida, selecione Avançar.
Na página Configurar o projeto, siga as seguintes etapas:
1. Insira um nome para o aplicativo.
2. Especifique um local para salvar os arquivos do projeto.
3. Selecione Concluir.

Crie um projeto do Firebase que ofereça suporte ao FCM

Faça logon no console do Firebase. Crie um novo projeto do Firebase se você ainda não tiver um.
Depois de criar seu projeto, selecione Adicionar Firebase ao seu aplicativo Android.
Siga estas etapas na página Adicionar Firebase ao seu aplicativo Android:
1. Para Nome do pacote Android, copie o valor de applicationId no arquivo build.gradle do aplicativo. Neste exemplo, é com.fabrikam.fcmtutorial1app.
2. Selecione Registrar aplicativo.
Selecione Baixar google-services.json, salve o arquivo na pasta app do projeto e, em seguida, selecione Avançar.
Faça as seguintes alterações na configuração do seu projeto no Android Studio.
1. No arquivo project-level build.gradle (<project>/build.gradle), adicione a seguinte instrução à seção de dependências.
```
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 de dependências.
```
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 de dependências.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selecione Sincronizar agora na barra de ferramentas.
Selecione Avançar.
Selecione Ignorar esta etapa.
No console do Firebase, selecione a engrenagem para seu projeto. Em seguida, selecione Configurações do Projeto.
Se você não tiver baixado o arquivo google-services.json para a pasta aplicativo do projeto do Android Studio, será possível fazer isso nesta página.
Mude para a guia Mensagens de Nuvem na parte superior.
Copie e salve a Chave do servidor para uso posterior. Use esse valor para configurar o hub.
Se você não vir uma Chave do servidor na guia Mensagens na Nuvem do Firebase, siga estas etapas adicionais.
1. Clique no menu de três pontos do título "API de Mensagens na Nuvem (Herdado) 🚫 Desabilitada"
2. Siga o link oferecido para "Gerenciar a API no Console do Google Cloud".
3. No console do Google Cloud, pressione o botão para habilitar a API googlecloudmessaging.
4. Aguarde alguns minutos.
5. Volte à guia Cloud Messaging do projeto do console do Firebase e atualize a página.
6. Veja que o cabeçalho da API de Mensagens na Nuvem foi alterado para "API de Mensagens na Nuvem (Herdada) ✅ Habilitada" e agora mostra uma Chave do Servidor.

Configurar um hub

Entre no portal do Azure.
Selecione Todos os serviços no menu esquerdo.
Digite Hubs de Notificação na caixa de texto Filtrar serviços. Selecione o ícone de estrela ao lado do nome do serviço para adicionar o serviço na seção FAVORITOS no menu à esquerda. Selecione Hubs de Notificação.
Na página Hubs de Notificações, selecione Criar na barra de ferramentas.
Na guia Informações Básicas da página Hub de Notificações, execute as seguintes etapas:
1. Em Assinatura, selecione o nome da assinatura do Azure que deseja usar e escolha um grupo de recursos existente ou crie um.
2. Insira um nome exclusivo para o novo namespace em Detalhes do Namespace.
3. Um namespace contém um ou mais hubs de notificações. Portanto, digite um nome para o hub em Detalhes do Hub de Notificações.
4. Selecione um valor da caixa de listagem suspensa Local. Esse valor especifica a localização na qual você deseja criar o hub.
5. Revise 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 um recurso pago, portanto, um valor adicional será acrescentado à sua camada de serviço.
6. Escolha uma opção de Recuperação de desastre: 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 entre uma lista de regiões de recuperação.
7. Selecione Criar.
Após a conclusão da implantação, selecione Ir para o recurso.

Definir as configurações do Firebase Cloud Messaging para o hub

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

O serviço agora está configurado para trabalhar com o Firebase Cloud Messaging. Você também tem as cadeias de caracteres de conexão que são necessárias para enviar notificações para um dispositivo e registrar um aplicativo para receber notificações.

Conectar seu aplicativo ao hub de notificação

Adicionar serviços do Google Play ao projeto

No Android Studio, selecione Ferramentas no menu e selecione Gerenciador do 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, caso ainda não estejam instaladas.
Alterne para a guia SDK Tools. Caso ainda não tenha instalado 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, a ser usado em uma etapa posterior.
Se a caixa de diálogo Confirmar Alteração for exibida, selecione OK. O Instalador de Componente instalará os componentes solicitados. Selecione Concluir depois que os componentes forem instalados.
Selecione OK para fechar a caixa de diálogo Configurações para Novos Projetos.

Abra o arquivo AndroidManifest.xml e adicione a seguinte marca ao aplicativo.

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

Adicionar bibliotecas de Hubs de Notificação do Azure

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

Adicione o seguinte repositório após a seção dependencies .

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

Adicionar suporte ao Google Firebase

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

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 plug-in a seguir ao final do arquivo, caso ele ainda não esteja 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 do FCM, use-o para se registrar nos Hubs de Notificação do Azure. Você oferecerá suporte a esse registro em segundo plano, usando um IntentService chamado RegistrationIntentService. Esse serviço também atualiza seu token de registro do FCM. Você também cria uma classe chamada FirebaseService como uma subclasse de FirebaseMessagingService e substitui o método onMessageReceived para receber e manipular notificações.

Adicione a seguinte definição de serviço ao arquivo Androidmanifest.xml, dentro da marcação <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 permissões necessárias relacionadas ao FCM a seguir abaixo da marca </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" />

Incluir código

Na Exibição de Projeto, expanda app>src>main>java. Clique com o botão direto do mouse na pasta do seu pacote, em java, selecione Novo e, em seguida, Classe Java. Insira NotificationSettings como nome e, em seguida, selecione OK.

Atualize esses dois espaços reservados no seguinte código para a classe NotificationSettings:
- HubListenConnectionString: a cadeia de conexão DefaultListenAccessSignature do hub. É possível copiar essa cadeia de conexão clicando em Políticas de Acesso no hub no Azure portal.
- HubName: Use o nome do hub de notificação que aparece na página do hub no Azure portal.
  
  NotificationSettings :
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Importante
  
  Insira o nome e a DefaultListenSharedAccessSignature de seu hub antes de prosseguir.

Adicione outra classe nova ao projeto denominada RegistrationIntentService. Essa classe implementa a interface IntentService. Ela também processa a atualização do token do FCM e o registro no hub de notificação.

Use o código a seguir para essa 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);
        }
    }
}

Na classe MainActivity, adicione as seguintes instruções import acima da declaração da 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 membros a seguir à parte superior da classe. Use esses campos para verificar a disponibilidade do Google Play Services, conforme recomendado pelo 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;

Na classe MainActivity, adicione o método a seguir 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;
}

Na classe MainActivity, adicione o seguinte código que verifica o Google Play Services antes de chamar o IntentService para obter seu token de registro do FCM e registrá-lo com o seu hub:

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

No método OnCreate da classe MainActivity, adicione o código a seguir para começar o processo de 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 do aplicativo e informar o status em seu aplicativo, inclua 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 método ToastNotify usa o controle "Olá, Mundo" TextView para informar de modo persistente o status e as notificações no aplicativo. No layout res>layout>activity_main.xml, adicione a ID a seguir a esse controle.
```
android:id="@+id/text_hello"
```
Em seguida, adicione a subclasse no receptor que você definiu no AndroidManifest.xml. Adicione outra classe nova ao projeto denominada FirebaseService.

Adicione as seguintes instruções de importação na parte superior de 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 código a seguir à classe FirebaseService, tornando-a uma subclasse de FirebaseMessagingService.

Esse código substitui o método onMessageReceived e relata as notificações recebidas. Ele também envia a notificação por push ao gerenciador de notificações do Android usando o método sendNotification(). Chame o método sendNotification() 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 Compilar>Recompilar Projeto para garantir que não haja erros no código. Se você receber um erro sobre o ícone ic_launcher, remova a instrução a seguir do arquivo AndroidManifest.xml:
```
    android:icon="@mipmap/ic_launcher"
```
Verifique se você tem um dispositivo virtual para executar o aplicativo. Se não tiver um, adicione da seguinte maneira:
Execute o aplicativo no dispositivo selecionado e verifique se ele é registrado com êxito no hub.

Observação

O registro poderá falhar na primeira inicialização até que o método onTokenRefresh() do serviço de ID da instância seja chamado. A atualização deve iniciar um registro bem-sucedido com o hub de notificação.

Teste enviar notificação pelo hub de notificação

Você pode enviar notificações por push pelo Azure portal seguindo estas etapas:

No portal do Azure, na página do Hub de Notificação de seu hub, selecione Envio de Teste na seção Solução de Problemas.
Em Plataformas, selecione Android.
Selecione Enviar. Você ainda não verá a 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.
Confira o resultado da operação na lista na parte inferior.
Você verá a mensagem de notificação no dispositivo.

As notificações por push normalmente são enviadas em um serviço de back-end como Aplicativos Móveis ou ASP.NET usando uma biblioteca compatível. Se uma biblioteca não estiver disponível para o 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 talvez você queira examinar para o envio de 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, veja Adicionar notificações por push ao seu aplicativo iOS.
ASP.NET: Usar Hubs de Notificação para enviar notificações por push aos usuários.
SDK Java do Hub de Notificação do Azure: consulte Como usar os Hubs de Notificação do Java para enviar notificações do Java. Isso foi testado no Eclipse para desenvolvimento no Android.
PHP: como usar Hubs de Notificação do PHP.

Executar o aplicativo móvel no emulador

Antes de testar notificações por push em um emulador, verifique se a imagem do emulador dá suporte ao nível de API do Google que você escolheu para o aplicativo. Se a imagem não der suporte às APIs nativas do Google, você poderá receber a exceção SERVICE_NOT_AVAILABLE.

Além disso, verifique se você adicionou a conta do Google ao emulador em execução em Configurações>Contas. Ou, suas tentativas de se registrar no FCM poderão resultar na exceção AUTHENTICATION_FAILED.

Próximas etapas

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

Tutorial: Enviar notificações por push para dispositivos Android específicos

Compartilhar via