Notificações por push

Pré-requisitos

Antes de usar este recurso, você precisará integrar o SDK Android Braze.

Recursos integrados

Os recursos a seguir são integrados ao SDK Android da Braze. Para usar qualquer outro recurso de notificação por push, você precisará configurar as notificações por push para o seu app.

Sobre o ciclo de vida da notificação por push

O fluxograma a seguir mostra como a Braze lida com o ciclo de vida da notificação por push, como solicitações de permissão, geração de token e entrega de mensagens.

• concedendo permissões
• gerando tokens de push
• exibindo notificações

---
config:
  theme: neutral
---
flowchart TD

%% Permission flow
subgraph Permission[Push Permissions]
    B{Android version of the device?}
    B -->|Android 13+| C["requestPushPermissionPrompt() called"]
    B -->|Android 12 and earlier| D[No permissions required]

    %% Connect Android 12 path to Braze state
    D --> H3[Braze: user subscription state]
    H3 --> J3[Defaults to 'subscribed' when user profile created]

    C --> E{Did the user grant push permission?}
    E -->|Yes| F[POST_NOTIFICATIONS permission granted]
    E -->|No| G[POST_NOTIFICATIONS permission denied]

    %% Braze subscription state updates
    F --> H1[Braze: user subscription state]
    G --> H2[Braze: user subscription state]

    H1 --> I1{Automatically opt in after permission granted?}
    I1 -->|true| J1[Set to 'opted-in']
    I1 -->|false| J2[Remains 'subscribed']

    H2 --> K1[Remains 'subscribed'<br/>or 'unsubscribed']

    %% Subscription state legend
    subgraph BrazeStates[Braze subscription states]
        L1['Subscribed' - default state<br/>when user profile created]
        L2['Opted-in' - user explicitly<br/>wants push notifications]
        L3['Unsubscribed' - user explicitly<br/>opted out of push]
    end

    %% Note about user-level states
    note1[Note: These states are user-level<br/>and apply across all devices for the user]

    %% Connect states to legend
    J1 -.-> L2
    J2 -.-> L1
    J3 -.-> L1
    K1 -.-> L3
    note1 -.-> BrazeStates
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

---
config:
  theme: neutral
---
flowchart TD

%% Token generation flow
subgraph Token[Token Generation]
    H["Braze SDK initialized"] --> Q{Is FCM auto-registration enabled?}
    Q -->|Yes| L{Is required configuration present?}
    Q -->|No| M[No FCM token generated]
    L -->|Yes| I[Generate FCM token]
    L -->|No| M
    I --> K[Register token with Braze]

    %% Configuration requirements
    subgraph Config[Required configuration]
        N['google-services.json' file is present]
        O['com.google.firebase:firebase-messaging' in gradle]
        P['com.google.gms.google-services' plugin in gradle]
    end

    %% Connect config to check
    N -.-> L
    O -.-> L
    P -.-> L
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

---
config:
  theme: neutral
  fontSize: 10
---
flowchart TD

subgraph Display[Push Display]
    %% Push delivery flow
    W[Push sent to FCM servers] --> X{Did FCM receive push?}
    X -->|App is terminated| Y[FCM cannot deliver push to the app]
    X -->|Delivery conditions met| X1[App receives push from FCM]
    X1 --> X2[Braze SDK receives push]
    X2 --> R[Push type?]

    %% Push Display Flow
    R -->|Standard push| S{Is push permission required?}
    R -->|Silent push| T[Braze SDK processes silent push]
    S -->|Yes| S1{Did the user grant push permission?}
    S -->|No| V[Notification is shown to the user]
    S1 -->|Yes| V
    S1 -->|No| U[Notification is not shown to the user]
end

%% Styling
classDef permissionClass fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef tokenClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px
classDef sdkClass fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef configClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef displayClass fill:#ffebee,stroke:#c62828,stroke-width:2px
classDef deliveryClass fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef brazeClass fill:#e8f5e9,stroke:#2e7d32,stroke-width:3px

class A,B,C,E,F,G permissionClass
class H,I tokenClass
class J,K sdkClass
class N,O,P configClass
class R,S,S1,T,U,V displayClass
class W,X,X1,X2,Y,Z deliveryClass
class H1,H2,H3,I1,J1,J2,J3,K1,L1,L2,L3,note1 brazeClass

