Usar balões de notificação para conversas

Os balões de notificação facilitam a visualização e a participação dos usuários em conversas.

Figura 1. Um balão de diálogo.

Eles flutuam sobre o conteúdo de outros apps, e os usuários podem expandir os balões para revelar e interagir com o conteúdo do app, além de recolhê-los quando não estiverem usando.

Quando o dispositivo está bloqueado ou a tela sempre ativada está ativa, os balões aparecem como notificações normalmente.

Os balões de notificação são ativados pelo usuário. Para fazer isso, basta tocar no botão de balão nas notificações que oferecem suporte a balões. Isso permite que esse chat específico sempre apareça como um balão. Nas configurações, os usuários podem ajustar quais chats foram exibidos como balões ou modificar as configurações do app geral.

Os usuários podem fazer o seguinte:

  • Bloquear todos os balões de notificação do seu app. As notificações não são bloqueadas, mas nunca aparecem como balões.
  • Permitir balões de notificação selecionados do seu app. As notificações que aparecem como balões usando o botão de balão são "selecionadas".
  • Permitir todos os balões de notificação do seu app. Todas as notificações enviadas com BubbleMetadata aparecem como balões.

A API Notification Bubble

Os balões de notificação são criados usando a API Notification. Se você quiser que sua notificação apareça como um balão, anexe dados extras a ela.

A visualização expandida do balão é criada a partir de uma atividade escolhida por você. Configure a atividade para que ela apareça corretamente como um balão. A atividade precisa ser redimensionável e incorporada. Se algum desses requisitos não for atendido, o sistema vai mostrar a atividade como uma notificação.

O código a seguir demonstra como implementar um balão:

<activity
  android:name=".bubbles.BubbleActivity"
  android:theme="@style/AppTheme.NoActionBar"
  android:label="@string/title_activity_bubble"
  android:allowEmbedded="true"
  android:resizeableActivity="true"
/>

Se seu app mostra vários balões do mesmo tipo, como várias conversas de chat com diferentes contatos, a atividade precisa ser capaz de iniciar várias instâncias. Em dispositivos com Android 10 e versões anteriores, as notificações não são mostradas como balões, a menos que você defina explicitamente documentLaunchMode como "always". A partir do Android 11, não é necessário definir explicitamente esse valor, já que o sistema define de forma automática todas as conversas de documentLaunchMode para "always".

Para enviar um balão de notificação, siga estas etapas:

  1. Crie uma notificação como você normalmente faz.
  2. Chame BubbleMetadata.Builder(PendingIntent, Icon) ou BubbleMetadata.Builder(String) para criar um objeto BubbleMetadata.
  3. Use setBubbleMetadata() para adicionar os metadados à notificação.
  4. Se o app for direcionado ao Android 11 ou mais recente, verifique se os metadados ou a notificação do balão fazem referência a um atalho de compartilhamento rápido.
  5. Modifique seu app para não cancelar notificações que aparecem como balões. Para verificar se a atividade de notificação é iniciada como um balão, chame Activity#isLaunchedFromBubble(). O cancelamento de uma notificação remove o balão da tela. A abertura de um balão oculta automaticamente a notificação associada a ele.

Essas etapas são mostradas no exemplo a seguir:

Kotlin

// Create a bubble intent.
val target = Intent(context, BubbleActivity::class.java)
val bubbleIntent = PendingIntent.getActivity(context, 0, target, 0 /* flags */)
val category = "com.example.category.IMG_SHARE_TARGET"

val chatPartner = Person.Builder()
    .setName("Chat partner")
    .setImportant(true)
    .build()

// Create a sharing shortcut.
val shortcutId = generateShortcutId()
val shortcut =
   ShortcutInfo.Builder(mContext, shortcutId)
       .setCategories(setOf(category))
       .setIntent(Intent(Intent.ACTION_DEFAULT))
       .setLongLived(true)
       .setShortLabel(chatPartner.name)
       .build()

// Create a bubble metadata.
val bubbleData = Notification.BubbleMetadata.Builder(bubbleIntent,
            Icon.createWithResource(context, R.drawable.icon))
    .setDesiredHeight(600)
    .build()

// Create a notification, referencing the sharing shortcut.
val builder = Notification.Builder(context, CHANNEL_ID)
    .setContentIntent(contentIntent)
    .setSmallIcon(smallIcon)
    .setBubbleMetadata(bubbleData)
    .setShortcutId(shortcutId)
    .addPerson(chatPartner)

Java

// Create a bubble intent.
Intent target = new Intent(mContext, BubbleActivity.class);
PendingIntent bubbleIntent =
    PendingIntent.getActivity(mContext, 0, target, 0 /* flags */);

private val CATEGORY_TEXT_SHARE_TARGET =
    "com.example.category.IMG_SHARE_TARGET"

Person chatPartner = new Person.Builder()
        .setName("Chat partner")
        .setImportant(true)
        .build();

