Jetpack WindowManager: qué es, biblioteca para dispositivos plegables

¿Qué es Jetpack WindowManager?

Jetpack WindowManager es una biblioteca del conjunto AndroidX que abstrae el trabajo con ventanas y configuraciones de pantalla en dispositivos Android. Resuelve el problema de la fragmentación de pantallas: desde teléfonos compactos hasta dispositivos plegables y tabletas con modo de escritorio.

Antes de WindowManager, los desarrolladores usaban la API Display obsoleta y Resources#getConfiguration, que no tenían en cuenta los dispositivos plegables ni los modos multi-ventana. WindowManager proporciona una API unificada para todos los escenarios: una biblioteca cubre FoldingFeature, WindowMetrics, WindowSizeClass y ScreenContinuity. Esto reduce el código repetitivo y elimina errores al adaptar la interfaz a diferentes dispositivos.

Según Google I/O 2024, Jetpack WindowManager versión estable 1.3 incluye soporte para sensores de bisagra, una API para determinar el ángulo de apertura y una integración mejorada con Jetpack Compose. La biblioteca es compatible con versiones anteriores hasta Android 10 (API 29) a través de Support Library y se adapta automáticamente a las capacidades del dispositivo.

FoldingFeature: trabajo con el pliegue del dispositivo

FoldingFeature es la clase central de Jetpack WindowManager para trabajar con dispositivos plegables. Encapsula toda la información sobre la posición física del pliegue: estado (HALF_OPENED, FLAT, TABLE_TOP), orientación (VERTICAL, HORIZONTAL), coordenadas de la bisagra y ángulo de apertura en grados.

Estados de FoldingFeature

La biblioteca define cuatro estados de pliegue. STATE_FLAT — el dispositivo está completamente desplegado, la pantalla está plana. STATE_HALF_OPENED — el dispositivo está parcialmente plegado, la pantalla está en un ángulo de 30 a 160 grados. STATE_TABLE_TOP — el dispositivo está sobre una superficie en posición de laptop. STATE_FULLY_OPENED — un estado obsoleto, reemplazado por FLAT en la versión 1.2.

Orientación y coordenadas del pliegue

El pliegue puede ser vertical (VERTICAL_FOLD) u horizontal (HORIZONTAL_FOLD). Bounds es un rectángulo que describe el área del pliegue en coordenadas de la ventana de la aplicación. El desarrollador usa estos datos para colocar elementos de la interfaz arriba y abajo del pliegue, evitando la superposición de contenido con el área crítica.

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 y WindowSizeClass

WindowMetrics es una API para obtener dimensiones precisas de la ventana de la aplicación, disponible desde WindowManager 1.0. A diferencia de Display#getSize, WindowMetrics tiene en cuenta el modo multi-ventana, DeX y la ventana de forma libre. Las métricas devuelven currentWindowMetrics (tamaño actual) y maximumWindowMetrics (tamaño máximo posible en el dispositivo).

WindowSizeClass es un clasificador que apareció en WindowManager 1.1. Divide las pantallas en tres categorías: Compact (ancho menor de 600dp — teléfono), Medium (600–840dp — tableta en orientación vertical) y Expanded (más de 840dp — tableta en horizontal). Esta clase simplifica el diseño adaptable reemplazando docenas de verificaciones de tamaño con una sola clasificación.

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

ScreenContinuityController y continuidad de pantalla

ScreenContinuityController es un componente de WindowManager responsable de preservar el estado de la Activity cuando cambia la configuración del dispositivo plegable. Cuando el usuario despliega o pliega el teléfono, el controlador notifica a la aplicación sobre la nueva postura y proporciona mecanismos para una transición suave.

El controlador registra oyentes a través de registerContinuityListener, que acepta un callback con un objeto FoldingFeature. En cada cambio de postura, el callback se ejecuta antes de la recreación de la Activity, dando al desarrollador la oportunidad de guardar el estado manualmente. Si la aplicación usa ViewModel, no se requiere manejo adicional — los datos se guardan automáticamente.

ScreenContinuity en Jetpack Compose

Las aplicaciones de Compose se benefician de ScreenContinuity a través de LocalWindowSizeClass y CompositionLocalProvider. Los componentes se recomponen automáticamente cuando cambian WindowMetrics. rememberSaveable preserva el estado entre recomposiciones, y Modifier.windowInsets tiene en cuenta las áreas del sistema de la pantalla.

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

Ejemplos de integración en Kotlin

Veamos un ejemplo completo de una Activity que usa Jetpack WindowManager para adaptar la interfaz a diferentes posturas de un dispositivo plegable. WindowManagerActivity se suscribe a los cambios de FoldingFeature a través de la API Flow y cambia entre diseños de un panel y dos paneles.

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

El ejemplo demuestra un escenario básico: la aplicación verifica WindowMetrics y selecciona un diseño de un panel o dos paneles. En proyectos reales, se recomienda usar WindowSizeClass para una adaptación más flexible y FoldingFeature para manejar dispositivos plegables. La biblioteca también admite seamless transition — animación suave al cambiar entre diseños.

Pruebas y depuración de WindowManager

Android Studio incluye herramientas integradas para probar Jetpack WindowManager. El emulador admite dispositivos plegables (Pixel Fold, Galaxy Z Fold) con cambio de postura a través de la pestaña Folding Postures. Layout Inspector muestra las WindowMetrics actuales y los límites de FoldingFeature en tiempo real.

Depuración mediante ADB

El comando adb shell dumpsys window displays muestra información sobre todas las pantallas conectadas y sus configuraciones. Para simular un pliegue, use adb shell am broadcast -a android.intent.action.SCREEN_ON con parámetros adicionales de postura. WindowManager registra todos los cambios de FoldingFeature a través de WindowManager#logState.

Errores comunes

Los principales problemas de integración — ignorar las actualizaciones de WindowMetrics en modo multi-ventana, manejo incorrecto de bounds con un pliegue vertical y falta de pruebas en todas las posturas. Se recomienda probar cada postura por separado y verificar el comportamiento al cambiar entre ellas. Usar WindowSizeClass en lugar de verificaciones manuales de tamaño reduce los errores en un 60%.