Configurando notificações por push

Dica

Para conferir um app de exemplo usando FCM com o SDK Android da Braze, consulte Braze: Firebase Push Sample App.

Limites de frequência

A API do Firebase Cloud Messaging (FCM) tem um limite de frequência padrão de 600.000 solicitações por minuto. Se você atingir esse limite, a Braze tentará novamente automaticamente em alguns minutos. Para solicitar um aumento, entre em contato com o Suporte do Firebase.

Etapa 1: Adicione o Firebase ao seu projeto

Primeiro, adicione o Firebase ao seu projeto Android. Para instruções passo a passo, consulte o guia de configuração do Firebase do Google.

Etapa 2: Adicione o Cloud Messaging às suas dependências

Em seguida, adicione a biblioteca do Cloud Messaging às dependências do seu projeto. No seu projeto Android, abra build.gradle e adicione a seguinte linha ao bloco dependencies.

1
implementation "google.firebase:firebase-messaging:+"

Suas dependências devem ficar semelhantes ao seguinte:

1
2
3
4
dependencies {
  implementation project(':android-sdk-ui')
  implementation "com.google.firebase:firebase-messaging:+"
}

Etapa 3: Ative a API do Firebase Cloud Messaging

No Google Cloud, selecione o projeto que seu app Android está usando e ative a API do Firebase Cloud Messaging.

Etapa 4: Crie uma conta de serviço

Em seguida, crie uma nova conta de serviço para que a Braze possa fazer chamadas de API autorizadas ao registrar tokens FCM. No Google Cloud, acesse Service Accounts e escolha seu projeto. Na página Service Accounts, selecione Create Service Account.

Insira um nome, ID e descrição para a conta de serviço e selecione Create and continue.

No campo Role, encontre e selecione Firebase Cloud Messaging API Admin na lista de funções. Para um acesso mais restritivo, crie uma função personalizada com a permissão cloudmessaging.messages.create e escolha-a na lista. Quando terminar, selecione Done.

Aviso

Certifique-se de selecionar Firebase Cloud Messaging API Admin, e não Firebase Cloud Messaging Admin.

Etapa 5: Gere credenciais JSON

Em seguida, gere credenciais JSON para sua conta de serviço FCM. No Google Cloud IAM & Admin, acesse Service Accounts e escolha seu projeto. Localize a conta de serviço FCM que você criou anteriormente e selecione  Actions > Manage Keys.

Selecione Add Key > Create new key.

Escolha JSON e selecione Create. Se você criou sua conta de serviço usando um ID de projeto do Google Cloud diferente do ID do seu projeto FCM, será necessário atualizar manualmente o valor atribuído a project_id no seu arquivo JSON.

Lembre-se de onde você baixou a chave—você precisará dela na próxima etapa.

Aviso

Chaves privadas podem representar um risco de segurança se comprometidas. Armazene suas credenciais JSON em um local seguro por enquanto—você excluirá sua chave após enviá-la para a Braze.

Etapa 6: Envie suas credenciais JSON para a Braze

Em seguida, envie suas credenciais JSON para o dashboard da Braze. Na Braze, selecione  Settings > App Settings.

Em Push Notification Settings do seu app Android, escolha Firebase, selecione Upload JSON File e envie as credenciais que você gerou anteriormente. Quando terminar, selecione Save.

Aviso

Chaves privadas podem representar um risco de segurança se comprometidas. Agora que sua chave foi enviada para a Braze, exclua o arquivo que você gerou anteriormente.

Etapa 7: Configure o registro automático de tokens

Quando um dos seus usuários aceitar receber notificações por push, seu app precisa gerar um token FCM no dispositivo dele antes que você possa enviar notificações por push. Com o SDK da Braze, você pode ativar o registro automático de tokens FCM para o dispositivo de cada usuário nos arquivos de configuração da Braze do seu projeto.

Primeiro, acesse o Firebase Console, abra seu projeto e selecione  Settings > Project settings.

Selecione Cloud Messaging e, em Firebase Cloud Messaging API (V1), copie o número no campo Sender ID.

