Applications permanentes et mode ambiant du système

Ce guide explique comment rendre votre application toujours active, comment réagir aux transitions d'état de l'alimentation et comment gérer le comportement de l'application pour offrir une bonne expérience utilisateur tout en économisant la batterie.

Rendre une application constamment visible a un impact significatif sur l'autonomie de la batterie. Par conséquent, tenez-en compte lorsque vous ajoutez cette fonctionnalité.

Concepts clés

Lorsqu'une application Wear OS s'affiche en plein écran, elle se trouve dans l'un des deux états d'alimentation suivants :

• Interactif : état de haute consommation d'énergie dans lequel l'écran est à pleine luminosité, ce qui permet une interaction complète avec l'utilisateur.
• Ambiant : état à faible consommation d'énergie dans lequel l'écran s'assombrit pour économiser de l'énergie. Dans cet état, l'UI de votre application occupe toujours tout l'écran, mais le système peut en modifier l'apparence en la floutant ou en superposant du contenu comme l'heure. On parle également de mode Veille.

Le système d'exploitation contrôle la transition entre ces états.

Une application Always-On est une application qui affiche du contenu à la fois dans les états Interactif et Ambiant.

Lorsqu'une application always-on continue d'afficher sa propre UI lorsque l'appareil est en mode Ambient (mode basse consommation), elle est décrite comme étant en mode ambiactif.

Transitions système et comportement par défaut

Lorsqu'une application est exécutée au premier plan, le système gère les transitions d'état d'alimentation en fonction de deux délais d'inactivité de l'utilisateur.

• Délai 1 : État interactif vers l'état Veille : après un certain temps d'inactivité de l'utilisateur, l'appareil passe à l'état Veille.
• Délai 2 : Retour au cadran : après une nouvelle période d'inactivité, le système peut masquer l'application en cours et afficher le cadran.

Immédiatement après la première transition vers l'état Ambient (Mode Veille), le comportement par défaut dépend de la version de Wear OS et de la configuration de votre application :

• Sur Wear OS 5 et versions antérieures, le système affiche une capture d'écran floutée de votre application mise en pause, avec l'heure superposée.
• Sur Wear OS 6 ou version ultérieure, si une application cible le SDK 36 ou une version ultérieure, elle est considérée comme toujours activée. L'écran est atténué, mais l'application continue de s'exécuter et reste visible. (Les mises à jour peuvent être aussi peu fréquentes qu'une fois par minute.)

Personnaliser le comportement pour l'état Veille

Quel que soit le comportement par défaut du système, sur toutes les versions de Wear OS, vous pouvez personnaliser l'apparence ou le comportement de votre application en mode Ambient à l'aide de AmbientLifecycleObserver pour écouter les rappels lors des transitions d'état.

Utiliser AmbientLifecycleObserver

Pour réagir aux événements du mode Veille, utilisez la classe AmbientLifecycleObserver :

1. Implémentez l'interface AmbientLifecycleObserver.AmbientLifecycleCallback. Utilisez la méthode onEnterAmbient() pour ajuster votre UI à l'état basse consommation et onExitAmbient() pour la restaurer à l'affichage interactif complet.

   val ambientCallback = object : AmbientLifecycleObserver.AmbientLifecycleCallback {
       override fun onEnterAmbient(ambientDetails: AmbientLifecycleObserver.AmbientDetails) {
           // ... Called when moving from interactive mode into ambient mode.
           // Adjust UI for low-power state: dim colors, hide non-essential elements.
       }
   
       override fun onExitAmbient() {
           // ... Called when leaving ambient mode, back into interactive mode.
           // Restore full UI.
       }
   
       override fun onUpdateAmbient() {
           // ... Called by the system periodically (typically once per minute)
           // to allow the app to update its display while in ambient mode.
       }
   }
   

2. Créez un AmbientLifecycleObserver et enregistrez-le avec le cycle de vie de votre activité ou composable.

   private val ambientObserver = AmbientLifecycleObserver(activity, ambientCallback)
   
   override fun onCreate(savedInstanceState: Bundle) {
       super.onCreate(savedInstanceState)
       lifecycle.addObserver(ambientObserver)
   
       // ...
   }
   

3. Appelez removeObserver() pour supprimer l'observateur dans onDestroy().

Pour les développeurs qui utilisent Jetpack Compose, la bibliothèque Horologist fournit une utilitaire utile, le composable AmbientAware, qui simplifie l'implémentation de ce modèle.

TimeText avec prise en compte de l'environnement

À titre d'exception, sur Wear OS 6, le widget TimeText est compatible avec le mode Veille. Il se met automatiquement à jour une fois par minute lorsque l'appareil est en mode Ambient, sans code supplémentaire.

Contrôler la durée d'affichage à l'écran

Les sections suivantes expliquent comment gérer la durée de votre application à l'écran.

Empêcher le retour au cadran avec une activité en cours

Après un certain temps à l'état Ambient (délai d'inactivité 2), le système revient généralement au cadran. L'utilisateur peut configurer la durée du délai avant expiration dans les paramètres système. Dans certains cas d'utilisation, comme lorsqu'un utilisateur suit un entraînement, une application peut avoir besoin de rester visible plus longtemps.

