Acompanhe tudo o que foi anunciado no Firebase Summit e saiba como usar o Firebase para acelerar o desenvolvimento de apps e executá-los com confiança. Saiba mais

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

Para escrever seu aplicativo cliente Firebase Cloud Messaging multiplataforma com C++, use a API Firebase Cloud Messaging . O SDK C++ funciona para as plataformas Android e Apple, com algumas configurações adicionais necessárias para cada plataforma.

Configurar o Firebase e o SDK do FCM

Android

  1. Se ainda não o fez, adicione o Firebase ao seu projeto C++ .

    • Nas instruções de configuração vinculadas, revise os requisitos do dispositivo e do aplicativo para usar o Firebase C++ SDK, incluindo a recomendação de usar o CMake para criar seu aplicativo.

    • No arquivo build.gradle no nível do projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects .

  2. Crie um objeto Firebase App, passando o ambiente JNI e a atividade:

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

  3. Defina uma classe que implemente a interface firebase::messaging::Listener .

  4. Inicialize o FCM, passando o App e um Listener construído:

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

  5. Os aplicativos que dependem do SDK do Google Play Services devem verificar se há um APK do Google Play Services compatível no dispositivo antes de acessar os recursos. Para saber mais, consulte Verificar o APK dos serviços do Google Play .

iOS+

  1. Você precisa de um certificado de APNs válido. Se você ainda não tiver um, certifique-se de criar um no Apple Developer Member Center .
  2. Se ainda não o fez, adicione o Firebase ao seu projeto C++ . Em seguida, para configurar seu projeto para o FCM:
    1. No Podfile do seu projeto, adicione a dependência do FCM:
      pod 'FirebaseMessaging'
    2. Arraste as estruturas firebase.framework e firebase_messaging.framework para seu projeto Xcode a partir do Firebase C++ SDK .
  3. Configure seu projeto Xcode para habilitar notificações push:

    1. Selecione o projeto na área do Navegador .
    2. Selecione o destino do projeto na área do Editor .
    3. Selecione a guia Geral na área Editor .

      1. Role para baixo até Estruturas e Bibliotecas Vinculadas e clique no botão + para adicionar estruturas.
      2. Na janela exibida, role até UserNotifications.framework , clique nessa entrada e clique em Adicionar .

        Essa estrutura só aparece no Xcode v8 e posterior e é exigida por esta biblioteca.

    4. Selecione a guia Capacidades na área Editor .

      1. Alterne as notificações por push para Ativado .
      2. Role para baixo até Modos de fundo e mude para Ativado .
      3. Selecione Notificações remotas em Modos de fundo .
  4. Crie um objeto de aplicativo do Firebase:

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

  5. Defina uma classe que implemente a interface firebase::messaging::Listener .

  6. Inicialize o Firebase Cloud Messaging, passando o App e um Listener construído:

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

Acesse o token de registro do dispositivo

Ao inicializar a biblioteca do Firebase Cloud Messaging, um token de registro é solicitado para a instância do aplicativo cliente. O aplicativo receberá o token com o retorno de chamada OnTokenReceived , que deve ser definido na classe que implementa firebase::messaging::Listener .

Se você quiser segmentar esse dispositivo específico, precisará de acesso a esse token.

Nota sobre a entrega de mensagens no Android

Quando o aplicativo não está em execução e um usuário toca em uma notificação, a mensagem não é, por padrão, roteada pelos retornos de chamada integrados do FCM. Nesse caso, as cargas úteis da mensagem são recebidas por meio de um Intent usado para iniciar o aplicativo. Para que o FCM encaminhe essas mensagens de entrada para o retorno de chamada da biblioteca C++, você precisa substituir o método onNewIntent em sua Activity e passar o Intent para o 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 de seu campo de notificação usado para preencher a notificação da bandeja do sistema, mas esse conteúdo de notificação não será comunicado ao FCM. Ou seja, Message::notification será nulo.

Resumindo:

Estado do aplicativo Notificação Dados Ambos
Primeiro plano OnMessageReceived OnMessageReceived OnMessageReceived
Fundo Bandeja do sistema OnMessageReceived Notificação: bandeja do sistema
Dados: em extras da intenção.

Manipulação de mensagens personalizadas no Android

Por padrão, as notificações enviadas ao aplicativo são passadas para ::firebase::messaging::Listener::OnMessageReceived , mas em alguns casos você pode querer substituir o comportamento padrão. Para fazer isso no Android, você precisará escrever classes personalizadas que estendam com.google.firebase.messaging.cpp.ListenerService , bem como atualizar o AndroidManifest.xml do seu projeto.

Substituir os métodos ListenerService .

O ListenerService é a classe Java que intercepta as mensagens recebidas enviadas ao aplicativo e as roteia para a biblioteca C++. Quando o aplicativo estiver em primeiro plano (ou quando o aplicativo estiver em segundo plano e receber uma carga útil somente de dados), as mensagens passarão por um dos retornos de chamada fornecidos nesta classe. Para adicionar um comportamento personalizado ao tratamento de mensagens, você precisará estender o ListenerService padrão do FCM:

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

class MyListenerService extends ListenerService {

Ao substituir o método ListenerService.onMessageReceived , você pode executar ações com base no objeto RemoteMessage recebido e obter 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 substituídos. Para obter mais informações, consulte a referência 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

Depois que suas classes personalizadas forem escritas, elas devem ser incluídas no AndroidManifest.xml para terem efeito. Certifique-se de que o manifesto inclua as ferramentas de mesclagem declarando o atributo apropriado dentro da tag <manifest> , assim:

<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. Esse manifesto normalmente é mesclado com o manifesto específico do projeto, que é como o ListenerService pode ser executado. Este ListenerService precisa ser substituído pelo serviço de ouvinte personalizado. Isso é feito removendo o ListenerService padrão e adicionando o serviço personalizado, o que pode ser feito com as seguintes linhas do arquivo AndroidManifest.xml de seus projetos:

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

Novas versões do Firebase C++ SDK (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 do identificador e dos dados de configuração para o Firebase. Se você deseja obter um opt-in explícito antes de usar o token, pode impedir a geração no momento da configuração desativando o FCM (e no Android, Analytics). Para fazer isso, adicione um valor de metadados ao seu Info.plist (não ao seu GoogleService-Info.plist ) nas plataformas da Apple ou ao seu AndroidManifest.xml no Android:

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>

Rápido

FirebaseMessagingAutoInitEnabled = NO

Para reativar o FCM, você pode fazer uma chamada de tempo de execução:

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

Esse valor persiste nas reinicializações do aplicativo depois de definido.

O FCM permite o envio de mensagens contendo um link direto para seu aplicativo. Para receber mensagens que contêm um link direto, você deve adicionar um novo filtro de intent à atividade que lida com links diretos para seu aplicativo. O filtro de intenção deve capturar links diretos do seu domínio. Se suas mensagens não contiverem um link direto, essa configuração não será necessária. Em 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 curinga para tornar o filtro de intenção 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 contendo um link para o esquema e o host que você especificar, seu aplicativo iniciará a atividade com esse filtro de intent para processar o link.

Próximos passos

Depois de configurar o aplicativo cliente, você está pronto para enviar mensagens downstream e de tópico com o Firebase. Para saber mais, veja esta funcionalidade demonstrada no exemplo de início rápido que você pode baixar, executar e revisar.

Para adicionar outro comportamento mais avançado ao seu aplicativo, consulte os guias para enviar mensagens de um servidor de aplicativos:

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