Configurar um app cliente do Firebase Cloud Messaging com C++

Para criar seu app cliente multiplataforma Firebase Cloud Messaging com C++, use a API Firebase Cloud Messaging. O SDK do C++ funciona com as plataformas Android e Apple, sendo necessárias configurações a mais em cada plataforma.

Configurar o Firebase e o SDK do FCM

Acessar o token de registro do dispositivo

Na inicialização da biblioteca do Firebase Cloud Messaging, um token de registro é solicitado para a instância do app cliente. O app recebe o token com o callback OnTokenReceived, que deve ser definido na classe que implementa firebase::messaging::Listener.

Para direcionar o app para esse dispositivo específico, você precisará ter acesso a esse token.

Observação sobre entrega de mensagens no Android

Quando o app não está em execução e um usuário toca em uma notificação, por padrão, a mensagem não é encaminhada usando as callbacks incorporadas do FCM. Nesse caso, os payloads das mensagens são recebidos por meio de um Intent usado para iniciar o aplicativo. Para que o FCM encaminhe essas mensagens recebidas para o callback da biblioteca C++, é necessário modificar o método onNewIntent na atividade e transmitir Intent para 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);
  }
}

As mensagens recebidas enquanto o aplicativo está em segundo plano têm o conteúdo do campo de notificação usado para preencher a notificação da bandeja do sistema, mas esse conteúdo não será comunicado ao FCM. Ou seja, Message::notification será nulo.

Em resumo:

Processamento de mensagens personalizadas no Android

Por padrão, as notificações enviadas para o app são transmitidas para ::firebase::messaging::Listener::OnMessageReceived, mas, em alguns casos, talvez você queira modificar o comportamento padrão. Para fazer isso no Android, é necessário gravar classes personalizadas que ampliam com.google.firebase.messaging.cpp.ListenerService além de atualizar os AndroidManifest.xml do projeto.

Modificar os métodos ListenerService.

ListenerService é a classe Java que intercepta as mensagens recebidas enviadas para o app e as encaminha para a biblioteca C ++. Quando o app está em primeiro plano (ou em segundo plano e recebe um payload somente de dados), as mensagens são transmitidas por meio de um dos callbacks fornecidos nessa classe. Para adicionar um comportamento personalizado ao processamento de mensagens, será necessário estender o ListenerService padrão do FCM:

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

class MyListenerService extends ListenerService {

Ao modificar o método ListenerService.onMessageReceived, é possível realizar ações com base no objeto RemoteMessage recebido e acessar os dados da mensagem:

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

ListenerService também tem alguns outros métodos que são usados com menos frequência. Eles também podem ser modificados. Para mais informações, consulte a referência 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);
}

Atualizar AndroidManifest.xml

Com suas classes personalizadas já escritas, é necessário incluí-las no AndroidManifest.xml para que tenham efeito. O manifesto precisa incluir as ferramentas de mesclagem declarando o atributo adequado dentro da tag <manifest> da seguinte maneira:

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

No arquivo firebase_messaging_cpp.aar há um arquivo AndroidManifest.xml que declara o ListenerService padrão do FCM. Normalmente, esse manifesto é mesclado com o manifesto específico do projeto, o que permite a execução de ListenerService. Esse ListenerService precisa ser substituído pelo serviço de listener personalizado. Isso é feito com a remoção do ListenerService padrão e a adição do serviço personalizado, o que pode ser feito com as seguintes linhas no arquivo AndroidManifest.xml do seu projeto:

<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>

As novas versões do SDK do Firebase para C++ (7.1.0 em diante) usam JobIntentService, que requer modificações adicionais no arquivo AndroidManifest.xml.

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

Impedir a inicialização automática

O FCM gera um token de registro para segmentação por dispositivo. Quando um token é gerado, a biblioteca faz upload dos dados de configuração e do identificador para o Firebase. Se você quiser receber uma confirmação antes de usar o token, é possível impedir a geração dele desativando o FCM (e o Analytics no Android). Para isso, adicione um valor de metadados ao Info.plist, e não ao GoogleService-Info.plist, nas plataformas Apple ou ao AndroidManifest.xml no Android:

<?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>

FirebaseMessagingAutoInitEnabled = NO

Para reativar o FCM, é possível fazer uma chamada de ambiente de execução:

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

Depois de definido, esse valor persiste às reinicializações do app.

Como processar mensagens com links diretos no Android

O FCM permite que sejam enviadas mensagens com um link direto para seu aplicativo. Para receber mensagens que contenham um link direto, é necessário adicionar um novo filtro de intent à atividade que processa links diretos para seu aplicativo. O filtro de intent precisa capturar links diretos do seu domínio. Se as suas mensagens não contiverem um link direto, essa configuração não será necessária. No 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>

Também é possível especificar um caractere curinga para deixar o filtro de intent mais flexível. Por exemplo:

<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>

Quando os usuários tocam em uma notificação que contém um link para o esquema e o host especificados por você, seu aplicativo iniciará a atividade com esse filtro de intent para processar o link.

Próximas etapas

Quando o app cliente estiver configurado, estará tudo pronto para começar a enviar mensagens downstream e mensagens de tópico com o Firebase. Para saber mais, veja essa funcionalidade demonstrada no exemplo de início rápido, que você pode transferir por download, executar e avaliar.

Para adicionar outros comportamentos avançados ao seu app, consulte os guias para envio de mensagens de um servidor de app:

• Enviar mensagens de tópicos
• Enviar a grupos de dispositivos

Saiba que você precisará de uma implementação de servidor para usar esses recursos.