Sur Wear OS 5 ou version ultérieure, vous pouvez éviter cela en implémentant une activité en cours. Si votre application affiche des informations sur une tâche utilisateur en cours, comme une séance d'entraînement, vous pouvez utiliser l'API Ongoing Activity pour maintenir votre application visible jusqu'à la fin de la tâche. Si un utilisateur revient manuellement au cadran, l'indicateur d'activité en cours lui permet de revenir à votre application en un seul geste.

Remarque : Si un contenu multimédia est en cours de lecture sur l'appareil Wear OS, une activité en cours est automatiquement créée. Dans ce cas, vous n'avez pas besoin de créer une autre activité en cours pour que votre application reste visible.

Pour ce faire, l'intent tactile de la notification en cours doit pointer vers votre activité toujours active, comme indiqué dans l'extrait de code suivant :

private fun createNotification(): Notification {
    val activityIntent =
        Intent(this, AlwaysOnActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
        }

    val pendingIntent =
        PendingIntent.getActivity(
            this,
            0,
            activityIntent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
        )

    val notificationBuilder =
        NotificationCompat.Builder(this, CHANNEL_ID)
            // ...
            // ...
            .setOngoing(true)

    // ...

    val ongoingActivity =
        OngoingActivity.Builder(applicationContext, NOTIFICATION_ID, notificationBuilder)
            // ...
            // ...
            .setTouchIntent(pendingIntent)
            .build()

    ongoingActivity.apply(applicationContext)

    return notificationBuilder.build()
}
AlwaysOnService.kt

Laisser l'écran allumé et empêcher l'état Veille

Dans de rares cas, vous devrez peut-être empêcher complètement l'appareil de passer en état Veille. C'est-à-dire pour éviter le délai d'inactivité 1. Pour ce faire, vous pouvez utiliser l'indicateur de fenêtre FLAG_KEEP_SCREEN_ON. Il fonctionne comme un verrouillage de réveil, maintenant l'appareil à l'état Interactive (Interactif). Utilisez cette option avec une extrême prudence, car elle a un impact important sur l'autonomie de la batterie.

Recommandations pour le mode Veille

Pour offrir la meilleure expérience utilisateur possible et économiser de l'énergie en mode Ambient, suivez ces consignes de conception.

• Utiliser un écran minimaliste et basse consommation
  • Laissez au moins 85 % de l'écran noir.
  • Utilisez des contours pour les icônes ou les boutons de grande taille plutôt que des remplissages pleins.
  • N'affichez que les informations les plus critiques, en déplaçant les détails secondaires vers l'écran interactif.
  • Évitez les grands blocs de couleur unie et les images de marque ou d'arrière-plan non fonctionnelles.
• Assurer la mise à jour appropriée du contenu
  • Pour les données qui changent fréquemment, comme un chronomètre, la distance d'un entraînement ou le temps, affichez un contenu d'espace réservé tel que -- pour éviter de donner l'impression que le contenu est récent.
  • Supprimez les indicateurs de progression qui s'actualisent en continu, comme pour les sonneries de compte à rebours et les sessions multimédias.
  • Le rappel onUpdateAmbient() ne doit être utilisé que pour les mises à jour essentielles, généralement une fois par minute.
• Maintenez une mise en page cohérente
  • Maintenez les éléments dans la même position dans les modes Interactif et Veille pour créer une transition fluide.
  • Toujours afficher l'heure.
• Tenir compte du contexte
  • Si l'utilisateur se trouvait sur un écran de paramètres ou de configuration lorsque l'appareil est passé en mode Veille, envisagez d'afficher un écran plus pertinent de votre application au lieu de la vue des paramètres.
• Gérer les exigences spécifiques à l'appareil
  • Dans l'objet AmbientDetails transmis à onEnterAmbient() :
    • Si deviceHasLowBitAmbient est true, désactivez l'anticrénelage dans la mesure du possible.
    • Si burnInProtectionRequired est true, déplacez régulièrement les éléments de l'interface utilisateur et évitez les zones blanches unies pour éviter les brûlures d'écran.

Débogage et test

Ces commandes adb peuvent être utiles lorsque vous développez ou testez le comportement de votre application lorsque l'appareil est en mode Veille :

# put device in ambient mode if the always on display is enabled in settings
# (and not disabled by other settings, such as theatre mode)
$ adb shell input keyevent KEYCODE_SLEEP

# put device in interactive mode
$ adb shell input keyevent KEYCODE_WAKEUP

Exemple : Application d'entraînement

Prenons l'exemple d'une application d'entraînement qui doit afficher des métriques à l'utilisateur pendant toute la durée de sa séance d'exercice. L'application doit rester visible lors des transitions d'état Ambient et éviter d'être remplacée par le cadran.

Pour ce faire, le développeur doit procéder comme suit :

1. Implémentez un AmbientLifecycleObserver pour gérer les modifications de l'UI entre les états Interactive (Interactif) et Ambient (Ambiant), comme atténuer l'écran et supprimer les données non essentielles.
2. Créez une nouvelle mise en page basse consommation pour l'état Ambient qui respecte les bonnes pratiques.
3. Utilisez l'API Ongoing Activity pendant toute la durée de l'entraînement pour empêcher le système de revenir au cadran.

Pour une implémentation complète, consultez l'exemple d'exercice basé sur Compose sur GitHub. Cet exemple montre également comment utiliser le composable AmbientAware de la bibliothèque Horologist pour simplifier la gestion du mode Veille dans Compose.