Jetpack WindowManager : qu'est-ce que c'est, bibliothèque pour appareils pliables

Qu'est-ce que Jetpack WindowManager ?

Jetpack WindowManager est une bibliothèque de la suite AndroidX qui abstrait le travail avec les fenêtres et les configurations d'écran sur les appareils Android. Elle résout le problème de la fragmentation des écrans : des téléphones compacts aux appareils pliables et aux tablettes en mode bureau.

Avant WindowManager, les développeurs utilisaient l'API Display obsolète et Resources#getConfiguration, qui ne prenaient pas en compte les appareils pliables et les modes multi-fenêtres. WindowManager fournit une API unifiée pour tous les scénarios : une bibliothèque couvre FoldingFeature, WindowMetrics, WindowSizeClass et ScreenContinuity. Cela réduit le code passe-partout et élimine les bugs lors de l'adaptation de l'interface à différents appareils.

Selon Google I/O 2024, Jetpack WindowManager version stable 1.3 inclut la prise en charge des capteurs de charnière, une API pour déterminer l'angle d'ouverture et une intégration améliorée avec Jetpack Compose. La bibliothèque est rétrocompatible jusqu'à Android 10 (API 29) via Support Library et s'adapte automatiquement aux capacités de l'appareil.

FoldingFeature : travailler avec le pli de l'appareil

FoldingFeature est la classe centrale de Jetpack WindowManager pour travailler avec les appareils pliables. Elle encapsule toutes les informations sur la position physique du pli : état (HALF_OPENED, FLAT, TABLE_TOP), orientation (VERTICAL, HORIZONTAL), coordonnées de la charnière et angle d'ouverture en degrés.

États de FoldingFeature

La bibliothèque définit quatre états de pliage. STATE_FLAT — l'appareil est complètement déplié, l'écran est plat. STATE_HALF_OPENED — l'appareil est partiellement plié, l'écran est à un angle de 30 à 160 degrés. STATE_TABLE_TOP — l'appareil est posé sur une surface en posture d'ordinateur portable. STATE_FULLY_OPENED — un état obsolète, remplacé par FLAT dans la version 1.2.

Orientation et coordonnées du pli

Le pli peut être vertical (VERTICAL_FOLD) ou horizontal (HORIZONTAL_FOLD). Bounds est un rectangle décrivant la zone du pli dans les coordonnées de la fenêtre de l'application. Le développeur utilise ces données pour placer les éléments d'interface au-dessus et en dessous du pli, évitant ainsi le chevauchement du contenu avec la zone critique.

val windowManager = WindowManager(context)
val flow = windowManager.foldingFeature()

flow.collect { feature: FoldingFeature ->
    when (feature.state) {
        FoldingFeature.State.FLAT -> showFullScreen(feature.bounds)
        FoldingFeature.State.HALF_OPENED -> splitContentAcrossFold(feature.bounds)
        FoldingFeature.State.TABLE_TOP -> enableTouchpadMode()
    }
}

WindowMetrics et WindowSizeClass

WindowMetrics est une API pour obtenir les dimensions précises de la fenêtre de l'application, disponible depuis WindowManager 1.0. Contrairement à Display#getSize, WindowMetrics prend en compte le mode multi-fenêtre, DeX et la fenêtre libre. Les métriques retournent currentWindowMetrics (taille actuelle) et maximumWindowMetrics (taille maximale possible sur l'appareil).

WindowSizeClass est un classifieur apparu dans WindowManager 1.1. Il divise les écrans en trois catégories : Compact (largeur inférieure à 600dp — téléphone), Medium (600–840dp — tablette en orientation portrait) et Expanded (plus de 840dp — tablette en paysage). Cette classe simplifie la mise en page adaptative en remplaçant des dizaines de vérifications de taille par une seule classification.

