Configurar una aplicación cliente de Firebase Cloud Messaging con C++

Para escribir tu aplicación cliente multiplataforma de Firebase Cloud Messaging con C++, usa la API de Firebase Cloud Messaging . El SDK de C++ funciona para plataformas Android y Apple, y se requiere alguna configuración adicional para cada plataforma.

Configurar Firebase y el SDK de FCM

Androide

  1. Si aún no lo has hecho, agrega Firebase a tu proyecto de C++ .

    • En las instrucciones de configuración vinculadas, revise los requisitos del dispositivo y la aplicación para usar el SDK de Firebase C++, incluida la recomendación de usar CMake para crear su aplicación.

    • En su archivo build.gradle a nivel de proyecto, asegúrese de incluir el repositorio Maven de Google en las secciones buildscript y allprojects .

  2. Cree un objeto de aplicación Firebase, pasando el entorno JNI y la actividad:

    app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);

  3. Defina una clase que implemente la interfaz firebase::messaging::Listener .

  4. Inicialice FCM, pasando la aplicación y un oyente construido:

    ::firebase::messaging::Initialize(app, listener);

  5. Las aplicaciones que dependen del SDK de servicios de Google Play deben verificar en el dispositivo un APK de servicios de Google Play compatible antes de acceder a las funciones. Para obtener más información, consulte Buscar APK de servicios de Google Play .

iOS+

  1. Necesita un certificado APN válido. Si aún no tiene uno, asegúrese de crear uno en el Centro de miembros desarrolladores de Apple .
  2. Si aún no lo has hecho, agrega Firebase a tu proyecto de C++ . Luego, para configurar su proyecto para FCM:
    1. En el Podfile de su proyecto, agregue la dependencia FCM:
      pod 'FirebaseMessaging'
    2. Arrastre los marcos firebase.framework y firebase_messaging.framework a su proyecto Xcode desde el SDK de Firebase C++ .

  3. Configure su proyecto Xcode para habilitar las notificaciones push:

    1. Seleccione el proyecto en el área del Navegador .
    2. Seleccione el destino del proyecto en el área Editor .

    3. Seleccione la pestaña General del área Editor .

      1. Desplácese hacia abajo hasta Bibliotecas y marcos vinculados y luego haga clic en el botón + para agregar marcos.

      2. En la ventana que aparece, desplácese hasta UserNotifications.framework , haga clic en esa entrada y luego haga clic en Agregar .

        Este marco solo aparece en Xcode v8 y posteriores y es requerido por esta biblioteca.

    4. Seleccione la pestaña Capacidades del área Editor .

      1. Cambie las notificaciones automáticas a Activadas .
      2. Desplázate hacia abajo hasta Modos de fondo y luego cámbialo a Activado .
      3. Seleccione Notificaciones remotas en Modos en segundo plano .

  4. Cree un objeto de aplicación Firebase:

    app = ::firebase::App::Create(::firebase::AppOptions());

  5. Defina una clase que implemente la interfaz firebase::messaging::Listener .

  6. Inicialice Firebase Cloud Messaging, pasando la aplicación y un oyente construido:

    ::firebase::messaging::Initialize(app, listener);

Acceder al token de registro del dispositivo

Al inicializar la biblioteca de Firebase Cloud Messaging, se solicita un token de registro para la instancia de la aplicación cliente. La aplicación recibirá el token con la devolución de llamada OnTokenReceived , que debe definirse en la clase que implementa firebase::messaging::Listener .

Si desea apuntar a ese dispositivo específico, necesitará acceso a este token.

Nota sobre la entrega de mensajes en Android

Cuando la aplicación no se está ejecutando y un usuario toca una notificación, el mensaje, de forma predeterminada, no se enruta a través de las devoluciones de llamada integradas de FCM. En este caso, las cargas de mensajes se reciben a través de un Intent utilizado para iniciar la aplicación. Para que FCM reenvíe estos mensajes entrantes a la devolución de llamada de la biblioteca C++, debe anular el método onNewIntent en su 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());
    // For older versions of Firebase C++ SDK (< 7.1.0), use `startService`.
    // startService(message);
    MessageForwardingService.enqueueWork(this, message);
  }
}

Los mensajes recibidos mientras la aplicación está en segundo plano tienen el contenido de su campo de notificación utilizado para completar la notificación de la bandeja del sistema, pero el contenido de la notificación no se comunicará a FCM. Es decir, Message::notification será nulo.

En resumen:

Estado de la aplicación Notificación Datos Ambos
Primer plano OnMessageReceived OnMessageReceived OnMessageReceived
Fondo Bandeja del sistema OnMessageReceived Notificación: bandeja del sistema
Datos: en extras de la intención.

