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

Artículo
03/10/2024

En este tutorial se muestra 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 de Android. En este tutorial, creará una aplicación de Android en blanco que recibirá 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 completo para este tutorial se puede descargar en GitHub.

En este tutorial, realizará los siguientes pasos:

Crear un nuevo proyecto en Android Studio
Crear un proyecto en Firebase que admita Firebase Cloud Messaging
Crear un centro.
Conectar la aplicación al centro.
Probar la aplicación.

Requisitos previos

Para completar este tutorial, deberá tener una cuenta de Azure activa. En caso de no tener cuenta, puede crear una de evaluación gratuita en tan solo unos minutos. Para obtener más información, consulte Evaluación gratuita de Azure.

También se necesitan los siguientes elementos:

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

La realización de este tutorial es un requisito previo para todos los tutoriales de Notification Hubs para aplicaciones Android.

Creación de un nuevo proyecto en Android Studio

Inicie Android Studio.
Seleccione sucesivamente File (Archivo), New (Nuevo) y New Project (Nuevo proyecto).
En la página Choose your project (Elija su proyecto), seleccione Empty Activity (Vaciar actividad) y seleccione Next (Siguiente).
En la página Configure your project (Configurar el proyecto), siga estos pasos:
1. Escriba un nombre para la aplicación.
2. Especifique una ubicación para guardar los archivos del proyecto.
3. Seleccione Finalizar.

Creación de un proyecto en Firebase que admita FCM

Inicie sesión en la consola Firebase. Si aún no tiene uno, cree un nuevo proyecto de Firebase.
Después de crear el proyecto, seleccione Add Firebase to your Android app (Añade Firebase a tu aplicación de Android).
En la página Add Firebase to your Android app (Agregar Firebase a la aplicación Android), haga lo siguiente:
1. En Nombre del paquete de Android, copie el valor de su 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 app 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 archivoproject-level build.gradle (<project>/build.gradle), agregue la siguiente instrucción a la sección de 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 app-level build.gradle después de la sección de dependencias.
```
apply plugin: 'com.google.gms.google-services'
```
4. Seleccione Sinc Now (Sincronizar ahora) en la barra de herramientas.
Seleccione Siguiente.
Seleccione Skip this step (Omitir este paso).
En la consola Firebase, seleccione el icono de la rueda dentada del proyecto. Luego, seleccione Project Settings (Configuración del proyecto).
Si aún no ha descargado el archivo google-services.json en la carpeta app del proyecto de Android Studio, puede hacerlo en esta página.
Cambie a la pestaña Cloud Messaging de la parte superior.
Copie y guarde la clave del servidor para su uso posterior. Usará este valor para configurar el concentrador.
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 Cloud Messaging API ha cambiado a "Cloud Messaging API (Legacy) ✅ Enabled" [Cloud Messaging API (heredado) ✅ habilitado] y ahora muestra una clave de servidor.

Configurar 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 Filtrar servicios. Seleccione el icono de estrella junto al nombre del servicio para agregarlo 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 Básico 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 debe escribir 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 quiere crear el centro.
5. Revise la opción Availability Zones. Si elige una región que tiene zonas de disponibilidad, la casilla estará activada de forma predeterminada. Availability Zones es una característica de pago, por lo que se agrega un honorario 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 mostrará la región de conmutación por error. Si selecciona Región de recuperación flexible, use la lista desplegable para elegir una lista de regiones de recuperación.
7. Seleccione Crear.
Cuando la implementación se complete, seleccione Ir al grupo de recursos.

Configuración de los valores 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 Save (Guardar) está deshabilitado.

El centro está ahora configurado para trabajar con Firebase Cloud Messaging. También tiene las cadenas de conexión que son 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

Incorporación de los servicios de Google Play al proyecto

En Android Studio, seleccione Tools (Herramientas) en el menú y, luego, seleccione SDK Manager.
Busque la versión de destino de Android SDK se usa en el proyecto. Luego, seleccione Show Package Details (Mostrar detalles del paquete).
Seleccione Google APIs (API de Google), si aún no está instalado este componente.
Cambie a la pestaña SDK Tools. Si no ha instalado todavía Google Play Services, seleccione Google Play Services, tal como se muestra en la imagen siguiente. A continuación, seleccione Apply (Aplicar) para realizar la instalación. Tome nota de la ruta de acceso del SDK para usarla en el paso siguiente.
Si ve el cuadro de diálogo Confirm Change (Confirmar cambio), seleccione OK (Aceptar). El instalador de componentes se instala los componentes solicitados. Seleccione Finish (Finalizar) una vez instalados los componentes.
Seleccione OK (Aceptar) para cerrar el cuadro de diálogo Settings for New Projects (Configuración para nuevos proyectos).

