Use balões para permitir que os usuários participem de conversas

Os balões permitem que os usuários vejam e participem de conversas com mais facilidade.

Os balões são integrados ao sistema de notificações. Eles flutuam sobre outro app e seguir o usuário em qualquer lugar. Os usuários podem expandir os balões para mostrar e interagem com o conteúdo do app, podendo recolhê-los quando não estiverem usá-las.

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

Os balões são um recurso que pode ser desativado. Quando um aplicativo apresenta seu primeiro balão, de permissão do Google, oferece duas opções:

• Bloqueie todos os balões do app. As notificações não estão bloqueadas, mas nunca aparecerão como bolhas.
• Permitir todos os balões do app. Todas as notificações enviadas com BubbleMetaData aparecem como balões.

API de balão

Os balões são criados com a API de notificação. Portanto, envie sua notificação como normais. Se você quiser que sua notificação seja exibida como um balão, anexe dados extras a ele.

A exibição expandida de uma bolha é criada a partir de uma atividade escolhida por você. Configure a atividade para ser exibida corretamente como um balão. A atividade precisa ser redimensionável e incorporado. Se faltar qualquer um desses requisitos, ela será exibida 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 o app mostrar vários balões do mesmo tipo, como várias conversas conversas com diferentes contatos, a atividade precisa ser capaz de iniciar várias instâncias. Em dispositivos com o Android 10 e versões anteriores, as notificações não aparecem como balões, a menos que você defina explicitamente documentLaunchMode para "always". A partir do Android 11, não é necessário defina esse valor, já que o sistema define automaticamente documentLaunchMode para "always".

Para enviar uma bolha, siga estas etapas:

1. Crie uma notificação quando: costumam fazer.
2. Chamar BubbleMetadata.Builder(PendingIntent, Icon) ou BubbleMetadata.Builder(String) para criar um objeto BubbleMetadata.
3. Usar setBubbleMetadata() para adicionar os metadados à notificação.
4. Se você estiver segmentando o Android 11 ou versões mais recentes, verifique se o balão os metadados ou a notificação fazem referência a um atalho de compartilhamento.

Essas etapas são mostradas no exemplo a seguir:

// 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)

// 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 o app estiver em primeiro plano quando um balão for enviado, a importância será ignorada e o balão será sempre exibido, a menos que o usuário bloqueie os balões ou as notificações. do seu app.

Criar um balão expandido

Você pode configurar sua bolha para que ela seja automaticamente exibida no estado expandido. Qa recomendamos o uso desse recurso apenas se o usuário realizar uma ação que resulta em uma bolha, como tocar em um botão para iniciar um novo bate-papo. Nesse caso, também faz sentido suprimir a notificação inicial enviada quando um balão é criados.

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

O exemplo abaixo mostra como configurar um balão para apresentar automaticamente em um estado expandido:

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

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 processo normal ciclo de vida, resultando no se tornando um processo em primeiro plano, se ainda não for.

Quando o balão é recolhido ou dispensado, a atividade é destruída. Isso pode fazem com que o processo seja armazenado em cache e encerrado posteriormente, dependendo se o app tem outros componentes em primeiro plano em execução.

Quando as bolhas aparecem

Para reduzir as interrupções para o usuário, os balões aparecem apenas sob determinados em cada situação.

Se um app for direcionado ao Android 11 ou versões mais recentes, a notificação não aparecer como um balão, a menos que ele corresponda à conversa . Se um app for direcionado No Android 10 ou versões anteriores, a notificação aparece como um balão apenas se pelo menos uma das condições a seguir for atendida:

• A notificação usa MessagingStyle e tem uma Person adicionada.
• A notificação é de uma chamada Service.startForeground, tem um category de CATEGORY_CALL e tem um Person adicionado.
• O app está em primeiro plano quando a notificação é enviada.

Se nenhuma dessas condições for atendida, a notificação será exibida em vez de bolha

Como iniciar atividades de balões

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

Para iniciar uma nova atividade na mesma tarefa que o 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.

Tenha em mente que um balão representa uma conversa específica, portanto, as atividades iniciada dentro do balão deve estar relacionada a essa conversa. Além disso, iniciar uma atividade dentro do balão aumenta a pilha de tarefas do balão e podem complicar a experiência do usuário, especificamente em relação navegação.

Práticas recomendadas

• Enviar uma notificação em forma de balão somente se for importante, por exemplo, quando for parte de uma comunicação em andamento ou se o usuário solicita explicitamente uma bolha de conteúdo. Os balões usam o espaço da tela e cobrem o conteúdo de outros aplicativos.
• Verifique se a notificação em balão também funciona como uma notificação normal. Quando o usuário desativar o balão, uma notificação de balão será exibida notificação.
• Chamar super.onBackPressed ao substituir. onBackPressed no balão atividades. Caso contrário, seu balão pode não se comportar corretamente.

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

• Atualize o BubbleMetadata para suprimir a notificação. Chame BubbleMetadata.Builder.setSuppressNotification(). Isso remove o ícone do selo para indicar que o usuário interagiu com a mensagem.
• Definir Notification.Builder.setOnlyAlertOnce() para true para suprimir o som ou a vibração que acompanha o BubbleMetadata. atualizar.

App de exemplo

A Pessoas O app de exemplo é um app de conversa que usa balões. Para fins de demonstração, este app usa chatbots. Em aplicativos do mundo real, use balões para mensagens humanos.