Tutorial: Envío de notificaciones a dispositivos específicos mediante Azure Notification Hubs y Google Firebase Cloud Messaging

Artigo
05/08/2024

Información general

Importante

A partir de junio de 2024, las API heredadas de FCM ya no se admitirán y se retirarán. Para evitar cualquier interrupción en el servicio de notificaciones de inserción, debe migrar al protocolo FCM v1 lo antes posible.

En este tutorial se muestra cómo usar Azure Notification Hubs para difundir notificaciones de noticias de última hora en una aplicación Android. Cuando lo complete, podrá registrar las categorías de noticias de última hora en las que esté interesado y recibir solo notificaciones de inserción para esas categorías. Este escenario es un patrón común para muchas aplicaciones en las que las notificaciones tienen que enviarse a grupos de usuarios que han mostrado previamente interés en ellas, por ejemplo, lectores RSS, aplicaciones para aficionados a la música, etc.

Los escenarios de difusión se habilitan mediante la inclusión de una o más etiquetas cuando se crea un registro en el Centro de notificaciones. Cuando las notificaciones se envían a una etiqueta, todos los dispositivos registrados para la etiqueta recibirán la notificación. Puesto que las etiquetas son cadenas simples, no tendrán que aprovisionarse antes. Para información sobre las etiquetas, consulte Expresiones de etiqueta y enrutamiento de Notification Hubs.

En este tutorial realizará lo siguiente:

Agregar una selección de categorías a la aplicación móvil.
Registrarse para notificaciones con etiquetas.
Enviar notificaciones con etiquetas.
Prueba de la aplicación

Requisitos previos

Este tutorial se basa en la aplicación que creó en el Tutorial: Envío de notificaciones push a dispositivos Android con Azure Notification Hubs y Firebase Cloud Messaging. Antes de comenzar este tutorial, realice el Tutorial: Envío de notificaciones push a dispositivos Android con Azure Notification Hubs y Firebase Cloud Messaging.

Adición de una selección de categorías a la aplicación

El primer paso es agregar los elementos de la interfaz de usuario a la actividad principal existente que permiten al usuario seleccionar las categorías para registrar. Las categorías seleccionadas por un usuario se almacenan en el dispositivo. Cuando la aplicación se inicia, se crea un registro de dispositivos en el Centro de notificaciones con las categorías seleccionadas como etiquetas.

Abra el archivo res/layout/activity_main.xml file y reemplace el contenido por lo siguiente:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.breakingnews.MainActivity"
    android:orientation="vertical">

        <CheckBox
            android:id="@+id/worldBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_world" />
        <CheckBox
            android:id="@+id/politicsBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_politics" />
        <CheckBox
            android:id="@+id/businessBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_business" />
        <CheckBox
            android:id="@+id/technologyBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_technology" />
        <CheckBox
            android:id="@+id/scienceBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_science" />
        <CheckBox
            android:id="@+id/sportsBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_sports" />
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:onClick="subscribe"
            android:text="@string/button_subscribe" />
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"
            android:id="@+id/text_hello"
        />
</LinearLayout>

Abra el archivo res/values/strings.xml y agregue las siguientes líneas:

<string name="button_subscribe">Subscribe</string>
<string name="label_world">World</string>
<string name="label_politics">Politics</string>
<string name="label_business">Business</string>
<string name="label_technology">Technology</string>
<string name="label_science">Science</string>
<string name="label_sports">Sports</string>

El diseño gráfico de main_activity.xml debe ser similar al de la siguiente imagen:

Captura de pantalla de un emulador que muestra el aspecto del diseño gráfico de la actividad principal X M L.

Cree una clase Notifications en el mismo paquete que la clase MainActivity.

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.Toast;

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;

public class Notifications {
    private static final String PREFS_NAME = "BreakingNewsCategories";
    private FirebaseInstanceId fcm;
    private NotificationHub hub;
    private Context context;
    private String senderId;
    public static String FCM_token = "";
    private static final String TAG = "Notifications";

    public Notifications(Context context, String hubName, String listenConnectionString) {
        this.context = context;
        this.senderId = senderId;

        fcm = FirebaseInstanceId.getInstance();
        hub = new NotificationHub(hubName, listenConnectionString, context);
    }

    public void storeCategoriesAndSubscribe(Set<String> categories)
    {
        SharedPreferences settings = context.getSharedPreferences(PREFS_NAME, 0);
        settings.edit().putStringSet("categories", categories).commit();
        subscribeToCategories(categories);
    }