// Create a sharing shortcut.
private String shortcutId = generateShortcutId();
ShortcutInfo shortcut =
   new ShortcutInfo.Builder(mContext, shortcutId)
       .setCategories(Collections.singleton(CATEGORY_TEXT_SHARE_TARGET))
       .setIntent(Intent(Intent.ACTION_DEFAULT))
       .setLongLived(true)
       .setShortLabel(chatPartner.getName())
       .build();

// Create a bubble metadata.
Notification.BubbleMetadata bubbleData =
    new Notification.BubbleMetadata.Builder(bubbleIntent,
            Icon.createWithResource(context, R.drawable.icon))
        .setDesiredHeight(600)
        .build();

// Create a notification, referencing the sharing shortcut.
Notification.Builder builder =
    new Notification.Builder(mContext, CHANNEL_ID)
        .setContentIntent(contentIntent)
        .setSmallIcon(smallIcon)
        .setBubbleMetadata(bubbleData)
        .setShortcutId(shortcutId)
        .addPerson(chatPartner);

Se seu app estiver em primeiro plano quando um balão for enviado, a importância será ignorada, e o balão será sempre mostrado, a menos que o usuário bloqueie balões ou notificações do seu app.

Criar um balão expandido

Você pode configurar sua bolha para que ela seja automaticamente exibida no estado expandido. Recomendamos que esse recurso só seja usado se o usuário executar uma ação que resulte em um balão, como tocar em um botão para iniciar um novo chat. Nesse caso, também faz sentido suprimir a notificação inicial enviada quando um balão é criado.

Há métodos que podem ser usados para definir sinalizações que ativem esses comportamentos: setAutoExpandBubble() e setSuppressNotification().

O exemplo a seguir mostra como configurar um balão para que ele seja apresentado automaticamente em um estado expandido:

Kotlin

val bubbleMetadata = Notification.BubbleMetadata.Builder()
    .setDesiredHeight(600)
    .setIntent(bubbleIntent)
    .setAutoExpandBubble(true)
    .setSuppressNotification(true)
    .build()

Java

Notification.BubbleMetadata bubbleData =
    new Notification.BubbleMetadata.Builder()
        .setDesiredHeight(600)
        .setIntent(bubbleIntent)
        .setAutoExpandBubble(true)
        .setSuppressNotification(true)
        .build();

Ciclo de vida do conteúdo do balão

Quando um balão é expandido, a atividade de conteúdo passa pelo ciclo de vida de processo normal, resultando na transformação do app em um processo em primeiro plano, se esse ainda não for o caso.

Quando o balão é recolhido ou dispensado, a atividade é destruída. Isso pode fazer com que o processo seja armazenado em cache e, posteriormente, interrompido se o app tiver outros componentes sendo executados em primeiro plano.

Quando os balões aparecem

Para reduzir as interrupções do usuário, os balões só aparecem em determinadas circunstâncias.

Se um app for direcionado ao Android 11 ou versões mais recentes, uma notificação não aparecerá como um balão a menos que atenda aos requisitos da conversa. Se um app for direcionado ao Android 10 ou versões anteriores, a notificação aparecerá como um balão somente se uma ou mais das seguintes condições forem atendidas:

Se nenhuma dessas condições for atendida, a notificação será mostrada em vez de um balão.

Como iniciar atividades em balões

Quando um balão inicia uma nova atividade, ela é iniciada na mesma tarefa e na mesma janela de balão ou em uma nova tarefa em tela cheia, recolhendo o balão que a iniciou.

Para iniciar uma nova atividade na mesma tarefa do balão: 1. Use o contexto da atividade ao iniciar intents, activity.startActivity(intent), e 1. Não defina a flag FLAG_ACTIVITY_NEW_TASK na intent.

Caso contrário, a nova atividade será iniciada em uma nova tarefa, e o balão será recolhido.

Um balão representa uma conversa específica. Portanto, as atividades iniciadas nele precisam estar relacionadas a essa conversa. Além disso, iniciar uma atividade no balão aumenta a pilha de tarefas do balão e pode complicar a experiência do usuário, especificamente em relação à navegação.

Práticas recomendadas

  • Envie uma notificação como um balão somente se ela for importante, por exemplo, quando fizer parte de uma comunicação em andamento ou se o usuário solicitar explicitamente um balão para conteúdo. Os balões usam espaço na tela e cobrem o conteúdo de outros apps.
  • Verifique se a notificação em balão também funciona como uma notificação normal. Quando o usuário desativa o balão, uma notificação em balão é mostrada como uma notificação normal.
  • Chame super.onBackPressed ao substituir onBackPressed na atividade do balão. Caso contrário, o balão poderá não se comportar corretamente.

Quando um balão recolhido recebe uma mensagem atualizada, ele mostra um ícone de selo para indicar uma mensagem não lida. Quando o usuário abrir a mensagem no app associado, siga estas etapas:

App de exemplo

O SociaLite app de exemplo é um app de conversa que usa balões. Para fins de demonstração, este app usa chatbots. Em aplicativos reais, use balões para mensagens enviadas por humanos.