Utiliser des bulles pour permettre aux utilisateurs de participer aux conversations

Les bulles permettent aux utilisateurs de voir et de participer plus facilement aux conversations.

Figure 1 Bulle de chat.

Les bulles sont intégrées au système de notification. Elles flottent au-dessus des autres contenus de l'application et suivent l'utilisateur partout où il va. Les utilisateurs peuvent développer les bulles pour révéler et interagir avec le contenu de l'application, et les réduire lorsqu'ils ne les utilisent pas.

Lorsque l'appareil est verrouillé ou que l'affichage permanent est activé, des bulles s'affichent comme d'habitude.

Les bulles sont une fonctionnalité désactivable. Lorsqu'une application présente sa première bulle, une boîte de dialogue d'autorisation propose deux choix:

  • Bloquez toutes les bulles de votre application. Les notifications ne sont pas bloquées, mais elles n'apparaissent jamais sous forme de bulles.
  • Autorisez toutes les bulles de votre application. Toutes les notifications envoyées avec BubbleMetaData s'affichent sous forme de bulles.

API Bubble

Les bulles sont créées à l'aide de l'API de notification. Envoyez donc votre notification normalement. Si vous souhaitez que votre notification s'affiche sous forme de bulle, joignez-y des données supplémentaires.

La vue développée d'une bulle est créée à partir d'une activité de votre choix. Configurez l'activité pour qu'elle s'affiche correctement sous forme de bulle. L'activité doit être redimensionnable et intégrée. Si l'une de ces conditions n'est pas remplie, l'application s'affiche sous forme de notification.

Le code suivant montre comment implémenter une bulle:

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

Si votre application affiche plusieurs bulles du même type, comme plusieurs conversations de chat avec différents contacts, l'activité doit pouvoir lancer plusieurs instances. Sur les appareils équipés d'Android 10 ou version antérieure, les notifications ne s'affichent pas sous forme de bulles, sauf si vous définissez explicitement documentLaunchMode sur "always". À partir d'Android 11, vous n'avez pas besoin de définir explicitement cette valeur, car le système définit automatiquement toutes les documentLaunchMode des conversations sur "always".

Pour envoyer une bulle, procédez comme suit:

  1. Créez une notification comme d'habitude.
  2. Appelez BubbleMetadata.Builder(PendingIntent, Icon) ou BubbleMetadata.Builder(String) pour créer un objet BubbleMetadata.
  3. Utilisez setBubbleMetadata() pour ajouter les métadonnées à la notification.
  4. Si vous ciblez Android 11 ou une version ultérieure, assurez-vous que les métadonnées de la bulle ou la notification font référence à un raccourci de partage.
  5. Modifiez votre application pour qu'elle n'annule pas les notifications qui s'affichent sous forme de bulles. Pour vérifier si l'activité de notification est lancée en tant que bulle, appelez Activity#isLaunchedFromBubble(). Si vous annulez une notification, la bulle disparaît de l'écran. L'ouverture d'une bulle masque automatiquement la notification qui lui est associée.

Ces étapes sont présentées dans l'exemple suivant :

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

Si votre application est au premier plan lorsqu'une bulle est envoyée, l'importance est ignorée et votre bulle est toujours affichée, sauf si l'utilisateur bloque les bulles ou les notifications de votre application.

Créer une bulle agrandie

Vous pouvez configurer votre info-bulle pour qu'elle s'affiche automatiquement en mode développé. Nous vous recommandons de n'utiliser cette fonctionnalité que si l'utilisateur effectue une action qui génère une bulle, comme appuyer sur un bouton pour démarrer une nouvelle discussion. Dans ce cas, il est également judicieux de supprimer la notification initiale envoyée lorsqu'une bulle est créée.

Vous pouvez utiliser les méthodes suivantes pour définir des indicateurs qui activent ces comportements : setAutoExpandBubble() et setSuppressNotification().

L'exemple suivant montre comment configurer une bulle pour qu'elle s'affiche automatiquement dans un état développé:

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();

Cycle de vie des contenus Bubble

Lorsqu'une bulle est développée, l'activité de contenu suit le cycle de vie du processus normal, ce qui fait que l'application devient un processus de premier plan, si ce n'est pas déjà le cas.

Lorsque la bulle est réduite ou fermée, l'activité est détruite. Le processus peut être mis en cache et supprimé par la suite, selon que l'application exécute d'autres composants de premier plan.

Lorsque des bulles apparaissent

Pour réduire les interruptions pour l'utilisateur, les bulles n'apparaissent que dans certaines circonstances.

Si une application cible Android 11 ou une version ultérieure, une notification n'apparaît pas sous forme de bulle, sauf si elle répond aux exigences de conversation. Si une application cible Android 10 ou une version antérieure, la notification s'affiche sous forme de bulle uniquement si une ou plusieurs des conditions suivantes sont remplies:

Si aucune de ces conditions n'est remplie, la notification s'affiche à la place d'une bulle.

Lancer des activités à partir de bulles

Lorsqu'une bulle lance une nouvelle activité, celle-ci est lancée dans la même tâche et la même fenêtre en bulle, ou dans une nouvelle tâche en plein écran, réduisant la bulle qui l'a lancée.

Pour lancer une nouvelle activité dans la même tâche que la bulle : 1. Utilisez le contexte de l'activité lorsque vous lancez des intents, activity.startActivity(intent) et 1. Ne définissez pas l'indicateur FLAG_ACTIVITY_NEW_TASK sur l'intent.

Sinon, la nouvelle activité est lancée dans une nouvelle tâche et la bulle est réduite.

N'oubliez pas qu'une bulle représente une conversation spécifique. Par conséquent, les activités lancées dans la bulle doivent être liées à cette conversation. De plus, le lancement d'une activité dans la bulle augmente la pile de tâches de la bulle et peut potentiellement compliquer l'expérience utilisateur, en particulier en ce qui concerne la navigation.

Bonnes pratiques

  • N'envoyez une notification sous forme de bulle que si elle est importante, par exemple lorsqu'elle fait partie d'une communication en cours ou si l'utilisateur demande explicitement une bulle pour un contenu. Les bulles occupent de l'espace à l'écran et recouvrent le contenu d'autres applications.
  • Assurez-vous que votre notification en bulle fonctionne également comme une notification normale. Lorsque l'utilisateur désactive la bulle, une notification de bulle s'affiche comme une notification normale.
  • Appelez super.onBackPressed lorsque vous remplacez onBackPressed dans l'activité de bulle. Sinon, votre bulle risque de ne pas se comporter correctement.

Lorsqu'une bulle réduite reçoit un message mis à jour, une icône de badge s'affiche pour indiquer qu'il s'agit d'un message non lu. Lorsque l'utilisateur ouvre le message dans l'application associée, procédez comme suit:

Application exemple

L'application exemple Personnes est une application de conversation qui utilise des bulles. À des fins de démonstration, cette application utilise des chatbots. Dans les applications réelles, utilisez des bulles pour les messages envoyés par des humains.