Em seguida, abra seu projeto no Android Studio e use seu Firebase Sender ID para ativar o registro automático de tokens FCM no seu braze.xml ou BrazeConfig.

• braze.xml
• brazeconfig

1
2
<bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">FIREBASE_SENDER_ID</string>

1
2
3
4
5
6
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string translatable="false" name="com_braze_api_key">12345ABC-6789-DEFG-0123-HIJK456789LM</string>
  <bool translatable="false" name="com_braze_firebase_cloud_messaging_registration_enabled">true</bool>
<string translatable="false" name="com_braze_firebase_cloud_messaging_sender_id">603679405392</string>
</resources>

1
2
.setIsFirebaseCloudMessagingRegistrationEnabled(true)
.setFirebaseCloudMessagingSenderIdKey("FIREBASE_SENDER_ID")

1
2
.setIsFirebaseCloudMessagingRegistrationEnabled(true)
.setFirebaseCloudMessagingSenderIdKey("FIREBASE_SENDER_ID")

1
2
3
4
5
6
7
8
9
10
BrazeConfig brazeConfig = new BrazeConfig.Builder()
  .setApiKey("12345ABC-6789-DEFG-0123-HIJK456789LM")
  .setCustomEndpoint("sdk.iad-01.braze.com")
  .setSessionTimeout(60)
  .setHandlePushDeepLinksAutomatically(true)
  .setGreatNetworkDataFlushInterval(10)
  .setIsFirebaseCloudMessagingRegistrationEnabled(true)
  .setFirebaseCloudMessagingSenderIdKey("603679405392")
  .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5
6
7
8
9
10
val brazeConfig = BrazeConfig.Builder()
  .setApiKey("12345ABC-6789-DEFG-0123-HIJK456789LM")
  .setCustomEndpoint("sdk.iad-01.braze.com")
  .setSessionTimeout(60)
  .setHandlePushDeepLinksAutomatically(true)
  .setGreatNetworkDataFlushInterval(10)
  .setIsFirebaseCloudMessagingRegistrationEnabled(true)
  .setFirebaseCloudMessagingSenderIdKey("603679405392")
  .build()
Braze.configure(this, brazeConfig)

Dica

Se preferir registrar tokens FCM manualmente, defina a propriedade registeredPushToken na instância da Braze dentro do método onCreate() do seu app.

1
2
// Kotlin
Braze.getInstance(context).registeredPushToken = "FCM_TOKEN"

1
2
// Java
Braze.getInstance(context).setRegisteredPushToken("FCM_TOKEN");

Usando múltiplos projetos Firebase

Se seu app usa múltiplos projetos Firebase, siga estas etapas:

1. Mantenha o push da Braze no projeto Firebase padrão inicializado a partir do google-services.json do seu app.
2. Se você usa um serviço de mensagens Firebase personalizado, conclua Registrar IDs de instalação em serviços de mensagens Firebase personalizados.
3. Se seu app obtém um token por push de outra forma, defina manualmente registeredPushToken conforme mostrado na dica anterior.

Importante

O Firebase Cloud Messaging não possui uma API compatível para recuperar um token de um FirebaseApp que você inicializa manualmente. Callbacks do FirebaseMessagingService, como onNewToken e onRegistered, só são disparados para o projeto padrão. Para saber mais, consulte Configure multiple projects na documentação do Firebase.

Para detalhes de versão, consulte os changelogs do SDK.

Etapa 8: Remova solicitações automáticas na classe da sua aplicação

Para evitar que a Braze dispare solicitações de rede desnecessárias toda vez que você enviar notificações por push silenciosas, remova quaisquer solicitações de rede automáticas configuradas no método onCreate() da classe Application. Para saber mais, consulte Android Developer Reference: Application.

Exibindo notificações

Etapa 1: Registrar o Braze Firebase Messaging Service

Você pode criar um Firebase Messaging Service novo, existente ou que não seja da Braze. Escolha o que melhor atender às suas necessidades específicas.

• novo
• existente
• não braze

A Braze inclui um serviço para lidar com o recebimento de push e intents de abertura. Nossa classe BrazeFirebaseMessagingService precisará ser registrada no seu AndroidManifest.xml:

