Incorporación de notificaciones push a la aplicación Android

2019-06-25

Información general

En este tutorial, agregará notificaciones push al proyecto de inicio rápido de Android para que se envíe una notificación push al dispositivo cada vez que se inserte un registro.

Si no usa el proyecto de servidor de inicio rápido descargado, necesita el paquete de extensión de notificación push. Para más información, consulte Trabajar con el SDK del servidor back-end de .NET para Azure Mobile Apps.

Prerrequisitos

Necesita lo siguiente:

Un IDE, según el back-end del proyecto:
- Android Studio si esta aplicación tiene un backend Node.js.
- Visual Studio Community 2013 o posterior si esta aplicación tiene un back-end de Microsoft .NET.
Android 2.3 o posterior, revisión 27 o posterior del repositorio de Google y Google Play Services 9.0.2 o posterior para Firebase Cloud Messaging.
Complete el inicio rápido de Android.

Creación de un proyecto que admita Firebase Cloud Messaging

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.
Realice los siguientes cambios de configuración a su 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 de Firebase, selecciona el engranaje de tu 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. Usas este valor para configurar el concentrador.

Configuración de un centro de notificaciones

La función Mobile Apps de Azure App Service usa Azure Notification Hubs para enviar notificaciones push, por lo tanto, configurarás un centro de notificaciones para su aplicación móvil.

En Azure Portal, vaya a App Servicesy, a continuación, seleccione el back-end de la aplicación. En Configuración, seleccione Notificaciones Push.
Para agregar un recurso del centro de notificaciones a la aplicación, seleccionar Connect. Puede crear un centro o conectarse a uno existente.

Ahora ha conectado un centro de notificaciones al proyecto de back-end de Mobile Apps. Más adelante, configure este centro de notificaciones para conectarse a un sistema de notificaciones de plataforma (PNS) para insertar en los dispositivos.

Configuración de Azure para enviar notificaciones push

En el portal de Azure, haga clic en Examinar todo>Servicios de Aplicacionesy, a continuación, haga clic en el back-end de aplicaciones móviles. En Configuración, haga clic en Push de App Servicey luego haga clic en el nombre del centro de notificaciones.
Vaya a Google (GCM), escriba el valor clave del servidor que obtuvo de Firebase en el procedimiento anterior y, a continuación, haga clic en Guardar.

El back-end de Mobile Apps ahora está configurado para usar Firebase Cloud Messaging. Esto le permite enviar notificaciones push a la aplicación que se ejecuta en un dispositivo Android mediante el centro de notificaciones.

Habilitación de notificaciones push para el proyecto de servidor

Use el procedimiento que coincida con el tipo de proyecto back-end, ya sea back-end de .NET o Node.js back-end.

Proyecto back-end de .NET

En Visual Studio, haga clic con el botón derecho en el proyecto de servidor y haga clic en Administrar paquetes NuGet. Busque Microsoft.Azure.NotificationHubs, y luego haga clic en Instalar. Esto instala la biblioteca cliente de Notification Hubs.
En la carpeta Controladores, abra TodoItemController.cs y agregue las siguientes using instrucciones:
```
using Microsoft.Azure.Mobile.Server.Config;
using Microsoft.Azure.NotificationHubs;
```

Reemplace el método PostTodoItem con el código siguiente:

public async Task<IHttpActionResult> PostTodoItem(TodoItem item)
{
    TodoItem current = await InsertAsync(item);
    // Get the settings for the server project.
    HttpConfiguration config = this.Configuration;

    MobileAppSettingsDictionary settings =
        this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();

    // Get the Notification Hubs credentials for the Mobile App.
    string notificationHubName = settings.NotificationHubName;
    string notificationHubConnection = settings
        .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;

    // Create a new Notification Hub client.
    NotificationHubClient hub = NotificationHubClient
    .CreateClientFromConnectionString(notificationHubConnection, notificationHubName);

    // Android payload
    var androidNotificationPayload = "{ \"data\" : {\"message\":\"" + item.Text + "\"}}";

    try
    {
        // Send the push notification and log the results.
        var result = await hub.SendGcmNativeNotificationAsync(androidNotificationPayload);

        // Write the success result to the logs.
        config.Services.GetTraceWriter().Info(result.State.ToString());
    }
    catch (System.Exception ex)
    {
        // Write the failure result to the logs.
        config.Services.GetTraceWriter()
            .Error(ex.Message, null, "Push.SendAsync Error");
    }
    return CreatedAtRoute("Tables", new { id = current.Id }, current);
}

