Notificações por push

Pré-requisitos

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

Recursos integrados

Os seguintes recursos estã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 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 da Braze para Android, veja 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 requisiçõ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 Firebase Support.

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 o build.gradle e adicione a seguinte linha ao bloco dependencies.

1

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

Suas dependências devem ficar parecidas com o 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 Firebase Cloud Messaging API.

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 papéis. Para um acesso mais restrito, crie um papel personalizado com a permissão cloudmessaging.messages.create e escolha-o 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 fazer o upload para a Braze.

Etapa 6: Faça upload das suas credenciais JSON na Braze

Em seguida, faça upload das suas credenciais JSON no dashboard da Braze. Na Braze, selecione  Settings > App Settings.

Em Push Notification Settings do seu app Android, escolha Firebase, selecione Upload JSON File e faça upload das 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 notificações por push, seu app precisa gerar um token FCM no dispositivo dele antes de você poder enviar notificações por push. Com o SDK da Braze, você pode ativar o registro automático de tokens FCM para cada dispositivo de 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 o Sender ID do Firebase 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 você 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 vários projetos Firebase

Se o seu app usa vários 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 a etapa Registrar IDs de instalação em serviços de mensagens Firebase personalizados.
3. Se o 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 tem API com suporte para recuperar um token de um FirebaseApp que você inicializa manualmente. Callbacks do FirebaseMessagingService como onNewToken e onRegistered só são acionados 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 requisições automáticas na sua classe Application

Para evitar que a Braze dispare requisições de rede desnecessárias toda vez que você enviar notificações por push silenciosas, remova quaisquer requisições de rede automáticas configuradas no método onCreate() da sua 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 não Braze. Escolha o que melhor atende às suas necessidades.

• 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 precisa 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 renderizemos apenas notificações enviadas pelos nossos sistemas. Você pode registrar serviços adicionais separadamente para renderizar notificações enviadas por outros serviços FCM. Consulte o 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á tem um Firebase Messaging Service registrado, pode 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 Installation IDs em serviços Firebase Messaging personalizados

Se você está usando o 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ê tem outro Firebase Messaging Service que também gostaria de usar, pode 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 os í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 os ativos de ícones pequenos de notificação 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 í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 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 ser 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 grande e pequeno a seguir são exemplos de ícones projetados corretamente:

Etapa 3: Configurar os í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 uma referência de cor opcionalmente:

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 os intents de push recebido e aberto 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 o 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álises, 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, se for, 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 Firebase no repositório do SDK Android da Braze.

Personalização do comportamento em primeiro plano

Se você quiser personalizar o comportamento 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 Firebase.
• Criar e publicar sua própria notificação usando um IBrazeNotificationFactory personalizado, ou suprimir a notificação ao não chamar notificationManager.notify no seu fluxo de tratamento.

Para saber mais sobre personalização de notificações, consulte Fábrica de notificação 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 suporta a configuração de deep links ou URLs 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 back stack

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

Por exemplo, para definir uma activity chamada YourMainActivity como a activity da back stack 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)

Veja a configuração equivalente no seu braze.xml. 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 suporta 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 visível ao usuário do canal de notificação padrão da Braze, use BrazeConfig.setDefaultNotificationChannelName().

Para definir a descrição visível ao usuário do canal de notificação padrão da Braze, 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 então inseridos no dashboard da Braze.

O nome e a descrição padrão do canal 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 exibição e análises de notificações

Teste de exibição

Neste ponto, você deve conseguir ver 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 projete sua mensagem. Em seguida, clique no ícone de olho no criador para abrir o remetente de teste. Insira o ID de usuário ou endereço de e-mail do seu usuário atual e clique em Send Test. Você deve 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álises

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

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

Teste via linha de comando

Se você quiser testar notificações no app e notificações por push via interface de linha de comando, pode enviar uma única notificação pelo terminal usando 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 (Acessar 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 está nesta 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 longo prazo 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 para 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 as mensagens 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 medidas que você pode tomar 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 com o Suporte do Firebase diretamente 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.