Tutorial: Envío de notificaciones push a dispositivos Android mediante firebase SDK versión 0.6

Artículo
2025-05-01

En este tutorial se describe cómo usar Azure Notification Hubs y el SDK de Firebase Cloud Messaging (FCM) versión 0.6 para enviar notificaciones push a una aplicación Android. En este tutorial, creará una aplicación Android en blanco que recibe notificaciones push mediante Firebase Cloud Messaging (FCM).

Importante

Google dejará de admitir HTTP heredado de FCM el 20 de junio de 2024. Para más información, consulte Azure Notification Hubs y migración de Google Firebase Cloud Messaging.

El código completado de este tutorial se puede descargar desde GitHub.

En este tutorial, realizará los pasos siguientes:

Cree un proyecto de Android Studio.
Cree un proyecto de Firebase que admita Firebase Cloud Messaging.
Crear un centro.
Conecte la aplicación al centro.
Pruebe la aplicación.

Requisitos previos

Para completar este tutorial, debe tener una cuenta de Azure activa. Si no tiene una cuenta, puede crear una cuenta de evaluación gratuita en tan solo un par de minutos. Para más información, consulte Evaluación gratuita de Azure.

También necesita los siguientes elementos:

La versión más reciente de Android Studio
Android 2.3 o posterior para Firebase Cloud Messaging
Revisión 27 o posterior del repositorio de Google para Firebase Cloud Messaging
Google Play Services 9.0.2 o posterior para Firebase Cloud Messaging

Completar este tutorial es un requisito previo para realizar todos los demás tutoriales de Notification Hubs para aplicaciones Android.

Creación de un proyecto de Android Studio

Inicie Android Studio.
Seleccione Archivo, seleccione Nuevoy, a continuación, seleccione Nuevo proyecto.
En la página Elegir el proyecto, seleccione Actividad vacía y, a continuación, seleccione Siguiente.
En la página Configurar el proyecto, siga estos pasos:
1. Escriba un nombre para la aplicación.
2. Especifique una ubicación en la que guardar los archivos del proyecto.
3. Seleccione Finalizar.

Creación de un proyecto de Firebase que admita FCM

Inicie sesión en la Consola Firebase. Cree un nuevo proyecto de Firebase si aún no tiene uno.
Después de crear el proyecto, seleccione Agregar Firebase a la aplicación Android.
En la página Agregar Firebase a la aplicación Android, siga estos pasos:
1. Para Nombre del paquete Android, copie el valor de la applicationId en el archivo build.gradle de la aplicación. En este ejemplo, es com.fabrikam.fcmtutorial1app.
2. Seleccione Registrar aplicación.
Seleccione Descargar google-services.json, guarde el archivo en la carpeta de aplicación del proyecto y, a continuación, seleccione Siguiente.
Haga que los siguientes cambios de configuración en el proyecto en Android Studio.
1. En el archivo build.gradle de nivel de proyecto (<proyecto>/build.gradle), agregue la siguiente instrucción a la sección dependencias.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. En el archivo build.gradle de nivel de aplicación (<project>/<app-module>/build.gradle), agregue las siguientes instrucciones a la sección de dependencias.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Agregue la siguiente línea al final del archivo build.gradle de nivel de aplicación después de la sección dependencias.
```
apply plugin: 'com.google.gms.google-services'
```
4. Seleccione Sincronizar ahora en la barra de herramientas.
Seleccione Siguiente.
Seleccione Omitir este paso.
En la consola de Firebase, seleccione el engranaje del proyecto. A continuación, seleccione Configuración del proyecto.
Si no ha descargado el archivo google-services.json en la carpeta aplicación del proyecto de Android Studio, puede hacerlo en esta página.
Cambie a la pestaña Mensajería en la nube de la parte superior.
Copie y guarde la Clave del servidor para su uso posterior. Este valor se usa para configurar el centro.
Si no ve una clave de servidor en la pestaña Firebase Cloud Messaging, siga estos pasos adicionales.
1. Haga clic en el menú de tres puntos del encabezado "Cloud Messaging API (Legacy) 🚫 Disabled" (Cloud Messaging API (heredado) 🚫 Deshabilitado)
2. Siga el vínculo ofrecido a "Manage API in Google Cloud Console" (Administrar API en Google Cloud Console).
3. En la consola de Google Cloud, presione el botón para habilitar la API googlecloudmessaging.
4. Espere unos minutos.
5. Vuelva a la pestaña Cloud Messaging del proyecto de consola Firebase y actualice la página.
6. Vea que el encabezado de la API de mensajería en la nube ha cambiado a "API de mensajería en la nube (heredado) ✅ habilitado" y ahora muestra una clave de servidor.

Configuración de un centro