Republíque el proyecto del servidor.

Proyecto de back-end con Node.js

Configure el proyecto de back-end.

Reemplace el código existente en el archivo todoitem.js por lo siguiente:

var azureMobileApps = require('azure-mobile-apps'),
promises = require('azure-mobile-apps/src/utilities/promises'),
logger = require('azure-mobile-apps/src/logger');

var table = azureMobileApps.table();

table.insert(function (context) {
// For more information about the Notification Hubs JavaScript SDK,
// see https://aka.ms/nodejshubs
logger.info('Running TodoItem.insert');

// Define the GCM payload.
var payload = {
    "data": {
        "message": context.item.text
    }
};

// Execute the insert.  The insert returns the results as a Promise,
// Do the push as a post-execute action within the promise flow.
return context.execute()
    .then(function (results) {
        // Only do the push if configured
        if (context.push) {
            // Send a GCM native notification.
            context.push.gcm.send(null, payload, function (error) {
                if (error) {
                    logger.error('Error while sending push notification: ', error);
                } else {
                    logger.info('Push notification sent successfully!');
                }
            });
        }
        // Don't forget to return the results from the context.execute()
        return results;
    })
    .catch(function (error) {
        logger.error('Error while running context.execute: ', error);
    });
});

module.exports = table;

Esto envía una notificación GCM que contiene el archivo item.text cuando se inserta un nuevo elemento de tareas pendientes.

Al editar el archivo en el equipo local, vuelva a publicar el proyecto de servidor.

Incorporación de notificaciones push a la aplicación

En esta sección, actualizará la aplicación Android cliente para controlar las notificaciones push.

Comprobación de la versión de Android SDK

Debido al desarrollo continuo, es posible que la versión de Android SDK instalada en Android Studio no coincida con la versión del código. Android SDK al que se hace referencia en este tutorial es la versión 26, la más reciente en el momento de escribir. El número de versión puede aumentar a medida que aparezcan nuevas versiones del SDK y se recomienda usar la versión más reciente disponible.

Dos síntomas de falta de coincidencia de versiones son:

Al compilar o recompilar el proyecto, puede obtener mensajes de error de Gradle como Gradle sync failed: Failed to find target with hash string 'android-XX'.
Los objetos Android estándar en el código que deben resolverse en función de las import instrucciones pueden generar mensajes de error.

Si aparece alguna de estas opciones, es posible que la versión del SDK de Android instalado en Android Studio no coincida con el destino del SDK del proyecto descargado. Para comprobar la versión, realice los cambios siguientes:

En Android Studio, haga clic en Herramientas> deAndroid>SDK Manager. Si no ha instalado la versión más reciente de la plataforma del SDK, haga clic para instalarla. Anote el número de versión.
En la pestaña Explorador de proyectos, en Scripts de Gradle, abra el archivo build.gradle (Módulo: aplicación). Asegúrese de que compileSdkVersion y targetSdkVersion estén establecidos en la versión más reciente del SDK instalada. build.gradle El podría tener este aspecto:
```
android {
    compileSdkVersion 26
    defaultConfig {
        targetSdkVersion 26
    }
}
```

El siguiente paso es instalar los servicios de Google Play. Firebase Cloud Messaging tiene algunos requisitos mínimos de nivel de API para el desarrollo y las pruebas, a los que debe ajustarse la propiedad minSdkVersion del manifiesto.

