Screen Continuity : définition, API de pli et adaptation d'interface

Qu'est-ce que Screen Continuity ?

Screen Continuity est un mécanisme Android qui préserve l'état de l'Activity lors du changement de configuration physique de l'écran sur les appareils pliables. Lorsque l'utilisateur déplie ou plie le téléphone, le système peut redémarrer l'Activity avec de nouvelles dimensions de fenêtre. La continuité évite la perte des données saisies, de la position de défilement et de l'écran actuel.

Contrairement à une simple rotation d'écran où Android recrée simplement l'Activity avec une nouvelle orientation, les appareils pliables introduisent des scénarios fondamentalement nouveaux. La posture HALF_OPENED permet à l'application de fonctionner sur un demi-écran, tandis que FLAT fonctionne en mode tablette entièrement déplié. Sans support de Screen Continuity, chaque changement de posture réinitialise l'interface à son état initial.

Selon Google I/O 2024, plus de 62% des utilisateurs d'appareils pliables ont rencontré des applications qui gèrent incorrectement le changement d'état. Screen Continuity résout ce problème au niveau de l'API, fournissant au développeur des outils prêts à l'emploi pour sauvegarder et restaurer l'interface utilisateur.

États des appareils pliables : postures d'écran

Jetpack WindowManager définit trois postures de base pour les appareils pliables via la classe FoldingFeature. Chaque posture correspond à une position physique spécifique de la charnière et nécessite un traitement d'interface particulier.

HALF_OPENED — État semi-plié

L'appareil est à un angle de 30 à 160 degrés. L'écran est divisé en deux zones logiques. L'application peut afficher du contenu sur la moitié supérieure et des commandes sur la moitié inférieure. Le mode tabletop pour les appels vidéo et les lecteurs multimédia utilise cette posture.

FLAT — État entièrement déplié

L'appareil est ouvert à 180 degrés, formant un seul grand écran. L'application passe en mode tablette avec un espace de travail agrandi. Dans cette posture, il est recommandé d'afficher une disposition multi-panneaux avec un panneau de navigation et un contenu détaillé côte à côte.

TABLE_TOP — Posture d'ordinateur portable

L'appareil repose sur une surface à un angle d'environ 120 degrés. La moitié inférieure de l'écran sert de panneau tactile ou de clavier. Le mode touchpad dans cette posture permet d'émuler un pavé tactile sur la partie inférieure de l'écran.

Comment fonctionne la continuité d'écran dans Android ?

Android gère les changements de configuration des appareils pliables via le mécanisme des configuration changes. Lorsque l'utilisateur déplie le téléphone, le système détecte le changement de taille de fenêtre et lance le cycle standard de recréation de l'Activity. Screen Continuity intercepte ce processus et sauvegarde les données clés.

La méthode principale pour sauvegarder l'état est onRetainNonConfigurationInstance, qui est appelée avant la destruction de l'Activity. Le développeur y sauvegarde le modèle de données, la position de la liste et l'écran de navigation actuel. Après la recréation, l'Activity reçoit ces données via getLastNonConfigurationInstance et restaure l'interface exactement comme avant le pliage.

Pour les Fragments, le mécanisme est implémenté via setRetainInstance(true), qui empêche la destruction du fragment lors des changements de configuration. Dans Jetpack Compose, on utilise rememberSaveable, qui sauvegarde automatiquement l'état lors du changement des Window Metrics.

class MainActivity : AppCompatActivity() {
    private var currentScrollPosition: Int = 0

    override fun onRetainNonConfigurationInstance(): Any {
        return SavedState(scrollPosition = currentScrollPosition)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val saved = lastNonConfigurationInstance as? SavedState
        saved?.let { currentScrollPosition = it.scrollPosition }
    }
}

API ScreenContinuity dans Jetpack WindowManager

Jetpack WindowManager version 1.1+ inclut la classe ScreenContinuityController, qui fournit des mécanismes prêts à gérer la continuité d'écran. L'API gère automatiquement les changements de posture et notifie l'application via des interfaces callback.

ScreenContinuityController

La classe centrale qui enregistre les écouteurs de changement de posture. registerContinuityListener accepte un callback qui se déclenche à chaque transition entre les états de l'appareil pliable. Le contrôleur fournit également des informations sur la posture actuelle via la méthode getCurrentFoldingFeature.