1
2
3
4
5
6
<service android:name="com.braze.push.BrazeFirebaseMessagingService"
  android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT" />
  </intent-filter>
</service>

Nosso código de notificação também usa BrazeFirebaseMessagingService para lidar com o rastreamento de ações de abertura e clique. Esse serviço deve ser registrado no AndroidManifest.xml para funcionar corretamente. Além disso, lembre-se de que a Braze prefixa as notificações do nosso sistema com uma chave exclusiva para que apenas as notificações enviadas pelos nossos sistemas sejam renderizadas. Você pode registrar serviços adicionais separadamente para renderizar notificações enviadas por outros serviços FCM. Consulte AndroidManifest.xml no app de exemplo de push do Firebase.

Importante

Antes do SDK da Braze 3.1.1, o AppboyFcmReceiver era usado para lidar com push do FCM. A classe AppboyFcmReceiver deve ser removida do seu manifesto e substituída pela integração anterior.

Se você já tiver um Firebase Messaging Service registrado, poderá passar objetos RemoteMessage para a Braze via BrazeFirebaseMessagingService.handleBrazeRemoteMessage(). Esse método só exibirá uma notificação se o objeto RemoteMessage tiver sido originado da Braze e será ignorado com segurança caso contrário.

Registrar IDs de instalação em serviços Firebase Messaging personalizados

