Personalização das notificações por push

Pré-requisitos

Antes de poder usar esse recurso, você precisará integrar o Android Braze SDK. Você também precisará configurar notificações por push.

Uso de um retorno de chamada para eventos push

A Braze fornece um retorno de chamada subscribeToPushNotificationEvents() para quando notificações por push são recebidas, abertas ou descartadas. Recomenda-se colocar este retorno de chamada no seu Application.onCreate() para não perder nenhum evento que ocorra enquanto seu aplicativo não estiver em execução.

• java
• kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Braze.getInstance(context).subscribeToPushNotificationEvents(event -> {
  final BrazeNotificationPayload parsedData = event.getNotificationPayload();

  //
  // The type of notification itself
  //
  final boolean isPushOpenEvent = event.getEventType() == BrazePushEventType.NOTIFICATION_OPENED;
  final boolean isPushReceivedEvent = event.getEventType() == BrazePushEventType.NOTIFICATION_RECEIVED;
  // Sent when a user has dismissed a notification
  final boolean isPushDeletedEvent = event.getEventType() == BrazePushEventType.NOTIFICATION_DELETED;

  //
  // Notification data
  //
  final String pushTitle = parsedData.getTitleText();
  final Long pushArrivalTimeMs = parsedData.getNotificationReceivedTimestampMillis();
  final String deeplink = parsedData.getDeeplink();

  //
  // Custom KVP data
  //
  final String myCustomKvp1 = parsedData.getBrazeExtras().getString("my first kvp");
  final String myCustomKvp2 = parsedData.getBrazeExtras().getString("my second kvp");
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Braze.getInstance(context).subscribeToPushNotificationEvents { event ->
    val parsedData = event.notificationPayload

    //
    // The type of notification itself
    //
    val isPushOpenEvent = event.eventType == BrazePushEventType.NOTIFICATION_OPENED
    val isPushReceivedEvent = event.eventType == BrazePushEventType.NOTIFICATION_RECEIVED
    // Sent when a user has dismissed a notification
    val isPushDeletedEvent = event.eventType == BrazePushEventType.NOTIFICATION_DELETED

    //
    // Notification data
    //
    val pushTitle = parsedData.titleText
    val pushArrivalTimeMs = parsedData.notificationReceivedTimestampMillis
    val deeplink = parsedData.deeplink

    //
    // Custom KVP data
    //
    val myCustomKvp1 = parsedData.brazeExtras.getString("my first kvp")
    val myCustomKvp2 = parsedData.brazeExtras.getString("my second kvp")
}

Personalização de fontes

Etapa 1: Criar uma família de fontes

A seguir, um exemplo de definição de família de fontes personalizada usando o guia de família de fontes. Para este exemplo, usamos a fonte Bungee Shade.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android"
             xmlns:app="http://schemas.android.com/apk/res-auto">

  <!--Note: You must declare both sets of attributes
      so that your fonts load on devices running Android 8.0 (API level 26) or lower.
      See https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html -->

  <font android:fontStyle="normal"
        android:fontWeight="400"
        android:font="@font/bungeeshade"

        app:fontStyle="normal"
        app:fontWeight="400"
        app:font="@font/bungeeshade"/>
</font-family>

Depois de armazenar a definição da família de fontes em /res/font/bungee_font_family.xml, podemos fazer referência a ela em XML como @font/bungee_font_family.

Etapa 2: Faça referência à sua família de fontes

Agora que a família de fontes foi criada, você pode substituir os padrões de estilo do Braze em seu site styles.xml para incluir referências à família de fontes.

Por exemplo, a seguinte substituição de estilos usaria a família de fontes bungee para todas as mensagens no app do Braze.

1
2
3
4
5
6
7
8
9
<style name="Braze.InAppMessage">
  <item name="android:fontFamily">@font/bungee_font_family</item>
  <item name="fontFamily">@font/bungee_font_family</item>
</style>

<style name="Braze.Cards">
  <item name="android:fontFamily">@font/another_custom_font_family</item>
  <item name="fontFamily">@font/another_custom_font_family</item>
</style>

Personalização da exibição de notificações

Etapa 1: Crie sua fábrica de notificações personalizada

Em alguns cenários, você pode querer personalizar as notificações por push de maneiras que seriam complicadas ou não estariam disponíveis no lado do servidor. Para que você tenha controle total sobre a exibição de notificações, adicionamos a capacidade de definir seus próprios IBrazeNotificationFactory para criar objetos de notificação para serem exibidos pelo Braze.

Se um IBrazeNotificationFactory personalizado for definido, o Braze chamará o método createNotification() de sua fábrica no recebimento do push antes que a notificação seja exibida ao usuário. O Braze transmitirá um Bundle contendo dados de envio do Braze e outro Bundle contendo pares de chave-valor personalizados enviados por meio do dashboard ou das APIs de envio de mensagens:

O Braze passará um arquivo BrazeNotificationPayload contendo dados da notificação por push da Braze.

• java
• kotlin

1
2
3
4
5
6
7
8
9
// Factory method implemented in your custom IBrazeNotificationFactory
@Override
public Notification createNotification(BrazeNotificationPayload brazeNotificationPayload) {
  // Example of getting notification title
  String title = brazeNotificationPayload.getTitleText();

  // Example of retrieving a custom KVP ("my_key" -> "my_value")
  String customKvp = brazeNotificationPayload.getBrazeExtras().getString("my_key");
}

1
2
3
4
5
6
7
8
// Factory method implemented in your custom IBrazeNotificationFactory
override fun createNotification(brazeNotificationPayload: BrazeNotificationPayload): Notification {
  // Example of getting notification title
  val title = brazeNotificationPayload.getTitleText()

  // Example of retrieving a custom KVP ("my_key" -> "my_value")
  val customKvp = brazeNotificationPayload.getBrazeExtras().getString("my_key")
}

Você pode retornar null de seu método personalizado createNotification() para não mostrar a notificação, usar BrazeNotificationFactory.getInstance().createNotification() para obter nosso objeto padrão notification para esses dados e modificá-lo antes da exibição ou gerar um objeto notification completamente separado para exibição.

Etapa 2: Defina sua fábrica de notificações personalizada

Para instruir a Braze a usar sua fábrica de notificações personalizada, use o método setCustomBrazeNotificationFactory para definir seu IBrazeNotificationFactory:

• java
• kotlin

1
setCustomBrazeNotificationFactory(IBrazeNotificationFactory brazeNotificationFactory);

1
setCustomBrazeNotificationFactory(brazeNotificationFactory: IBrazeNotificationFactory)

O local recomendado para definir seu IBrazeNotificationFactory personalizado é no método (não na atividade) do ciclo de vida do aplicativo Application.onCreate(). Isso permitirá que a fábrica de notificações seja definida corretamente sempre que o processo do seu app estiver ativo.

Para cancelar sua configuração personalizada IBrazeNotificationFactory e retornar ao tratamento padrão do Braze para push, passe o endereço null para o nosso configurador de fábrica de notificações personalizadas:

• java
• kotlin

1
setCustomBrazeNotificationFactory(null);

1
setCustomBrazeNotificationFactory(null)

Texto do multiplicador de renderização

Na versão 3.1.1 do SDK da Braze, o HTML pode ser enviado a um dispositivo para renderizar o texto multiplicador nas notificações por push.

Esse exemplo é renderizado com o seguinte HTML:

1
2
3
<p><span style="color: #99cc00;">M</span>u<span style="color: #008080;">lti</span>Colo<span style="color: #ff6600;">r</span> <span style="color: #000080;">P</span><span style="color: #00ccff;">u</span><span style="color: #ff0000;">s</span><span style="color: #808080;">h</span></p>

<p><em>test</em> <span style="text-decoration: underline; background-color: #ff6600;"><strong>message</strong></span></p>

Lembre-se de que o Android limita quais elementos e tags HTML são válidos em suas notificações por push. Por exemplo, marquee não é permitido.

Para renderizar texto multicolorido em uma notificação por push, você pode atualizar seu site braze.xml ou BrazeConfig:

• braze.xml
• brazeconfig

1
<bool translatable="false" name="com_braze_push_notification_html_rendering_enabled">true</bool>

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

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

Tags HTML suportadas

Atualmente, o Google não lista as tags HTML compatíveis com o Android diretamente em sua documentação - essas informações só podem ser encontradas no arquivo Html.java do repositório Git. Tenha isso em mente ao consultar a tabela a seguir, pois essas informações foram extraídas desse arquivo e as tags HTML suportadas podem estar sujeitas a alterações.

Renderização de imagens em linha

Como funciona?

Você pode exibir uma imagem maior em sua notificação por push do Android usando o push de imagem em linha. Com esse design, os usuários não precisarão expandir manualmente o push para ampliar a imagem. Ao contrário das notificações por push normais do Android, as imagens inline por push têm uma proporção de 3:2.

Compatibilidade

Embora você possa enviar imagens em linha para qualquer dispositivo, os dispositivos e SDKs que não atenderem às versões mínimas exibirão uma imagem padrão. Para que as imagens em linha sejam exibidas corretamente, são necessários o SDK do Braze para Android v10.0.0+ e um dispositivo com Android M+.

Envio de um push de imagem em linha

Ao criar uma mensagem push para Android, esse recurso está disponível no menu suspenso Notification Type (Tipo de notificação ).

Configurações

Há muitas configurações avançadas disponíveis para notificações por push do Android enviadas pelo dashboard do Braze. Este artigo descreverá esses recursos e como usá-los com sucesso.

ID da notificação

Um ID de Notificação é um identificador único para uma categoria de mensagem de sua escolha que informa o serviço de envio de mensagens a respeitar apenas a mensagem mais recente desse ID. Definir um ID de notificação permite que você envie apenas a mensagem mais recente e relevante, em vez de uma pilha de mensagens desatualizadas e irrelevantes.

Prioridade de entrega de mensagem do Firebase

O campo Prioridade de entrega de mensagem do Firebase permite que você controle se um push é enviado com prioridade “normal” ou “alta” para o Firebase Cloud Messaging.

Time to live (TTL)

O campo TTL permite que você defina um tempo personalizado para armazenar mensagens com o serviço de push de envio de mensagens. Os valores padrão para TTL são quatro semanas para FCM e 31 dias para ADM.

Texto resumido

O texto de resumo permite que você defina texto adicional na visualização expandida da notificação. Também serve como uma legenda para notificações com imagens.

O texto do resumo será exibido sob o corpo da mensagem na exibição expandida.

Para notificações por push que incluem imagens, o texto da mensagem será mostrado na exibição recolhida, enquanto o texto do resumo será exibido como a legenda da imagem quando a notificação for expandida.

URIs personalizados

O recurso Custom URI permite que você especifique um URL da Web ou um recurso do Android para navegar quando a notificação for clicada. Se nenhum URI personalizado for especificado, clicar na notificação leva os usuários para o seu app. Você pode usar o URI personalizado para deep link dentro do seu app e direcionar os usuários para recursos que existem fora do seu app. Isso pode ser especificado por meio da API de envio de mensagens ou de nosso dashboard, em Advanced Settings (Configurações avançadas), no criador de mensagens push, conforme ilustrado:

Prioridade de exibição de notificação

O nível de prioridade de uma notificação por push afeta a forma como a notificação é exibida na bandeja de notificações em relação a outras notificações. Também pode afetar a velocidade e a maneira de entrega, pois mensagens normais e de baixa prioridade podem ser enviadas com uma latência ligeiramente maior ou agrupadas para preservar a vida útil da bateria, enquanto mensagens de alta prioridade são sempre enviadas imediatamente.

No Android O, a prioridade de notificação se tornou uma propriedade dos canais de notificação. Você precisará trabalhar com seu desenvolvedor para definir a prioridade de um canal durante sua configuração e, em seguida, usar o dashboard para selecionar o canal adequado ao enviar seus sons de notificação. Para dispositivos que executam versões do Android anteriores ao O, a especificação de um nível de prioridade para notificações do Android é possível por meio do dashboard do Braze e da API de envio de mensagens.

Para enviar mensagens para toda a sua base de usuários com uma prioridade específica, recomendamos especificar indiretamente a prioridade por meio da configuração do canal de envio de mensagens (para direcionar dispositivos O+) e enviar a prioridade individual a partir do dashboard (para direcionar dispositivos <O).

Os níveis de prioridade que você pode definir em notificações por push do Android ou Fire OS são:

Para saber mais, consulte a documentação de notificação do Android do Google.

Sons

No Android O, os sons de notificação se tornaram uma propriedade dos canais de notificação. Você precisará trabalhar com seu desenvolvedor para definir o som de um canal durante sua configuração e, em seguida, usar o dashboard para selecionar o canal adequado ao enviar suas notificações.

Para dispositivos executando versões do Android anteriores ao O, o Braze permite que você defina o som de uma mensagem push individual através do criador do dashboard. Você pode fazer isso especificando um recurso de som local no dispositivo (por exemplo, android.resource://com.mycompany.myapp/raw/mysound). Especificar “padrão” neste campo reproduzirá o som de notificação padrão no dispositivo. Isso pode ser especificado por meio da API de envio de mensagens ou do dashboard em Configurações avançadas no criador do push.

Digite o URI completo do recurso de som (por exemplo, android.resource://com.mycompany.myapp/raw/mysound) no prompt do dashboard.

Para enviar mensagens para toda a sua base de usuários com um som específico, recomendamos que especifique indiretamente o som por meio da configuração do canal de envio de mensagens (para direcionar dispositivos O+) e envie o som individual a partir do dashboard (para direcionar dispositivos <O).