Inicie sesión en Azure Portal.
Seleccione Todos los servicios en el menú de la izquierda.
Escriba Notification Hubs en el cuadro de texto Servicios de filtro. Seleccione el icono de estrella situado junto al nombre del servicio para agregar el servicio a la sección FAVORITOS en el menú de la izquierda. Seleccione Notification Hubs.
En la página Notification Hubs, seleccione Crear en la barra de herramientas.
En la pestaña Datos básicos de la página Centro de notificaciones, siga estos pasos:
1. En Suscripción, seleccione el nombre de la suscripción de Azure que desea usar y, a continuación, seleccione un grupo de recursos existente o cree uno nuevo.
2. Escriba un nombre único para el nuevo espacio de nombres en Detalles del espacio de nombres.
3. Un espacio de nombres contiene uno o varios centros de notificaciones, por lo que escriba un nombre para el centro en Detalles del centro de notificaciones.
4. Seleccione un valor en el cuadro de lista desplegable Ubicación. Este valor especifica la ubicación en la que desea crear el centro.
5. Revise la opción Availability Zones. Si elige una región que tiene zonas de disponibilidad, la casilla está activada de manera predeterminada. Availability Zones es una característica de pago, por lo que se agrega una tarifa adicional al nivel.
6. Elija una opción de Recuperación ante desastres: Ninguna, Región de recuperación emparejada o Región de recuperación flexible. Si elige Región de recuperación emparejada, se muestra la región de conmutación por error. Si selecciona Región de recuperación flexible, use la lista desplegable para elegir entre una lista de regiones de recuperación.
7. Seleccione Crear.
Cuando se complete la implementación, seleccione Ir al recurso.

Configuración de Firebase Cloud Messaging para el centro

En el panel izquierdo, en Configuración, haga clic en Google (GCM/FCM).
Escriba la clave de servidor para el proyecto FCM que ha guardado anteriormente.
En la barra de herramientas, seleccione Guardar.
Azure Portal muestra un mensaje en las alertas de que el centro se ha actualizado correctamente. El botón Guardar está deshabilitado.

El centro ya está configurado para trabajar con Firebase Cloud Messaging. También tiene las cadenas de conexión necesarias para enviar notificaciones a un dispositivo y registrar una aplicación para recibir notificaciones.

Conexión de la aplicación al centro de notificaciones

Agregar de servicios de Google Play al proyecto

En Android Studio, seleccione Herramientas en el menú y, a continuación, seleccione Administrador de SDK.
Seleccione la versión de destino del SDK de Android que se usa en el proyecto. A continuación, seleccione Mostrar detalles del paquete.
Seleccione API de Google, si aún no está instalado.
Cambie a la pestaña SDK Tools. Si aún no ha instalado Google Play Services, seleccione Google Play Services como se muestra en la imagen siguiente. A continuación, seleccione Aplicar para instalar. Anote la ruta de acceso del SDK para usarla en un paso posterior.
Si ve el cuadro de diálogo Confirmar cambio , seleccione Aceptar. El Instalador de componentes instala los componentes solicitados. Seleccione Finalizar después de instalar los componentes.
Seleccione Aceptar para cerrar el cuadro de diálogo Configuración para nuevos proyectos.

Abra el archivo AndroidManifest.xml y agregue la etiqueta siguiente a la etiqueta aplicación.

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

Agregar de bibliotecas de Azure Notification Hubs

En el archivo Build.Gradle de la aplicación, agregue las líneas siguientes en la sección dependencias.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Agregue el repositorio siguiente después de la sección de dependencias.

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

Agregar de soporte con Google Firebase

En el archivo Build.Gradle de la aplicación, agregue las líneas siguientes en la sección dependencias si aún no existen.

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'

Agregue el siguiente complemento al final del archivo si aún no está ahí.
```
apply plugin: 'com.google.gms.google-services'
```
Seleccione Sincronizar ahora en la barra de herramientas.

Actualización del archivo AndroidManifest.xml

Después de recibir el token de registro de FCM, úselo para registrarse en Azure Notification Hubs. Este registro se admite en segundo plano mediante un IntentService denominado RegistrationIntentService. Este servicio también actualiza el token de registro de FCM. También se crea una clase denominada FirebaseService como una subclase de FirebaseMessagingService e invalida el método onMessageReceived para recibir y controlar las notificaciones.