Se você estiver usando firebase-messaging v25.1.0 ou posterior, o registro do Firebase usa o Firebase Installation ID. No seu serviço Firebase Messaging personalizado, sobrescreva onRegistered e defina registeredPushToken.

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MyFirebaseMessagingService extends FirebaseMessagingService {
  @Override
  public void onRegistered(String installationId) {
    super.onRegistered(installationId);
    Braze.getInstance(this).setRegisteredPushToken(installationId);
  }

  @Override
  public void onMessageReceived(RemoteMessage remoteMessage) {
    super.onMessageReceived(remoteMessage);
    if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
      // This Remote Message originated from Braze and a push notification was displayed.
      // No further action is needed.
    } else {
      // This Remote Message did not originate from Braze.
      // No action was taken and you can safely pass this Remote Message to other handlers.
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyFirebaseMessagingService : FirebaseMessagingService() {
  override fun onRegistered(installationId: String) {
    super.onRegistered(installationId)
    Braze.getInstance(this).registeredPushToken = installationId
  }

  override fun onMessageReceived(remoteMessage: RemoteMessage?) {
    super.onMessageReceived(remoteMessage)
    if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
      // This Remote Message originated from Braze and a push notification was displayed.
      // No further action is needed.
    } else {
      // This Remote Message did not originate from Braze.
      // No action was taken and you can safely pass this Remote Message to other handlers.
    }
  }
}

Se você tiver outro Firebase Messaging Service que também gostaria de usar, poderá especificar um Firebase Messaging Service de fallback para ser chamado caso seu aplicativo receba um push que não seja da Braze.

No seu braze.xml, especifique:

1
2
<bool name="com_braze_fallback_firebase_cloud_messaging_service_enabled">true</bool>
<string name="com_braze_fallback_firebase_cloud_messaging_service_classpath">com.company.OurFirebaseMessagingService</string>

ou defina via configuração em tempo de execução:

• java
• kotlin

1
2
3
4
5
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setFallbackFirebaseMessagingServiceEnabled(true)
        .setFallbackFirebaseMessagingServiceClasspath("com.company.OurFirebaseMessagingService")
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5
val brazeConfig = BrazeConfig.Builder()
        .setFallbackFirebaseMessagingServiceEnabled(true)
        .setFallbackFirebaseMessagingServiceClasspath("com.company.OurFirebaseMessagingService")
        .build()
Braze.configure(this, brazeConfig)

Etapa 2: Adequar ícones pequenos às diretrizes de design

Para informações gerais sobre ícones de notificação do Android, consulte a Visão geral de notificações.

A partir do Android N, você deve atualizar ou remover ativos de ícones de notificação pequenos que envolvam cores. O sistema Android (não o SDK da Braze) ignora todos os canais não alfa e de transparência em ícones de ação e no ícone pequeno de notificação. Em outras palavras, o Android converterá todas as partes do seu ícone pequeno de notificação para monocromático, exceto as regiões transparentes.

Para criar um ativo de ícone pequeno de notificação que seja exibido corretamente:

• Remova todas as cores da imagem, exceto o branco.
• Todas as outras regiões não brancas do ativo devem ser transparentes.

Nota

Um sintoma comum de um ativo inadequado é o ícone pequeno de notificação sendo renderizado como um quadrado monocromático sólido. Isso ocorre porque o sistema Android não consegue encontrar nenhuma região transparente no ativo do ícone pequeno de notificação.

Os ícones grandes e pequenos a seguir são exemplos de ícones projetados corretamente:

Etapa 3: Configurar ícones de notificação

Especificando ícones no braze.xml

A Braze permite que você configure seus ícones de notificação especificando recursos drawable no seu braze.xml:

1
2
<drawable name="com_braze_push_small_notification_icon">REPLACE_WITH_YOUR_ICON</drawable>
<drawable name="com_braze_push_large_notification_icon">REPLACE_WITH_YOUR_ICON</drawable>

Definir um ícone pequeno de notificação é obrigatório. Se você não definir um, a Braze usará o ícone do aplicativo como ícone pequeno de notificação por padrão, o que pode não ter uma aparência ideal.

Definir um ícone grande de notificação é opcional, mas recomendado.

Especificando a cor de destaque do ícone

A cor de destaque do ícone de notificação pode ser substituída no seu braze.xml. Se a cor não for especificada, a cor padrão será o mesmo cinza que o Lollipop usa para notificações do sistema.

1
<integer name="com_braze_default_notification_accent_color">0xFFf33e3e</integer>

Você também pode usar opcionalmente uma referência de cor:

1
<color name="com_braze_default_notification_accent_color">@color/my_color_here</color>

Etapa 4: Adicionar deep links

Ativando a abertura automática de deep links

Para permitir que a Braze abra automaticamente seu app e quaisquer deep links quando uma notificação por push for clicada, defina com_braze_handle_push_deep_links_automatically como true no seu braze.xml:

1
<bool name="com_braze_handle_push_deep_links_automatically">true</bool>

Esse flag também pode ser definido via configuração em tempo de execução:

• java
• kotlin

1
2
3
4
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4
val brazeConfig = BrazeConfig.Builder()
        .setHandlePushDeepLinksAutomatically(true)
        .build()
Braze.configure(this, brazeConfig)

Se você quiser lidar com deep links de forma personalizada, precisará criar um retorno de chamada de push que escute intents de push recebidos e abertos da Braze. Para saber mais, consulte Usando um retorno de chamada para eventos de push.

Tratamento de notificações em primeiro plano

Por padrão, quando uma notificação por push chega enquanto seu app está em primeiro plano no Android, o sistema a exibe automaticamente. Para que a Braze processe a carga útil da notificação por push (para rastreamento de análise de dados, tratamento de deep links e processamento personalizado), encaminhe os dados de push recebidos para a Braze dentro do seu método FirebaseMessagingService.onMessageReceived.

Como funciona

Quando você chama BrazeFirebaseMessagingService.handleBrazeRemoteMessage, a Braze determina se a carga útil é uma notificação por push da Braze e, em caso afirmativo, cria e exibe a notificação com o método NotificationManagerCompat. Diferentemente do iOS, o Android exibe notificações independentemente de o app estar em primeiro plano ou em segundo plano.

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.example.push;

import com.braze.push.BrazeFirebaseMessagingService;
import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class MyFirebaseMessagingService extends FirebaseMessagingService {
    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        super.onMessageReceived(remoteMessage);

        // Let Braze process the payload and display the notification
        if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
            // Braze successfully handled the push notification
        } else {
            // Handle non-Braze messages
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.example.push

import com.braze.push.BrazeFirebaseMessagingService
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage

class MyFirebaseMessagingService : FirebaseMessagingService() {
    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)

        // Let Braze process the payload and display the notification
        if (BrazeFirebaseMessagingService.handleBrazeRemoteMessage(this, remoteMessage)) {
            // Braze successfully handled the push notification
        } else {
            // Handle non-Braze messages
        }
    }
}

