Para escrever seu aplicativo cliente Firebase Cloud Messaging multiplataforma com C++, use a API Firebase Cloud Messaging . O SDK C++ funciona para plataformas Android e Apple, com algumas configurações adicionais necessárias para cada plataforma.
Configure o Firebase e o SDK do FCM
Android
Adicione o Firebase ao seu projeto C++ , caso ainda não o tenha feito.
Nas instruções de configuração vinculadas, revise os requisitos do dispositivo e do aplicativo para usar o SDK C++ do Firebase, incluindo a recomendação de usar o CMake para criar seu aplicativo.
No arquivo
build.gradleno nível do projeto, certifique-se de incluir o repositório Maven do Google nas seçõesbuildscripteallprojects.
Crie um objeto Firebase App, passando o ambiente JNI e a atividade:
app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);
Defina uma classe que implemente a interface
firebase::messaging::Listener.Inicialize o FCM, passando o App e um Listener construído:
::firebase::messaging::Initialize(app, listener);
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 APK do Google Play Services .
iOS+
- Você precisa de um certificado APNs válido. Se você ainda não tiver um, crie um no Apple Developer Member Center .
- Adicione o Firebase ao seu projeto C++ , caso ainda não o tenha feito. Então, para configurar seu projeto para FCM:
- No Podfile do seu projeto, adicione a dependência FCM:
pod 'FirebaseMessaging'
- Arraste as estruturas
firebase.frameworkefirebase_messaging.frameworkpara seu projeto Xcode a partir do SDK C++ do Firebase .
- No Podfile do seu projeto, adicione a dependência FCM:
Configure seu projeto Xcode para habilitar notificações push:
- Selecione o projeto na área Navegador .
- Selecione o destino do projeto na área do Editor .
Selecione a guia Geral na área Editor .
- Role para baixo até Linked Frameworks and Libraries e clique no botão + para adicionar frameworks.
Na janela que aparece, vá até UserNotifications.framework , clique nessa entrada e clique em Adicionar .
Esta estrutura aparece apenas no Xcode v8 e posterior e é exigida por esta biblioteca.
Selecione a guia Capacidades na área Editor .
- Mude as notificações push para ativado .
- Role para baixo até Modos de fundo e mude para Ligado .
- Selecione Notificações remotas em Modos de segundo plano .
Crie um objeto de aplicativo do Firebase:
app = ::firebase::App::Create(::firebase::AppOptions());
Defina uma classe que implemente a interface
firebase::messaging::Listener.Inicialize o Firebase Cloud Messaging, passando o aplicativo e um ouvinte 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 quiser atingir esse dispositivo específico, você precisará de acesso a esse token.
Nota sobre 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 dos retornos de chamada integrados do FCM. Nesse caso, as cargas úteis das mensagens são recebidas 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 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 na bandeja do sistema, mas esse conteúdo da 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. |
Tratamento de mensagens personalizado 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 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 ú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 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 possui 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 do 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 deverão 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 ListenerService padrão do FCM. Este 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 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 quiser obter uma aceitação explícita antes de usar o token, você pode impedir a geração no momento da configuração desativando o FCM (e no Android, o Analytics). Para fazer isso, adicione um valor de metadados ao seu Info.plist (não ao seu GoogleService-Info.plist ) nas plataformas 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, uma vez definido.
Tratamento de mensagens com links diretos no Android
O FCM permite o envio de mensagens contendo um link direto para seu aplicativo. Para receber mensagens que contenham um link direto, você deve adicionar um novo filtro de intent à atividade que gerencia 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ções 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 host especificados, seu aplicativo iniciará a atividade com esse filtro de intent para processar o link.
Próximos passos
Depois de configurar o aplicativo cliente, você estará pronto para enviar mensagens downstream e de tópico com o Firebase. Para saber mais, consulte 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.