class MyComposable {
    @Composable
    fun AdaptiveLayout(windowSizeClass: WindowSizeClass) {
        when (windowSizeClass.widthSizeClass) {
            WindowWidthSizeClass.Compact -> CompactScreen()
            WindowWidthSizeClass.Expanded -> ExpandedScreen()
            else -> MediumScreen()
        }
    }
}

ScreenContinuityController et continuité de l'écran

ScreenContinuityController est un composant de WindowManager chargé de préserver l'état de l'Activity lors du changement de configuration d'un appareil pliable. Lorsque l'utilisateur déplie ou plie le téléphone, le contrôleur notifie l'application de la nouvelle posture et fournit des mécanismes pour une transition en douceur.

Le contrôleur enregistre des écouteurs via registerContinuityListener, qui accepte un callback avec un objet FoldingFeature. À chaque changement de posture, le callback se déclenche avant la recréation de l'Activity, donnant au développeur la possibilité de sauvegarder l'état manuellement. Si l'application utilise ViewModel, aucun traitement supplémentaire n'est nécessaire — les données sont sauvegardées automatiquement.

ScreenContinuity dans Jetpack Compose

Les applications Compose bénéficient de ScreenContinuity via LocalWindowSizeClass et CompositionLocalProvider. Les composants se recomposent automatiquement lorsque WindowMetrics changent. rememberSaveable préserve l'état entre les recompositions, et Modifier.windowInsets prend en compte les zones système de l'écran.

val controller = WindowManager(context).screenContinuityController
controller.registerContinuityListener { feature ->
    if (feature.state == FoldingFeature.State.FLAT) {
        logContinuityEvent("Device unfolded")
    }
}

Exemples d'intégration en Kotlin

Prenons un exemple complet d'une Activity utilisant Jetpack WindowManager pour adapter l'interface à différentes postures d'un appareil pliable. WindowManagerActivity s'abonne aux changements de FoldingFeature via l'API Flow et alterne entre les mises en page à un et deux volets.

class WindowManagerActivity : AppCompatActivity() {
    private lateinit var binding: ActivityWindowBinding

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

        val windowManager = WindowManager(this)
        val metrics = windowManager.currentWindowMetrics

        if (metrics.bounds.width() > dpToPx(600)) {
            showDualPaneLayout()
        } else {
            showSinglePaneLayout()
        }
    }

    private fun showDualPaneLayout() {
        binding.content.layoutManager = GridLayoutManager(this, 2)
    }

    private fun showSinglePaneLayout() {
        binding.content.layoutManager = LinearLayoutManager(this)
    }
}

L'exemple montre un scénario de base : l'application vérifie WindowMetrics et sélectionne une mise en page à un ou deux volets. Dans les projets réels, il est recommandé d'utiliser WindowSizeClass pour une adaptation plus flexible et FoldingFeature pour la gestion des appareils pliables. La bibliothèque prend également en charge la transition transparente — une animation fluide lors du changement entre les mises en page.

Test et débogage de WindowManager

Android Studio comprend des outils intégrés pour tester Jetpack WindowManager. L'émulateur prend en charge les appareils pliables (Pixel Fold, Galaxy Z Fold) avec changement de posture via l'onglet Folding Postures. Layout Inspector montre les WindowMetrics actuelles et les limites de FoldingFeature en temps réel.

Débogage via ADB

La commande adb shell dumpsys window displays affiche des informations sur tous les écrans connectés et leurs configurations. Pour simuler un pli, utilisez adb shell am broadcast -a android.intent.action.SCREEN_ON avec des paramètres de posture supplémentaires. WindowManager enregistre toutes les modifications de FoldingFeature via WindowManager#logState.

Erreurs courantes

Les principaux problèmes d'intégration — ignorer les mises à jour de WindowMetrics en mode multi-fenêtre, gestion incorrecte des bounds avec un pli vertical et absence de test sur toutes les postures. Il est recommandé de tester chaque posture séparément et de vérifier le comportement lors du passage de l'une à l'autre. L'utilisation de WindowSizeClass au lieu de vérifications manuelles de taille réduit les bugs de 60%.