Tutorial: Implement Android Push Notifications in your Couchbase Mobile app

Al desarrollar una aplicación, es muy útil utilizar la replicación push y pull en modo continuo. Los replicadores se encargan de todo para asegurarse de que su aplicación y Sync Gateway siempre tengan sincronizados los documentos más recientes.

Sin embargo, una replicación pull continua significa que Couchbase Lite utilizará técnicas como sondeos largos o web sockets para comprobar si hay nuevos datos que obtener de Sync Gateway. Esto puede tener un impacto en la duración de la batería y, en consecuencia, en la experiencia del usuario.

En este post, exploraremos una alternativa a la replicación pull continua utilizando Google Cloud Messaging, el servicio de notificaciones push de Android.

Puede consultar un ejemplo práctico en ToDoLite Android. ¡Veamos cómo puedes incluir la sincronización GCM en tu aplicación!

Activar GCM en tu aplicación

En primer lugar, vamos a configurar ToDoLite Android para que se registre en Google Cloud Messaging. Crearemos un nuevo proyecto Google API en el directorio consola para desarrolladores. Siga este guía para configurarlo. Deberías tener un número de proyecto y una clave API. Ahora podemos actualizar el proyecto de AndroidManifest.xml con los permisos necesarios, el filtro de intención y el servicio. Debería tener este aspecto:


 // ...

    
    
    
    

    
    

     // ...

        /* ... activities ... */

// ...

/* ... actividades ... */

Nota: Echa un vistazo a la ejemplo desde el sitio de desarrolladores de android también.

Si el proyecto está configurado correctamente, podemos recuperar el token de dispositivo con el número de proyecto que obtuvimos al crear la app en la consola de desarrollador de google. Añade un método en la Actividad Principal para recuperar el token de dispositivo desde GCM y guardarlo en el documento de perfil de usuario, por ejemplo:

void getDeviceToken() {
        new AsyncTask() {
            @Override
            protected String doInBackground(Void... params) {

                GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(getApplicationContext());

                String deviceToken = gcm.register("632113338862");
                Log.i("GCM", "Device token : " + deviceToken);

                // update user profile document

                return null;
            }
        }.execute(null, null, null);
}

void getDeviceToken() {

nuevo AsyncTask() {

@Anular

protegido Cadena doInBackground(Vacío... parámetros) {

GoogleCloudMessaging gcm = GoogleCloudMessaging.getInstance(getApplicationContext());

Cadena deviceToken = gcm.regístrese en("632113338862");

Registro.i("GCM", "Token del dispositivo : " + deviceToken);

// actualizar el documento de perfil de usuario

devolver null;

}

}.ejecutar(null, null, null);

}

Nota: Los tokens de dispositivo en Android siempre empiezan por APA91, así que no los pierdas de vista en LogCat ;)

A continuación, tenemos que añadir algo de código para manejar una notificación entrante. Subclasificamos la clase WakefulBroadcastReceiver donde el método onReceive es llamado cada vez que recibimos una notificación.

public class GcmBroadcastReceiver extends WakefulBroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // Explicitly specify that GcmMessageHandler will handle the intent.
        ComponentName component = new ComponentName(context.getPackageName(),
                GcmMessageHandler.class.getName());

        // Start the service, keeping the device awake while it is launching.
        startWakefulService(context, (intent.setComponent(component)));
        setResultCode(Activity.RESULT_OK);
    }

}