FoldingFeatureAdapter

Une classe utilitaire pour transformer les données FoldingFeature en états lisibles par l'application. FoldingFeatureAdapter normalise les coordonnées de la charnière et détermine si la posture actuelle est HALF_OPENED, FLAT ou TABLE_TOP. Cela évite au développeur de calculer manuellement les angles et les seuils.

Intégration avec Jetpack Compose

Pour les applications Compose, WindowManager fournit WindowSizeClass et des modificateurs qui tiennent compte du pli. Le composant BoxWithConstraints s'adapte aux changements de taille d'écran en temps réel sans recréation de l'Activity. Compose déclenche automatiquement la recomposition lorsque les WindowMetrics changent.

val windowManager = WindowManager(context)
val controller = windowManager.screenContinuityController

controller.registerContinuityListener { feature: FoldingFeature ->
    when (feature.state) {
        FoldingFeature.State.HALF_OPENED -> enterTabletopMode()
        FoldingFeature.State.FLAT -> expandToTablet()
    }
}

Exemple d'implémentation en Kotlin

Examinons un exemple complet d'Activity avec le support de Screen Continuity. MainActivity gère trois scénarios : pliage, dépliage et état semi-plié. Les données sont sauvegardées via onRetainNonConfigurationInstance et restaurées lors de la recréation.

class ContinuityActivity : AppCompatActivity() {
    private lateinit var binding: ActivityContinuityBinding
    private var itemList = mutableListOf<String>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityContinuityBinding.inflate(layoutInflater)
        setContentView(binding.root)

        val savedState = lastNonConfigurationInstance as? ContinuityState
        if (savedState != null) {
            itemList.addAll(savedState.items)
            restoreUi(savedState)
        }
        setupWindowManager()
    }

    private fun setupWindowManager() {
        val controller = WindowManager(this).screenContinuityController
        controller.registerContinuityListener { feature ->
            updateLayoutForFeature(feature)
        }
    }

    private fun updateLayoutForFeature(feature: FoldingFeature) {
        when (feature.state) {
            FoldingFeature.State.HALF_OPENED -> binding.root.enableTabletopMode()
            FoldingFeature.State.FLAT -> binding.root.enableTabletMode()
            FoldingFeature.State.TABLE_TOP -> binding.root.enableTouchpadMode()
        }
    }

    override fun onRetainNonConfigurationInstance(): Any {
        return ContinuityState(itemList.toList(), binding.listView.firstVisiblePosition)
    }
}

data class ContinuityState(
    val items: List<String>,
    val scrollPosition: Int
)

L'élément clé est la classe ContinuityState, qui stocke la liste des éléments et la position de défilement. L'Activity la sauvegarde avant la recréation et la restaure immédiatement après l'appel à onCreate. Le contrôleur WindowManager s'abonne aux changements de posture et bascule la disposition entre les modes.

Test de la continuité sur émulateur et appareil

Android Studio fournit un émulateur d'appareil pliable avec le support des trois postures. Pour tester Screen Continuity, créez simplement un appareil virtuel de type Pixel Fold ou Samsung Galaxy Z Fold et basculez les postures via le panneau de contrôle de l'émulateur.

Configuration de l'émulateur

Créez un AVD avec la catégorie Foldable et sélectionnez une résolution d'écran de 7,6 pouces. Dans les contrôles étendus de l'émulateur, ouvrez l'onglet Folding Postures et basculez entre les postures. Chaque basculement déclenche un configuration change que l'application doit gérer correctement.

Appareil physique

Sur un appareil réel (Galaxy Z Fold 5, Pixel Fold), les tests sont effectués en pliant et dépliant physiquement. Les modes Samsung DeX et Multi-Window activent également la continuité. Pour le débogage, utilisez la commande ADB adb shell dumpsys window policy, qui affiche l'état actuel du pli.

Problèmes courants

Les principales erreurs incluent la perte d'état du RecyclerView, la réinitialisation du contenu des champs de texte et la fermeture des fenêtres de dialogue. ViewModel résout ces problèmes en conservant les données en mémoire indépendamment du cycle de vie de l'Activity. Il est également important d'annoter l'Activity dans le manifeste avec le paramètre android:configChanges si l'application gère les changements manuellement.

<!-- AndroidManifest.xml -->
@android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"