Abra el archivo AndroidManifest.xml y, luego, agregue la siguiente etiqueta a la etiqueta application.

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

Incorporación de las bibliotecas de Azure Notification Hubs

En el archivo Build.Gradle de la aplicación, agregue las siguientes líneas en la sección de 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"
    }
}

Adición de compatibilidad con Google Firebase

En el archivo Build.Gradle de la aplicación, agregue las siguientes líneas en la sección de 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 todavía no existe.
```
apply plugin: 'com.google.gms.google-services'
```
Seleccione Sinc Now (Sincronizar ahora) en la barra de herramientas.

Actualización del archivo AndroidManifest.xml

Una vez que haya recibido el token de registro de FCM, úselo para el registro en Azure Notification Hubs. Este registro se admite en segundo plano con un IntentService llamado RegistrationIntentService. Este servicio también actualiza el token de registro FCM. También puede crear una clase llamada FirebaseService como subclase de FirebaseMessagingService y reemplazar el método onMessageReceived para recibir y controlar notificaciones.

Agregue la siguiente definición de servicio al archivo AndroidManifest.xml, en 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 relacionados con FCM necesarios 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" />

Incorporación de 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 Nuevo y, 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 dicha cadena de conexión, haga clic en Directivas de acceso en su centro en Azure Portal.
- HubName: use el nombre del centro de notificaciones que aparece en la página del centro de Azure Portal.
  
  NotificationSettings :
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Importante
  
  Escriba el nombre y elemento DefaultListenSharedAccessSignature del centro antes de continuar.

Agregue otra clase nueva, llamada RegistrationIntentService, al proyecto. 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 siguiente código 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 la 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 al principio de la clase. Use estos campos para comprobar la disponibilidad de Google Play Services, tal como recomienda 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 siguiente código, que comprueba Google Play Services antes de llamar a IntentService para obtener el token de registro de FCM y realizar el registro 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 método OnCreate de la clase MainActivity, 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 e informar del estado 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 "Hello World"TextView para informar del estado y de 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 clase nueva, llamada FirebaseService, al proyecto.

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 siguiente código para la clase FirebaseService para convertirla en una subclase de FirebaseMessagingService.

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

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 la barra de menús de Android Studio, seleccione Build (Compilar) >Rebuild Project (Recompilar proyecto) para asegurarse de que no hay 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 uno, agregue uno como sigue:
Ejecute la aplicación en el dispositivo seleccionado y compruebe que se registra correctamente con el centro.

Nota

En el registro se puede producir un error la primera vez que se realiza el inicio hasta que se llama al método onTokenRefresh() del servicio de identificación de la instancia. La actualización debe iniciar un registro correcto en el Centro de notificaciones.

Envío de prueba de notificación desde el Centro de notificaciones

Para enviar notificaciones push desde Azure Portal realice las siguientes acciones:

En Azure Portal, en la página Notification Hubs del centro, seleccione Envío de prueba en la sección Solución de problemas.
En Plataformas, seleccione Android.
Seleccione Enviar. No verá aún ninguna 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.
Vea el resultado de la operación en la lista de la parte inferior.
Verá el mensaje de notificación en el dispositivo.

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

A continuación, presentamos una lista de algunos otros tutoriales que podría interesarle revisar para enviar notificaciones:

Azure Mobile Apps: Para ver un ejemplo de cómo enviar notificaciones desde un back-end de Mobile Apps con Notification Hubs, consulte Incorporación de notificaciones push a la aplicación iOS.
ASP.NET: Uso de Notification Hubs para enviar notificaciones push a los usuarios.
SDK de Java de Azure Notification Hubs: consulte Uso de Notification Hubs desde Java para enviar notificaciones desde Java. Esto se probó 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 en un emulador, asegúrese de que la imagen del emulador admita el nivel de API de Google que elija para la aplicación. Si la imagen no admite las API de Google nativas, puede recibir la excepción SERVICE_NOT_AVAILABLE.

Además, asegúrese de haber 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, se usa Firebase Cloud Messaging para enviar notificaciones de difusión a todos los dispositivos Android registrados en el servicio. Para aprender a enviar notificaciones push a dispositivos específicos, pase al siguiente tutorial:

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