público clase GcmBroadcastReceiver extiende WakefulBroadcastReceiver {

@Anular

público void onReceive(Contexto contexto, Intención intento) {

// Especifica explícitamente que GcmMessageHandler manejará la intención.

ComponentName componente = nuevo ComponentName(contexto.getPackageName(),

GcmMessageHandler.clase.getName());

// Inicia el servicio, manteniendo el dispositivo despierto mientras se lanza.

startWakefulService(contexto, (intento.setComponent(componente)));

setResultCode(Actividad.RESULT_OK);

}

A partir de ahí, el servicio wakeful inicia la clase GcmMessageHandler y realiza una única replicación pull. El servicio wakeful se ejecuta incluso si tu aplicación se está ejecutando en segundo plano. Así, tu aplicación mostrará los nuevos datos cuando se abra.


public class GcmMessageHandler extends IntentService {
    
    /* ... */
    
    @Override
    protected void onHandleIntent(Intent intent) {
        mIntent = intent;
        showToast();
        Application application = (Application) getApplication();

        try {
            URL url = new URL(BuildConfig.SYNC_URL_HTTP);
            Replication pull = application.getDatabase().createPullReplication(url);
            pull.addChangeListener(getReplicationListener());
            pull.start();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

    }

    private Replication.ChangeListener getReplicationListener() {
        return new Replication.ChangeListener() {
            @Override
            public void changed(Replication.ChangeEvent event) {
                Log.i("GCM", "replication status is : " + event.getSource().getStatus());
                if (event.getSource().getStatus() == Replication.ReplicationStatus.REPLICATION_STOPPED) {
                    GcmBroadcastReceiver.completeWakefulIntent(mIntent);
                }
            }
        };
    }

    /* ... */

}

público clase GcmMessageHandler extiende IntentService {

/* ... */

@Anular

protegido void onHandleIntent(Intención intento) {

mIntent = intento;

showToast();

Aplicación aplicación = (Aplicación) getApplication();

pruebe {

URL url = nuevo URL(BuildConfig.SYNC_URL_HTTP);

Replicación tire de = aplicación.getDatabase().createPullReplication(url);

tire de.addChangeListener(getReplicationListener());

tire de.iniciar();

} captura (MalformedURLException e) {

e.printStackTrace();

}

privado Replicación.ChangeListener getReplicationListener() {

devolver nuevo Replicación.ChangeListener() {

@Anular

público void cambiado(Replicación.Evento de cambio evento) {

Registro.i("GCM", "el estado de replicación es : " + evento.getSource().getStatus());

si (evento.getSource().getStatus() == Replicación.ReplicationStatus.REPLICACIÓN_PARADA) {

GcmBroadcastReceiver.completeWakefulIntent(mIntent);

}

};

}

/* ... */

}

Fíjate que estamos usando el escuchador de cambios de replicación para que nos notifique cuando haya terminado y para apagar el servicio de vigilia.

Eso es todo lo que tenemos que hacer en el lado de Android para manejar la notificación de sincronización.

Guardar las fichas de los dispositivos

Ahora podemos almacenar el token de dispositivo en el documento de perfil de usuario. Cada usuario puede estar conectado a más de un dispositivo a la vez por lo que debemos almacenar cada uno de ellos. El documento de usuario tendrá este aspecto:

{
 "_id": "profile:johnny@couchbase.com",
 ...
 "device_tokens": ["APA91K...", "APA91O..."]
}

{

"_id": "profile:johnny@couchbase.com",

...

"device_tokens": ["APA91K...", "APA91O..."]

}

En la siguiente sección, hablaremos sobre cómo añadir lógica de aplicación adicional a Sync Gateway utilizando la fuente de cambios.

La pasarela de sincronización cambia de fuente

En /base de datos/cambios devuelve una lista ordenada de los cambios realizados en los documentos de la base de datos. Este endpoint forma parte de CouchDB spec y tanto Couchbase Lite Listener como Sync Gateway lo implementan.

Es muy fácil conectarse a la fuente de cambios de Sync Gateway para añadir lógica adicional al back-end como, en nuestro caso, el envío de notificaciones push.

Puede utilizar cualquier biblioteca que implemente la api de alimentación de cambios:

NodeJS: https://github.com/iriscouch/follow
Vamos: https://github.com/fjl/go-couchdb
Python: https://github.com/djc/couchdb-python
Java: https://github.com/helun/Ektorp

De todos los parámetros disponibles en la cadena de consulta, las más importantes en nuestro caso son:

feed=continuous para garantizar que recibimos los cambios inmediatamente
since=ahora para obtener los cambios desde el momento actual, de lo contrario registrará todos los cambios desde que se creó la base de datos.

Por último, centrémonos en la última pieza del rompecabezas: dado un cambio de documento del feed de cambios, necesitamos obtener los documentos del perfil de usuario "interesado" en ese cambio porque tienen las fichas de los dispositivos.

Cambios Feed → GCM

En ToDoLite, existen 3 tipos de documentos: un perfil, una lista y una tarea. El documento de tarea contiene una referencia a la lista a la que pertenece y una lista tiene un propietario y una matriz de miembros.

Cuando un documento de tarea o un documento de lista cambia, nos gustaría notificar al propietario y a los miembros de esa lista. Hay dos tipos de eventos que nos gustaría manejar:

1. Un evento de cambio de documento de lista:

obtener el documento de perfil del propietario
obtener el documento de perfil de cada miembro

2. Un evento de cambio de documento de tarea:

obtener el documento de la lista a la que pertenece
siga los mismos pasos que en 1)

Con los tokens de dispositivo recuperados, el último paso es enviar una petición a los servidores de Google Cloud Messaging con nuestra API Key y el payload de la notificación. También puedes encontrar muchas librerías en GitHub que simplifican la interacción con los servidores de GCM:

NodeJS: https://github.com/ToothlessGear/node-gcm
Vamos: https://github.com/alexjlockwood/gcm
Python: https://github.com/geeknam/python-gcm
Java: https://github.com/inloop/easygcm

Conclusión

El uso de Google Cloud Messaging para activar la obtención de datos desde el lado del servidor puede proporcionar una gran experiencia de usuario sin ninguna sobrecarga adicional de batería y uso de red.

Siga las léame instrucciones para ejecutar la demo de ToDoLite.

Me encantaría saber cómo utilizas las notificaciones de Google Cloud Messaging en tu aplicación. Házmelo saber en los comentarios.

Más lectura:

Consejos para configurar GCM en tu aplicación: https://blog.pushbullet.com/2014/02/12/keeping-google-cloud-messaging-for-android-working-reliably-techincal-post/
Sincronización de datos en la aplicación Google I/O: https://android-developers.blogspot.co.uk/2014/09/conference-data-sync-gcm-google-io.html

James Nocentini, Redactor técnico, Móvil, Couchbase

Comparte este artículo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Tutorial: Implementa las notificaciones push de Android en tu aplicación Couchbase Mobile

Activar GCM en tu aplicación

Guardar las fichas de los dispositivos

La pasarela de sincronización cambia de fuente

Cambios Feed → GCM

Conclusión

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Author

Posted by James Nocentini

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto