Configura una app cliente de Firebase Cloud Messaging con C++

Para escribir tu app cliente multiplataforma de Firebase Cloud Messaging con C++, usa la API Firebase Cloud Messaging. El SDK de C++ funciona tanto en Android como en iOS, aunque se requiere un poco de configuración adicional para cada plataforma.

Configura Firebase y el SDK de FCM

Android

  1. Para las apps cliente de FCM, se necesitan dispositivos con Android 4.0 o una versión más reciente, que además tengan instalada la aplicación de servicios de Google Play y que se compilen con Gradle mediante Android Studio 1.4 o una versión más reciente.
  2. Si aún no lo hiciste, agrega Firebase a tu proyecto de C++.
  3. En Android Studio, agrega la dependencia de FCM al archivo build.gradle de nivel de tu app:
    repositories {
    flatDir {
    dirs project.ext.firebase_cpp_sdk_dir + "/libs/android"
    }
    }
    dependencies {
     compile 'com.google.firebase:firebase-messaging:12.0.1'
     compile 'com.google.firebase.messaging.cpp:firebase_messaging_cpp@aar'
    }
  4. Vincula libapp.a y la biblioteca estática libmessaging.a desde el SDK de C++.
  5. Crea un objeto de app de Firebase y pasa el entorno y la actividad de JNI:
    app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);
    
  6. Define una clase que implemente la interfaz firebase::messaging::Listener.
  7. Inicializa Firebase Cloud Messaging y pasa la app y un agente de escucha construido:
    ::firebase::messaging::Initialize(app, listener);
    
  8. Las apps que usan el SDK de servicios de Play deben verificar que el dispositivo tenga un APK de Servicios de Google Play compatible antes de acceder a las funciones. Para obtener más información, consulta Búsqueda de APK de Servicios Google Play.

iOS

  1. Necesitas un certificado APNS válido. Si aún no tienes uno, consulta Aprovisionamiento de certificados SSL del APNS.
  2. Si aún no lo hiciste, agrega Firebase a tu proyecto de C++.
  3. En el Podfile de tu proyecto, agrega la dependencia de FCM:
    pod 'Firebase/Messaging'
  4. Arrastra los marcos de trabajo firebase.framework y firebase_messaging.framework a tu proyecto Xcode desde el SDK de C++.
  5. Crea un objeto de app de Firebase:
    app = ::firebase::App::Create(::firebase::AppOptions());
  6. Define una clase que implemente la interfaz firebase::messaging::Listener.
  7. Inicializa Firebase Cloud Messaging y pasa la app y un agente de escucha construido:
    ::firebase::messaging::Initialize(app, listener);

Accede al token de registro de dispositivo

Después de inicializar la biblioteca de Firebase Cloud Messaging, se solicita un token de registro para la instancia de app del cliente. La app recibirá el token con la devolución de llamada OnTokenReceived, que se debería definir en la clase que implementa firebase::messaging::Listener.

Si deseas orientarte hacia ese dispositivo específico, necesitarás acceder a este token.

Nota sobre la entrega de mensajes en Android

Cuando la aplicación no se está ejecutando en absoluto y un usuario presiona una notificación, el mensaje no se envía, de manera predeterminada, a través de las devoluciones de llamada incorporadas en FCM. En este caso, las cargas útiles de los mensajes se reciben a través de un Intent que se utiliza para iniciar la aplicación. Para que FCM reenvíe estos mensajes entrantes a la devolución de llamada de la biblioteca de C++, se debe anular el método onNewIntent en tu actividad y pasar el Intent al MessageForwardingService.

import com.google.firebase.messaging.MessageForwardingService;

class MyActivity extends Activity {
  private static final String TAG = "MyActvity";

  @Override
  protected void onNewIntent(Intent intent) {
    Log.d(TAG, "A message was sent to this app while it was in the background.");
    Intent message = new Intent(this, MessageForwardingService.class);
    message.setAction(MessageForwardingService.ACTION_REMOTE_INTENT);
    message.putExtras(intent);
    message.setData(intent.getData());
    startService(message);
  }
}