    public Set<String> retrieveCategories() {
        SharedPreferences settings = context.getSharedPreferences(PREFS_NAME, 0);
        return settings.getStringSet("categories", new HashSet<String>());
    }

    public void subscribeToCategories(final Set<String> categories) {
        new AsyncTask<Object, Object, Object>() {
            @Override
            protected Object doInBackground(Object... params) {
                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);

                    String templateBodyFCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";

                    hub.registerTemplate(FCM_token,"simpleFCMTemplate", templateBodyFCM,
                            categories.toArray(new String[categories.size()]));
                } catch (Exception e) {
                    Log.e("MainActivity", "Failed to register - " + e.getMessage());
                    return e;
                }
                return null;
            }

            protected void onPostExecute(Object result) {
                String message = "Subscribed for categories: "
                        + categories.toString();
                Toast.makeText(context, message,
                        Toast.LENGTH_LONG).show();
            }
        }.execute(null, null, null);
    }

}

Esta clase usa el almacenamiento local para almacenar las categorías de noticias que este dispositivo ha de recibir. También contiene métodos para registrar estas categorías.

En la clase MainActivity, agregue un campo para Notifications:
```
private Notifications notifications;
```
A continuación, actualice el método onCreate tal como se muestra en el código siguiente. Puede registrarse en Notification Hubs con el método subscribeToCategories de la clase Notifications.
```
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mainActivity = this;

    FirebaseService.createChannelAndHandleNotifications(getApplicationContext());
    notifications = new Notifications(this, NotificationSettings.HubName, NotificationSettings.HubListenConnectionString);
    notifications.subscribeToCategories(notifications.retrieveCategories());
}
```
Confirme que el nombre del centro y la cadena de conexión están configuradas correctamente en la clase NotificationSettings.

Nota

Puesto que las credenciales que se distribuyen con una aplicación de cliente no son normalmente seguras, solo debe distribuir la clave para el acceso de escucha con la aplicación cliente. El acceso de escucha permite a la aplicación el registro de notificaciones, pero los registros existentes no pueden modificarse y las notificaciones no se pueden enviar. La clave de acceso completo se usa en un servicio back-end protegido para el envío de notificaciones y el cambio de registros existentes.

Luego, agregue las importaciones siguientes:

import android.widget.CheckBox;
import java.util.HashSet;
import java.util.Set;
import android.view.View;

Agregue el siguiente método subscribe para controlar el evento clic del botón de suscripción:

public void subscribe(View sender) {
    final Set<String> categories = new HashSet<String>();

    CheckBox world = (CheckBox) findViewById(R.id.worldBox);
    if (world.isChecked())
        categories.add("world");
    CheckBox politics = (CheckBox) findViewById(R.id.politicsBox);
    if (politics.isChecked())
        categories.add("politics");
    CheckBox business = (CheckBox) findViewById(R.id.businessBox);
    if (business.isChecked())
        categories.add("business");
    CheckBox technology = (CheckBox) findViewById(R.id.technologyBox);
    if (technology.isChecked())
        categories.add("technology");
    CheckBox science = (CheckBox) findViewById(R.id.scienceBox);
    if (science.isChecked())
        categories.add("science");
    CheckBox sports = (CheckBox) findViewById(R.id.sportsBox);
    if (sports.isChecked())
        categories.add("sports");

    notifications.storeCategoriesAndSubscribe(categories);
}

Este método crea una lista de categorías y usa la clase Notifications para almacenar la lista en el almacenamiento local y registrar las etiquetas correspondientes en el centro de notificaciones. Cuando se modifican las categorías, el registro vuelve a crearse con las nuevas categorías.

La aplicación ahora puede almacenar un conjunto de categorías en el almacenamiento local en el dispositivo y registrarse en el Centro de notificaciones siempre que el usuario cambie la selección de categorías.

Registro de notificaciones

Estos pasos permiten registrar el Centro de notificaciones en el inicio mediante las categorías que se han almacenado en el almacén local.

Confirme que el código siguiente está al final del método onCreate de la clase MainActivity:
```
notifications.subscribeToCategories(notifications.retrieveCategories());
```
Este código garantiza que cada vez que la aplicación se inicia, se recuperan las categorías del almacenamiento local y se solicita un registro de estas categorías.

Después actualice el método onStart() de la clase MainActivity de la siguiente manera:

