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

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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

Configure o Firebase e o FCM SDK

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 de dispositivo e aplicativo para usar o Firebase C++ SDK, incluindo a recomendação de usar o CMake para criar seu aplicativo.

    • Em seu arquivo build.gradle de nível de projeto, certifique-se de incluir o repositório Maven do Google em ambas as seções buildscript e allprojects .

  2. Crie um objeto Firebase App, passando no ambiente JNI e Activity:

    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 de serviços do Google Play devem verificar se há um APK de serviços do Google Play 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 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 FCM:
      pod 'FirebaseMessaging'
    2. Arraste os frameworks firebase.framework e firebase_messaging.framework para seu projeto Xcode 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 do Editor .

      1. Role para baixo até Estruturas e bibliotecas vinculadas e clique no botão + para adicionar estruturas.
      2. Na janela que aparece, vá 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 do Editor .

      1. Alterne as notificações por push para ativado .
      2. Role para baixo até Modos de segundo plano e, em seguida, mude para Ativado .
      3. Selecione Notificações remotas em Modos de segundo plano .
  4. Crie um objeto Firebase App:

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

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

  6. Inicialize o Firebase Cloud Messaging, transmitindo o aplicativo e um ouvinte construído:

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

Acesse o token de registro do dispositivo

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

Se você deseja segmentar esse dispositivo específico, precisará acessar 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 por meio de retornos de chamada integrados 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 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: nos extras da intenção.

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

Substitua os métodos ListenerService .

O ListenerService é a classe Java que intercepta as mensagens recebidas enviadas ao aplicativo e as encaminha para a biblioteca C++. Quando o aplicativo está em primeiro plano (ou quando o aplicativo está em segundo plano e recebe uma carga 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 {

Substituindo 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 entrarem em vigor. 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 padrão ListenerService 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 escuta 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 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>

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 carrega o identificador e os 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 GoogleService-Info.plist ) nas plataformas Apple ou ao 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 que mensagens sejam enviadas contendo um link direto para seu aplicativo. Para receber mensagens que contenham um link direto, você deve adicionar um novo filtro de intenção à 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 é 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 intenção para lidar com 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 envio de mensagens de um servidor de aplicativos:

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