Para saber mais, consulte o exemplo de integração com Firebase no repositório do SDK Android da Braze.

Personalização do comportamento em primeiro plano

Se você deseja um comportamento personalizado em primeiro plano, como suprimir a notificação do sistema ou exibir uma interface no app, você pode:

• Usar subscribeToPushNotificationEvents para reagir a eventos de push e tratar deep links com o método BrazeNotificationUtils.routeUserWithNotificationOpenedIntent. Para saber mais, consulte o exemplo de push com Firebase.
• Criar e publicar sua própria notificação usando um IBrazeNotificationFactory personalizado, ou suprimir a notificação não chamando notificationManager.notify no seu fluxo de tratamento.

Para saber mais sobre personalização de notificações, consulte Fábrica de notificações personalizada.

Criação de deep links personalizados

Siga as instruções encontradas na documentação para desenvolvedores Android sobre deep linking, caso ainda não tenha adicionado deep links ao seu app. Para saber mais sobre o que são deep links, consulte nosso artigo de perguntas frequentes.

Adição de deep links

O dashboard da Braze permite configurar deep links ou URLs da web em Campaigns de notificação por push e Canvas que serão abertos quando a notificação for clicada.

Personalização do comportamento da pilha de retorno

O SDK Android, por padrão, colocará a activity principal do launcher do seu app na pilha de retorno ao seguir deep links de push. A Braze permite que você defina uma activity personalizada para abrir na pilha de retorno no lugar da activity principal do launcher, ou desative a pilha de retorno completamente.

Por exemplo, para definir uma activity chamada YourMainActivity como a activity da pilha de retorno usando a configuração em tempo de execução:

• java
• kotlin

1
2
3
4
5
BrazeConfig brazeConfig = new BrazeConfig.Builder()
        .setPushDeepLinkBackStackActivityEnabled(true)
        .setPushDeepLinkBackStackActivityClass(YourMainActivity.class)
        .build();
Braze.configure(this, brazeConfig);

1
2
3
4
5
val brazeConfig = BrazeConfig.Builder()
        .setPushDeepLinkBackStackActivityEnabled(true)
        .setPushDeepLinkBackStackActivityClass(YourMainActivity.class)
        .build()
Braze.configure(this, brazeConfig)

Consulte a configuração equivalente para o seu braze.xml. Observe que o nome da classe deve ser o mesmo retornado por Class.forName().

1
2
<bool name="com_braze_push_deep_link_back_stack_activity_enabled">true</bool>
<string name="com_braze_push_deep_link_back_stack_activity_class_name">your.package.name.YourMainActivity</string>

Etapa 5: Definir canais de notificação

O SDK Android da Braze oferece suporte a canais de notificação do Android. Se uma notificação da Braze não contiver o ID de um canal de notificação ou contiver um ID de canal inválido, a Braze exibirá a notificação com o canal de notificação padrão definido no SDK. Os usuários da empresa usam os Canais de notificação do Android na plataforma para agrupar notificações.

Para definir o nome do canal de notificação padrão da Braze visível ao usuário, use BrazeConfig.setDefaultNotificationChannelName().

Para definir a descrição do canal de notificação padrão da Braze visível ao usuário, use BrazeConfig.setDefaultNotificationChannelDescription().

Atualize quaisquer Campaigns de API com o parâmetro do objeto de push Android para incluir o campo notification_channel. Se esse campo não for especificado, a Braze enviará a carga útil da notificação com o ID do canal de fallback do dashboard.

Além do canal de notificação padrão, a Braze não criará nenhum canal. Todos os outros canais devem ser definidos programaticamente pelo app host e, em seguida, inseridos no dashboard da Braze.

O nome e a descrição do canal padrão também podem ser configurados no braze.xml.

1
2
<string name="com_braze_default_notification_channel_name">Your channel name</string>
<string name="com_braze_default_notification_channel_description">Your channel description</string>

Etapa 6: Testar a exibição e a análise de dados das notificações

Teste de exibição

