Screen Continuity: qué es, API de pliegue y adaptación de interfaz

¿Qué es Screen Continuity?

Screen Continuity es un mecanismo de Android que preserva el estado de la Activity cuando cambia la configuración física de la pantalla en dispositivos plegables. Cuando el usuario despliega o pliega el teléfono, el sistema puede reiniciar la Activity con nuevas dimensiones de ventana. La continuidad evita la pérdida de datos ingresados, la posición de desplazamiento y la pantalla actual.

A diferencia de una simple rotación de pantalla donde Android solo recrea la Activity con una nueva orientación, los dispositivos plegables introducen escenarios fundamentalmente nuevos. La postura HALF_OPENED permite que la aplicación funcione en media pantalla, mientras que FLAT opera en modo tableta completamente desplegado. Sin soporte de Screen Continuity, cada cambio de postura restablece la interfaz a su estado inicial.

Según Google I/O 2024, más del 62% de los usuarios de dispositivos plegables se han encontrado con aplicaciones que manejan incorrectamente el cambio de estado. Screen Continuity resuelve este problema a nivel de API, proporcionando al desarrollador herramientas listas para guardar y restaurar la interfaz de usuario.

Estados de dispositivos plegables: posturas de pantalla

Jetpack WindowManager define tres posturas básicas para dispositivos plegables a través de la clase FoldingFeature. Cada postura corresponde a una posición física específica de la bisagra y requiere un manejo especial de la interfaz.

HALF_OPENED — Estado semiplegado

El dispositivo está en un ángulo de 30 a 160 grados. La pantalla se divide en dos áreas lógicas. La aplicación puede mostrar contenido en la mitad superior y controles en la inferior. Modo tabletop para videollamadas y reproductores multimedia utiliza esta postura.

FLAT — Estado completamente desplegado

El dispositivo está abierto 180 grados, formando una sola pantalla grande. La aplicación cambia al modo tableta con un área de trabajo ampliada. En esta postura, se recomienda mostrar un diseño de múltiples paneles con un panel de navegación y contenido detallado lado a lado.

TABLE_TOP — Postura de laptop

El dispositivo se apoya en una superficie en un ángulo de aproximadamente 120 grados. La mitad inferior de la pantalla sirve como panel táctil o teclado. Modo touchpad en esta postura permite emular un trackpad en la parte inferior de la pantalla.

¿Cómo funciona la continuidad de pantalla en Android?

Android maneja los cambios de configuración de dispositivos plegables a través del mecanismo de configuration changes. Cuando el usuario despliega el teléfono, el sistema detecta el cambio de tamaño de ventana e inicia el ciclo estándar de recreación de la Activity. Screen Continuity intercepta este proceso y guarda los datos clave.

El método principal para guardar el estado es onRetainNonConfigurationInstance, que se llama antes de que la Activity sea destruida. El desarrollador guarda en él el modelo de datos, la posición de la lista y la pantalla de navegación actual. Después de la recreación, la Activity recibe estos datos a través de getLastNonConfigurationInstance y restaura la interfaz exactamente como estaba antes de plegar.

Para Fragments, el mecanismo se implementa mediante setRetainInstance(true), que evita que el fragmento sea destruido en cambios de configuración. En Jetpack Compose se usa rememberSaveable, que guarda automáticamente el estado cuando cambian las 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 en Jetpack WindowManager

Jetpack WindowManager versión 1.1+ incluye la clase ScreenContinuityController, que proporciona mecanismos listos para gestionar la continuidad de pantalla. La API maneja automáticamente los cambios de postura y notifica a la aplicación a través de interfaces callback.

ScreenContinuityController

La clase central que registra oyentes de cambios de postura. registerContinuityListener acepta un callback que se dispara en cada transición entre estados del dispositivo plegable. El controlador también proporciona información sobre la postura actual a través del método getCurrentFoldingFeature.

FoldingFeatureAdapter

Una clase de utilidad para transformar datos de FoldingFeature en estados legibles por la aplicación. FoldingFeatureAdapter normaliza las coordenadas de la bisagra y determina si la postura actual es HALF_OPENED, FLAT o TABLE_TOP. Esto evita que el desarrollador tenga que calcular ángulos y umbrales manualmente.

Integración con Jetpack Compose

Para aplicaciones Compose, WindowManager proporciona WindowSizeClass y modificadores que tienen en cuenta el pliegue. El componente BoxWithConstraints se adapta a los cambios de tamaño de pantalla en tiempo real sin recreación de la Activity. Compose activa automáticamente la recomposición cuando cambian las WindowMetrics.

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

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

Ejemplo de implementación en Kotlin

Veamos un ejemplo completo de Activity con soporte de Screen Continuity. MainActivity maneja tres escenarios: plegado, desplegado y estado semiplegado. Los datos se guardan mediante onRetainNonConfigurationInstance y se restauran al recrearse.

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
)

El elemento clave es la clase ContinuityState, que almacena la lista de elementos y la posición de desplazamiento. La Activity la guarda antes de la recreación y la restaura inmediatamente después de llamar a onCreate. El controlador WindowManager se suscribe a los cambios de postura y cambia el diseño entre modos.

Pruebas de continuidad en emulador y dispositivo

Android Studio proporciona un emulador de dispositivo plegable con soporte para las tres posturas. Para probar Screen Continuity, simplemente crea un dispositivo virtual de tipo Pixel Fold o Samsung Galaxy Z Fold y cambia de postura usando el panel de control del emulador.

Configuración del emulador

Crea un AVD con la categoría Foldable y selecciona una resolución de pantalla de 7.6 pulgadas. En los controles extendidos del emulador, abre la pestaña Folding Postures y cambia entre posturas. Cada cambio activa un configuration change que la aplicación debe manejar correctamente.

Dispositivo físico

En un dispositivo real (Galaxy Z Fold 5, Pixel Fold), las pruebas se realizan plegando y desplegando físicamente. Los modos Samsung DeX y Multi-Window también activan la continuidad. Para depuración, usa el comando ADB adb shell dumpsys window policy, que muestra el estado actual del pliegue.

Problemas comunes

Los principales errores incluyen pérdida de estado de RecyclerView, reinicio de texto en campos de texto y cierre de ventanas de diálogo. ViewModel resuelve estos problemas manteniendo los datos en memoria independientemente del ciclo de vida de la Activity. También es importante anotar la Activity en el manifiesto con el parámetro android:configChanges si la aplicación maneja los cambios manualmente.

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