Agregue la siguiente definición de servicio al archivo AndroidManifest.xml, dentro de la 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>
```

Agregue los siguientes permisos necesarios relacionados con FCM debajo de la etiqueta </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" />

Agregar código

En la Vista de proyecto, expanda app>src>main>java. Haga clic con el botón derecho en la carpeta del paquete en java, seleccione Nuevoy, a continuación, seleccione clase Java. Escriba NotificationSettings para el nombre y, a continuación, seleccione Aceptar.

Asegúrese de actualizar estos dos marcadores de posición en el código siguiente para la clase NotificationSettings :
- HubListenConnectionString: la cadena de conexión DefaultListenAccessSignature del centro. Para copiar esa cadena de conexión, haga clic en Directivas de acceso en el centro de Azure Portal.
- HubName: use el nombre del centro que aparece en la página del centro de Azure Portal.
  
  NotificationSettings código:
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Importante
  
  Escriba el nombre y el DefaultListenSharedAccessSignature del centro antes de continuar.

Agregue otra nueva clase al proyecto denominado RegistrationIntentService. Esta clase implementa la interfaz IntentService. También controla la actualización del token de FCM y el registro en el centro de notificaciones.

Use el código siguiente para esta clase.

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

En la clase MainActivity, agregue las siguientes instrucciones import encima de la declaración de clase.

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;

Agregue los siguientes miembros en la parte superior de la clase. Estos campos se usan para comprobar la disponibilidad de Google Play Services según lo recomendado por 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;

En la clase MainActivity, agregue el método siguiente para comprobar la disponibilidad de 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;
}

En la clase MainActivity, agregue el código siguiente que comprueba Google Play Services antes de llamar al IntentService para obtener el token de registro de FCM y registrarse en el centro:

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

En el OnCreatemétodo de la MainActivityclase, agregue el código siguiente para iniciar el proceso de registro cuando se crea la actividad:

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

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

Para comprobar el estado de la aplicación y el estado del informe en la aplicación, agregue estos métodos adicionales 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);
        }
    });
}

El método ToastNotify usa el control de "Hola mundo" TextViewpara notificar el estado y las notificaciones de forma persistente en la aplicación. En el diseño res>layout>activity_main.xml, agregue el siguiente identificador para ese control.
```
android:id="@+id/text_hello"
```
A continuación, agregue una subclase para el receptor que definió en AndroidManifest.xml. Agregue otra nueva clase al proyecto denominado FirebaseService.

Agregue las siguientes instrucciones de importación en la 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;

Agregue el código siguiente para la clase FirebaseService, por lo que es una subclase de FirebaseMessagingService.

Este código invalida el método onMessageReceived y notifica las notificaciones que se reciben. también envía la notificación de inserción al administrador de notificaciones de Android mediante el método sendNotification(). Llame al método sendNotification() cuando la aplicación no se esté ejecutando y se reciba una notificación.

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

En Android Studio, en la barra de menús, seleccione Compilar>Recompilar proyecto para asegurarse de que no haya errores en el código. Si recibe un error sobre el icono ic_launcher, quite la siguiente instrucción del archivo AndroidManifest.xml:
```
android:icon="@mipmap/ic_launcher"
```
Asegúrese de que tiene un dispositivo virtual para ejecutar la aplicación. Si no tiene una, agregue una de las siguientes:
Ejecute la aplicación en el dispositivo seleccionado y compruebe que se registra correctamente en el centro.

Nota

Es posible que se produzca un error en el registro durante el inicio inicial hasta que se llame al método onTokenRefresh() del servicio de identificador de instancia. La actualización debe iniciar un registro correcto con el centro de notificaciones.

Prueba de la notificación de envío desde el centro de notificaciones

Puede enviar notificaciones push desde Azure Portal siguiendo estos pasos:

En Azure Portal, en la página Centro de notificaciones del centro de notificaciones, seleccione Envío de pruebas en la sección Solución de problemas.
En Plataformas, seleccione Android.
Seleccione Enviar. Aún no verá una notificación en el dispositivo Android porque no ha ejecutado la aplicación móvil en él. Después de ejecutar la aplicación móvil, vuelva a seleccionar el botón Enviar para ver el mensaje de notificación.
Consulte el resultado de la operación en la lista en la parte inferior.
Verá el mensaje de notificación en el dispositivo.

Normalmente, las notificaciones push se envían en un servicio back-end como Mobile Apps o ASP.NET mediante una biblioteca compatible. Si una biblioteca no está disponible para el back-end, también puede usar la API REST directamente para enviar mensajes de notificación.

Esta es una lista de otros tutoriales que puede revisar para enviar notificaciones:

Azure Mobile Apps: para obtener un ejemplo de cómo enviar notificaciones desde un back-end de Mobile Apps integrado con Notification Hubs, consulte Agregar notificaciones push a la aplicación iOS.
ASP.NET: Usar Notification Hubs para enviar notificaciones push a los usuarios.
SDK de Java de Azure Notification Hub: consulte Uso de Notification Hubs desde Java para enviar notificaciones desde Java. Esto se ha probado en Eclipse para el desarrollo de Android.
PHP: Uso de Notification Hubs desde PHP.

Ejecución de la aplicación móvil en el emulador

Antes de probar las notificaciones push dentro de un emulador, asegúrese de que la imagen del emulador admite el nivel de API de Google que eligió para la aplicación. Si la imagen no admite las API de Google nativas, puede recibir la excepción SERVICE_NOT_AVAILABLE.

Asegúrese también de que ha agregado su cuenta de Google al emulador en ejecución en Configuración>Cuentas. De lo contrario, sus intentos de registrarse con FCM podrían generar la excepción AUTHENTICATION_FAILED.

Pasos siguientes

En este tutorial, ha usado Firebase Cloud Messaging para difundir notificaciones a todos los dispositivos Android registrados con el servicio. Para obtener información sobre cómo enviar notificaciones push a dispositivos específicos, pase al siguiente tutorial:

Tutorial : Envío de notificaciones push a dispositivos Android específicos

Compartir vía