Neste ponto, você já deve conseguir ver as notificações enviadas pela Braze. Para testar, acesse a página Campaigns no dashboard da Braze e crie uma Campaign de Push Notification. Escolha Android Push e crie sua mensagem. Em seguida, clique no ícone de olho no criador para acessar o remetente de teste. Insira o ID de usuário ou o endereço de e-mail do seu usuário atual e clique em Send Test. Você deverá ver a notificação por push aparecer no seu dispositivo.

Para problemas relacionados à exibição de push, consulte nosso guia de solução de problemas.

Teste de análise de dados

Neste ponto, você também deve ter o registro de análise de dados para aberturas de notificações por push. Clicar na notificação quando ela chegar deve fazer com que o valor de Aberturas Diretas na página de resultados da sua Campaign aumente em 1. Consulte nosso artigo sobre relatórios de push para um detalhamento da análise de dados de push.

Para problemas relacionados à análise de dados de push, consulte nosso guia de solução de problemas.

Teste pela linha de comando

Se você quiser testar notificações no app e notificações por push pela interface de linha de comando, pode enviar uma única notificação pelo terminal via cURL e a API de envio de mensagens. Você precisará substituir os seguintes campos pelos valores corretos para o seu caso de teste:

• YOUR_API_KEY (Acesse Settings > API Keys.)
• YOUR_EXTERNAL_USER_ID (Pesquise um perfil na página Search Users.)
• YOUR_KEY1 (opcional)
• YOUR_VALUE1 (opcional)

1
2
3
4
5
6
7
8
9
10
11
12
curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer {YOUR_API_KEY}" -d '{
  "external_user_ids":["YOUR_EXTERNAL_USER_ID"],
  "messages": {
    "android_push": {
      "title":"Test push title",
      "alert":"Test push",
      "extra": {
        "YOUR_KEY1":"YOUR_VALUE1"
      }
    }
  }
}' https://rest.iad-01.braze.com/messages/send

Este exemplo usa a instância US-01. Se você não estiver nessa instância, substitua o endpoint US-01 pelo seu endpoint.

Notificações por push de conversa

A iniciativa de pessoas e conversas é uma iniciativa de vários anos do Android que visa elevar pessoas e conversas nas superfícies do sistema do telefone. Essa prioridade é baseada no fato de que a comunicação e a interação com outras pessoas ainda é a área funcional mais valorizada e importante para a maioria dos usuários do Android em todos os perfis demográficos.

Requisitos de uso

• Esse tipo de notificação requer o SDK Android da Braze v15.0.0+ e dispositivos com Android 11+.
• Dispositivos ou SDKs não compatíveis farão fallback para uma notificação por push padrão.

Esse recurso está disponível apenas pela REST API da Braze. Consulte o objeto push do Android para saber mais.

Erros de cota excedida do FCM

Quando o limite do Firebase Cloud Messaging (FCM) é excedido, o Google retorna erros de “cota excedida”. O limite padrão do FCM é de 600.000 solicitações por minuto. A Braze tenta reenviar seguindo as práticas recomendadas pelo Google. No entanto, um grande volume desses erros pode prolongar o tempo de envio em vários minutos. Para mitigar o impacto potencial, a Braze enviará um alerta informando que o limite de frequência está sendo excedido e as etapas que você pode seguir para evitar os erros.

Para verificar seu limite atual, acesse Google Cloud Console > APIs & Services > Firebase Cloud Messaging API > Quotas & System Limits, ou visite a página de cotas da API do FCM.

Práticas recomendadas

Recomendamos estas práticas para manter o volume desses erros baixo.

Solicitar um aumento de limite de frequência ao FCM

Para solicitar um aumento de limite de frequência ao FCM, você pode entrar em contato diretamente com o Suporte do Firebase ou fazer o seguinte:

1. Acesse a página de cotas da API do FCM.
2. Localize a cota Send requests per minute.
3. Selecione Edit Quota.
4. Insira um novo valor e envie sua solicitação.

Aplicar um limite de frequência no espaço de trabalho

Você pode aplicar um limite de frequência no espaço de trabalho para notificações por push do Android. Isso pode ajudar a regular a taxa de entrega das suas mensagens enviadas. Para saber mais, consulte Limites de frequência de envio de mensagens do espaço de trabalho.