Manejo de mensajes personalizado en Android

De forma predeterminada, las notificaciones enviadas a la aplicación se pasan a ::firebase::messaging::Listener::OnMessageReceived , pero en algunos casos es posible que desees anular el comportamiento predeterminado. Para hacer esto en Android necesitarás escribir clases personalizadas que extiendan com.google.firebase.messaging.cpp.ListenerService así como actualizar AndroidManifest.xml de tu proyecto.

Anular los métodos ListenerService .

ListenerService es la clase Java que intercepta los mensajes entrantes enviados a la aplicación y los enruta a la biblioteca C++. Cuando la aplicación está en primer plano (o cuando la aplicación está en segundo plano y recibe una carga útil de solo datos), los mensajes pasarán a través de una de las devoluciones de llamada proporcionadas en esta clase. Para agregar un comportamiento personalizado al manejo de mensajes, deberá extender ListenerService predeterminado de FCM:

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

class MyListenerService extends ListenerService {

Al anular el método ListenerService.onMessageReceived , puede realizar acciones basadas en 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);
}

ListenerService también tiene algunos otros métodos que se utilizan con menos frecuencia. Estos también se pueden anular; para obtener más información, consulte la referencia de 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);
}

Actualizar AndroidManifest.xml

Una vez que se hayan escrito las clases personalizadas, deben incluirse en AndroidManifest.xml para que surtan efecto. Asegúrese de que el manifiesto incluya las herramientas de combinación declarando el atributo apropiado dentro de la etiqueta <manifest> , así:

<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 hay un archivo AndroidManifest.xml que declara ListenerService predeterminado de FCM. Este manifiesto normalmente se combina con el manifiesto específico del proyecto, que es como se puede ejecutar ListenerService . Este ListenerService debe reemplazarse con el servicio de escucha personalizado. Esto se logra eliminando el ListenerService predeterminado y agregando el servicio personalizado, lo que se puede hacer con las siguientes líneas en el archivo AndroidManifest.xml de su 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>

Las nuevas versiones del SDK de Firebase C++ (7.1.0 en adelante) usan JobIntentService , que requiere modificaciones adicionales en el archivo AndroidManifest.xml .

<service android:name="com.google.firebase.messaging.MessageForwardingService"
     android:permission="android.permission.BIND_JOB_SERVICE"
     android:exported="false" >
</service>

Prevenir la inicialización automática

FCM genera un token de registro para la orientación por dispositivo. Cuando se genera un token, la biblioteca carga el identificador y los datos de configuración en Firebase. Si desea obtener una suscripción explícita antes de usar el token, puede evitar su generación en el momento de la configuración desactivando FCM (y en Android, Analytics). Para hacer esto, agregue un valor de metadatos a su Info.plist (no a su GoogleService-Info.plist ) en plataformas Apple, o a su AndroidManifest.xml en Android:

Androide

<?xml version="1.0" encoding="utf-8"?>
<application>
  <meta-data android:name="firebase_messaging_auto_init_enabled"
             android:value="false" />
  <meta-data android:name="firebase_analytics_collection_enabled"
             android:value="false" />
</application>

Rápido

FirebaseMessagingAutoInitEnabled = NO

Para volver a habilitar FCM, puede realizar una llamada en tiempo de ejecución:

::firebase::messaging::SetTokenRegistrationOnInitEnabled(true);

Este valor persiste durante los reinicios de la aplicación una vez establecido.

FCM permite enviar mensajes que contengan un enlace profundo a su aplicación. Para recibir mensajes que contengan un vínculo profundo, debe agregar un nuevo filtro de intención a la actividad que maneja vínculos profundos para su aplicación. El filtro de intención debería detectar enlaces profundos de su dominio. Si sus mensajes no contienen un enlace profundo, esta configuración no es necesaria. En AndroidManifest.xml:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="http"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="https"/>
</intent-filter>

También es posible especificar un comodín para que el filtro de intención sea más flexible. Por ejemplo:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="*.example.com" android:scheme="http"/>
  <data android:host="*.example.com" android:scheme="https"/>
</intent-filter>

Cuando los usuarios tocan una notificación que contiene un enlace al esquema y al host que usted especifica, su aplicación iniciará la actividad con este filtro de intención para manejar el enlace.

Próximos pasos

Después de configurar la aplicación cliente, estará listo para enviar mensajes posteriores y temáticos con Firebase. Para obtener más información, vea esta funcionalidad demostrada en el ejemplo de inicio rápido que puede descargar, ejecutar y revisar.

Para agregar otro comportamiento más avanzado a su aplicación, consulte las guías para enviar mensajes desde un servidor de aplicaciones:

Tenga en cuenta que necesitará una implementación de servidor para utilizar estas funciones.