Screen Continuity: cos'è, API di piega e adattamento dell'interfaccia

Cos'è Screen Continuity?

Screen Continuity è un meccanismo Android che preserva lo stato dell'Activity quando la configurazione fisica dello schermo cambia sui dispositivi pieghevoli. Quando l'utente dispiega o piega il telefono, il sistema può riavviare l'Activity con nuove dimensioni della finestra. La continuità impedisce la perdita di dati inseriti, posizione di scorrimento e schermata corrente.

A differenza di una semplice rotazione dello schermo dove Android ricrea semplicemente l'Activity con un nuovo orientamento, i dispositivi pieghevoli introducono scenari fondamentalmente nuovi. La postura HALF_OPENED consente all'app di funzionare su mezzo schermo, mentre FLAT opera in modalità tablet completamente dispiegata. Senza il supporto di Screen Continuity, ogni cambio di postura reimposta l'interfaccia allo stato iniziale.

Secondo Google I/O 2024, più del 62% degli utenti di dispositivi pieghevoli ha incontrato app che gestiscono in modo errato il cambio di stato. Screen Continuity risolve questo problema a livello di API, fornendo allo sviluppatore strumenti pronti per salvare e ripristinare l'interfaccia utente.

Stati dei dispositivi pieghevoli: posture dello schermo

Jetpack WindowManager definisce tre posture di base per i dispositivi pieghevoli attraverso la classe FoldingFeature. Ogni postura corrisponde a una specifica posizione fisica della cerniera e richiede una gestione speciale dell'interfaccia.

HALF_OPENED — Stato semipiegato

Il dispositivo è a un angolo da 30 a 160 gradi. Lo schermo è diviso in due aree logiche. L'app può visualizzare contenuti sulla metà superiore e controlli sulla metà inferiore. La modalità tabletop per videochiamate e lettori multimediali utilizza questa postura.

FLAT — Stato completamente dispiegato

Il dispositivo è aperto a 180 gradi, formando un unico grande schermo. L'app passa alla modalità tablet con un'area di lavoro ampliata. In questa postura, si consiglia di mostrare un layout multi-pannello con un pannello di navigazione e contenuti dettagliati affiancati.

TABLE_TOP — Postura da laptop

Il dispositivo poggia su una superficie a un angolo di circa 120 gradi. La metà inferiore dello schermo funge da pannello tattile o tastiera. La modalità touchpad in questa postura consente di emulare un trackpad sulla parte inferiore dello schermo.

Come funziona la continuità dello schermo in Android?

Android gestisce i cambiamenti di configurazione dei dispositivi pieghevoli attraverso il meccanismo dei configuration changes. Quando l'utente dispiega il telefono, il sistema rileva il cambiamento di dimensione della finestra e avvia il ciclo standard di ricreazione dell'Activity. Screen Continuity intercetta questo processo e salva i dati chiave.

Il metodo principale per salvare lo stato è onRetainNonConfigurationInstance, che viene chiamato prima che l'Activity venga distrutta. Lo sviluppatore vi salva il modello dati, la posizione dell'elenco e la schermata di navigazione corrente. Dopo la ricreazione, l'Activity riceve questi dati tramite getLastNonConfigurationInstance e ripristina l'interfaccia esattamente come prima della piegatura.

Per i Fragment, il meccanismo è implementato tramite setRetainInstance(true), che impedisce la distruzione del fragment durante i cambiamenti di configurazione. In Jetpack Compose si usa rememberSaveable, che salva automaticamente lo stato quando cambiano le 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 in Jetpack WindowManager

Jetpack WindowManager versione 1.1+ include la classe ScreenContinuityController, che fornisce meccanismi pronti per gestire la continuità dello schermo. L'API gestisce automaticamente i cambiamenti di postura e notifica l'app attraverso interfacce callback.

ScreenContinuityController

La classe centrale che registra gli ascoltatori di cambiamento di postura. registerContinuityListener accetta un callback che si attiva a ogni transizione tra gli stati del dispositivo pieghevole. Il controller fornisce anche informazioni sulla postura corrente tramite il metodo getCurrentFoldingFeature.

FoldingFeatureAdapter

Una classe di utilità per trasformare i dati FoldingFeature in stati leggibili dall'app. FoldingFeatureAdapter normalizza le coordinate della cerniera e determina se la postura corrente è HALF_OPENED, FLAT o TABLE_TOP. Questo evita allo sviluppatore di calcolare manualmente angoli e soglie.

Integrazione con Jetpack Compose

Per le app Compose, WindowManager fornisce WindowSizeClass e modificatori che tengono conto della piega. Il componente BoxWithConstraints si adatta ai cambiamenti di dimensione dello schermo in tempo reale senza ricreazione dell'Activity. Compose attiva automaticamente la ricomposizione quando cambiano le 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()
    }
}

Esempio di implementazione in Kotlin

Vediamo un esempio completo di Activity con supporto di Screen Continuity. MainActivity gestisce tre scenari: piegatura, dispiegamento e stato semipiegato. I dati vengono salvati tramite onRetainNonConfigurationInstance e ripristinati alla ricreazione.

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'elemento chiave è la classe ContinuityState, che memorizza l'elenco degli elementi e la posizione di scorrimento. L'Activity la salva prima della ricreazione e la ripristina immediatamente dopo la chiamata a onCreate. Il controller WindowManager si sottoscrive ai cambiamenti di postura e commuta il layout tra le modalità.

Test della continuità su emulatore e dispositivo

Android Studio fornisce un emulatore di dispositivo pieghevole con supporto per tutte e tre le posture. Per testare Screen Continuity, basta creare un dispositivo virtuale di tipo Pixel Fold o Samsung Galaxy Z Fold e cambiare postura tramite il pannello di controllo dell'emulatore.

Configurazione dell'emulatore

Crea un AVD con la categoria Foldable e seleziona una risoluzione dello schermo da 7,6 pollici. Nei controlli estesi dell'emulatore, apri la scheda Folding Postures e passa da una postura all'altra. Ogni passaggio attiva un configuration change che l'app deve gestire correttamente.

Dispositivo fisico

Su un dispositivo reale (Galaxy Z Fold 5, Pixel Fold), il test viene eseguito piegando e dispiegando fisicamente. Le modalità Samsung DeX e Multi-Window attivano anch'esse la continuità. Per il debug, usa il comando ADB adb shell dumpsys window policy, che mostra lo stato attuale della piega.

Problemi comuni

Gli errori principali includono la perdita di stato della RecyclerView, il reset del testo nei campi di testo e la chiusura delle finestre di dialogo. ViewModel risolve questi problemi mantenendo i dati in memoria indipendentemente dal ciclo di vita dell'Activity. È importante anche annotare l'Activity nel manifest con il parametro android:configChanges se l'app gestisce manualmente i cambiamenti.

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