Los mensajes que se reciben mientras la app se ejecuta en segundo plano incluyen el contenido del campo de notificación que se usó para rellenar la información de la notificación de la bandeja del sistema. Sin embargo, no se comunicará el contenido de esa notificación a FCM, es decir, Message::notification será nulo.

Resumen:

Estado de la app Notificación Datos Ambos
Primer plano OnMessageReceived OnMessageReceived OnMessageReceived
Segundo plano Bandeja del sistema OnMessageReceived Notificación: Bandeja del sistema
Datos: En extras del intent.

Administración personalizada de mensajes en Android

De forma predeterminada, las notificaciones enviadas a la app se pasan a ::firebase::messaging::Listener::OnMessageReceived, pero, en algunos casos, es posible que desees anular el comportamiento predeterminado. Para hacer esto en Android, deberás escribir clases personalizadas que extiendan com.google.firebase.messaging.cpp.ListenerService y que actualicen el archivo AndroidManifest.xml de tu proyecto.

Anula los métodos ListenerService

El ListenerService es la clase Java que intercepta los mensajes entrantes enviados a la app y los dirige a la biblioteca de C++. Cuando la app se ejecuta en primer plano (o en segundo plano y recibe una carga solo de datos), los mensajes pasarán a través de una de las devoluciones de llamada proporcionadas en esta clase. Para agregar un comportamiento personalizado a la administración de mensajes, necesitarás extender el ListenerService predeterminado de FCM:

import com.google.firebase.messaging.cpp.ListenerService;

class MyListenerService extends ListenerService {

Puedes anular el método ListenerService.onMessageReceived para realizar acciones según el objeto RemoteMessage recibido y obtener los datos del mensaje:

@Override
public void onMessageReceived(RemoteMessage message) {
  Log.d(TAG, "A message has been received.");
  // Do additional logic...
  super.onMessageReceived(message);
}

El ListenerService tiene otros métodos que se utilizan con menos frecuencia y que también se pueden anular. Para obtener más detalles, consulta la información de referencia FirebaseMessagingService.

@Override
public void onDeletedMessages() {
  Log.d(TAG, "Messages have been deleted on the server.");
  // Do additional logic...
  super.onDeletedMessages();
}

@Override
public void onMessageSent(String messageId) {
  Log.d(TAG, "An outgoing message has been sent.");
  // Do additional logic...
  super.onMessageSent(messageId);
}

@Override
public void onSendError(String messageId, Exception exception) {
  Log.d(TAG, "An outgoing message encountered an error.");
  // Do additional logic...
  super.onSendError(messageId, exception);
}

Actualiza AndroidManifest.xml

Una vez que se hayan escrito tus clases personalizadas, se deben incluir en el archivo AndroidManifest.xml para que surtan efecto. Asegúrate de que el manifiesto incluya las herramientas de combinación mediante la declaración del atributo apropiado en la etiqueta <manifest> de la siguiente manera:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.google.firebase.messaging.cpp.samples"
    xmlns:tools="http://schemas.android.com/tools">

En el archivo firebase_messaging_cpp.aar, se encuentra un archivo AndroidManifest.xml que declara el ListenerService predeterminado de FCM. Normalmente, este manifiesto se combina con el manifiesto específico del proyecto, de modo que se ejecute el ListenerService. Este ListenerService debe reemplazarse con el servicio de agente de escucha personalizado. Esto se logra si se quita el ListenerService predeterminado y se agrega el servicio personalizado mediante las siguientes líneas en el archivo AndroidManifest.xml de tu proyecto:

<service android:name="com.google.firebase.messaging.cpp.ListenerService"
         tools:node="remove" />
<service android:name="com.google.firebase.messaging.cpp.samples.MyListenerService"
         android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT"/>
  </intent-filter>
</service>

Pasos siguientes

Después de configurar la app cliente, estás listo para enviar mensajes descendentes y a temas con Firebase. Para obtener más información, consulta la demostración que se incluye en la guía de inicio rápido de ejemplo que puedes descargar, ejecutar y revisar.

Para agregar otro comportamiento más avanzado a tu app, consulta las guías para enviar mensajes desde un servidor de apps.

Recuerda que necesitarás una implementación de servidor para usar estas funciones.

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.