@Override
protected void onStart() {

    super.onStart();
    isVisible = true;

    Set<String> categories = notifications.retrieveCategories();

    CheckBox world = (CheckBox) findViewById(R.id.worldBox);
    world.setChecked(categories.contains("world"));
    CheckBox politics = (CheckBox) findViewById(R.id.politicsBox);
    politics.setChecked(categories.contains("politics"));
    CheckBox business = (CheckBox) findViewById(R.id.businessBox);
    business.setChecked(categories.contains("business"));
    CheckBox technology = (CheckBox) findViewById(R.id.technologyBox);
    technology.setChecked(categories.contains("technology"));
    CheckBox science = (CheckBox) findViewById(R.id.scienceBox);
    science.setChecked(categories.contains("science"));
    CheckBox sports = (CheckBox) findViewById(R.id.sportsBox);
    sports.setChecked(categories.contains("sports"));
}

Este código actualiza la actividad principal en función del estado de las categorías guardadas anteriormente.

La aplicación está ahora completa y puede almacenar un conjunto de categorías en el almacenamiento local del dispositivo usado para registrarse en el Centro de notificaciones cuando el usuario cambie la selección de categorías. A continuación, defina un back-end que pueda enviar notificaciones de categorías a esta aplicación.

Envío de notificaciones con etiquetas

En esta sección se envían noticias de última hora como notificaciones de plantilla con etiquetas desde una aplicación de consola .NET.

En Visual Studio, cree una nueva aplicación de consola en Visual C#:
1. En el menú, seleccione Archivo>Nuevo>Proyecto.
2. En Crear un proyecto, seleccione Aplicación de consola (.NET Framework) para C# en la lista de plantillas y seleccione Siguiente.
3. Escriba un nombre para la aplicación.
4. En Solución, elija Agregar a solución y seleccione Crear, para crear el proyecto.
Seleccione Herramientas>Administrador de paquetes NuGet>Consola del administrador de paquetes y, en la ventana de la consola, ejecute el siguiente comando:
```
Install-Package Microsoft.Azure.NotificationHubs
```
Esta acción agrega una referencia al SDK de Azure Notification Hubs mediante el paquete Microsoft.Azure.NotificationHubs.
Abra el archivo Program.cs y agregue la siguiente instrucción using:
```
using Microsoft.Azure.NotificationHubs;
```

En la clase Program , agregue el siguiente método o reemplácelo si ya existe:

private static async void SendTemplateNotificationAsync()
{
    // Define the notification hub.
    NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<connection string with full access>", "<hub name>");

    // Apple requires the apns-push-type header for all requests
    var headers = new Dictionary<string, string> {{"apns-push-type", "alert"}};

    // Create an array of breaking news categories.
    var categories = new string[] { "World", "Politics", "Business", "Technology", "Science", "Sports"};

    // Send the notification as a template notification. All template registrations that contain
    // "messageParam" and the proper tags will receive the notifications.
    // This includes APNS, GCM/FCM, WNS, and MPNS template registrations.

    Dictionary<string, string> templateParams = new Dictionary<string, string>();

    foreach (var category in categories)
    {
        templateParams["messageParam"] = "Breaking " + category + " News!";
        await hub.SendTemplateNotificationAsync(templateParams, category);
    }
}

Este código envía una notificación de plantilla para cada una de las seis etiquetas en la matriz de cadenas. El uso de etiquetas garantiza que los dispositivos reciben notificaciones solo de las categorías registradas.

En el código anterior, reemplace los marcadores de posición <hub name> y <connection string with full access> por el nombre del centro de notificaciones y la cadena de conexión de DefaultFullSharedAccessSignature del panel del centro de notificaciones.

Agregue las siguientes líneas al método Main():

 SendTemplateNotificationAsync();
 Console.ReadLine();

Compile la aplicación de consola.

Prueba de la aplicación

En Android Studio, ejecute la aplicación del emulador o dispositivo Android. La interfaz de usuario de la aplicación ofrece un conjunto de elementos de alternancia que le permiten seleccionar las categorías a las que suscribirse.
Habilite uno o más elementos de alternancia de las categorías y, a continuación, haga clic en Suscribirse. La aplicación convierte las categorías seleccionadas en etiquetas y solicita un nuevo registro de dispositivo para las etiquetas seleccionadas al Centro de notificaciones. Se devuelven las categorías registradas y se muestran en una notificación del sistema.
Ejecute la aplicación de consola .NET, que envía notificaciones para cada categoría. Las notificaciones para las categorías seleccionadas aparecen como notificaciones del sistema.

Pasos siguientes

En este tutorial se han enviado notificaciones de difusión a los dispositivos Android concretos a que se han registrado para las categorías. Para aprender a enviar notificaciones push a usuarios específicos, pase al siguiente tutorial:

Envío de notificaciones push a usuarios específicos

Compartir por