Si está probando con un dispositivo anterior, consulte Agregar Firebase a Su proyecto de Android para determinar la baja que puede establecer este valor y establecerlo adecuadamente.

Incorporación de Firebase Cloud Messaging al proyecto

Incorporación de Firebase al proyecto de Android
En Android Studio, elija Archivo>Estructura del proyecto. Seleccione Notificaciones, Firebase Cloud Messaging y, a continuación, haga clic en Aceptar.

Agregar código

En el proyecto de aplicación , abra el archivo AndroidManifest.xml. Agregue el siguiente código después de la etiqueta de apertura application.

<service android:name=".ToDoMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>
<service android:name=".ToDoInstanceIdService">
    <intent-filter>
        <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
    </intent-filter>
</service>

Abra el archivo ToDoActivity.javay realice los siguientes cambios:

Agregue la instrucción de importación:

import com.google.firebase.iid.FirebaseInstanceId;

Cambie la definición de MobileServiceClient de private a private static, por lo que ahora tiene el siguiente aspecto:
```
private static MobileServiceClient mClient;
```

Método Add registerPush :

public static void registerPush() {
    final String token = FirebaseInstanceId.getInstance().getToken();
    if (token != null) {
        new AsyncTask<Void, Void, Void>() {
            protected Void doInBackground(Void... params) {
                mClient.getPush().register(token);
                return null;
            }
        }.execute();
    }
}

Actualice el método onCreate de la ToDoActivity clase . Asegúrese de agregar este código después de que MobileServiceClient sea instanciado.
```
registerPush();
```

Agregue una nueva clase para controlar las notificaciones. En el Explorador de proyectos, abra la aplicación>java>los nodos del espacio de nombres de su proyecto y haga clic con el botón derecho en el nodo de nombre del paquete. Haga clic en Nuevo, y luego haga clic en Clase Java. En Nombre, escriba ToDoMessagingServicey haga clic en Aceptar. A continuación, reemplace la declaración de clase por:

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class ToDoMessagingService extends FirebaseMessagingService {

    private static final int NOTIFICATION_ID = 1;

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        String message = remoteMessage.getData().get("message");
        if (message != null) {
            sendNotification("Notification Hub Demo", message);
        }
    }

    private void sendNotification(String title, String messageBody) {
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, ToDoActivity.class), 0);
        Notification.Builder notificationBuilder = new Notification.Builder(this)
                .setSmallIcon(R.drawable.ic_launcher)
                .setContentTitle(title)
                .setContentText(messageBody)
                .setContentIntent(contentIntent);
        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        if (notificationManager != null) {
            notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
        }
    }
}

Agregue otra clase para controlar las actualizaciones de tokens. Cree ToDoInstanceIdService una clase java y reemplace la declaración de clase por:

import com.google.firebase.iid.FirebaseInstanceIdService;

public class ToDoInstanceIdService extends FirebaseInstanceIdService {

    @Override
    public void onTokenRefresh() {
        ToDoActivity.registerPush();
    }
}

La aplicación ahora se actualiza para admitir notificaciones push.

Prueba de la aplicación en el servicio móvil publicado

Puede probar la aplicación mediante la conexión directa de un teléfono Android con un cable USB o mediante un dispositivo virtual en el emulador.

Pasos siguientes

Ahora que ha completado este tutorial, considere la posibilidad de continuar con uno de los siguientes tutoriales:

Agregue autenticación a la aplicación Android. Aprenda a agregar autenticación al proyecto de inicio rápido todolist en Android mediante un proveedor de identidades compatible.
Habilite la sincronización sin conexión para la aplicación Android. Obtenga información sobre cómo agregar compatibilidad sin conexión a la aplicación mediante un back-end de Mobile Apps. Con la sincronización sin conexión, los usuarios pueden interactuar con una aplicación móvil (ver, agregar o modificar datos), incluso cuando no hay ninguna conexión de red.

Compartir a través de