Screen Continuity: vad är det, viknings-API och anpassning av gränssnitt

Vad är Screen Continuity?

Screen Continuity är en Android-mekanism som bevarar Activity-tillståndet vid ändring av fysisk skärmkonfiguration på vikbara enheter. När användaren fäller ut eller viker ihop telefonen kan systemet starta om Activity med nya fönsterdimensioner. Kontinuitet förhindrar förlust av inmatade data, scrollposition och aktuell skärm.

Till skillnad från vanlig skärmrotation, där Android helt enkelt återskapar Activity med ny orientering, introducerar vikbara enheter helt nya scenarier. Pos HALF_OPENED gör att applikationen kan fungera på en halv skärm, och FLAT — i fullt utfälldt tablet-läge. Utan stöd för Screen Continuity återställer varje posändring gränssnittet till ursprungligt tillstånd.

Enligt Google I/O 2024 har över 62% av användare av vikbara enheter stött på applikationer som inte korrekt hanterar växling mellan tillstånd. Screen Continuity löser detta problem på API-nivå och ger utvecklaren färdiga verktyg för att spara och återställa UI.

Tillstånd för vikbara enheter: skärmposer

Jetpack WindowManager definierar tre grundlägganden poser för en vikbar enhet genom klassen FoldingFeature. Varje pos motsvarar en viss fysisk position av gångjärnet och kräver särskild hantering av gränssnittet.

HALF_OPENED — halvöppet tillstånd

Enheten befinner sig i en vinkel på 30 till 160 grader. Skärmen är uppdelad i två logiska områden. Applikationen kan visa innehåll på den övre halvan och kontroller på den nedre halvan. Tabletop-läge för videosamtal och mediaspelare använder just denna pos.

FLAT — fullt utfälld tillstånd

Enheten är öppen 180 grader och bildar en enda stor skärm. Applikationen går över till tablet-läge med förstorad arbetsyta. I denna pos rekommenderas att visa en flerpanelslayout med navigeringsfält och detaljerat innehåll sida vid sida.

TABLE_TOP — laptop-pos

Enheten står på en yta i en vinkel på cirka 120 grader. Den nedre halvan av skärmen fungerar som touchpanel eller tangentbord. Touchpad-läge i denna pos gör det möjligt att emulera en styrplatta på den nedre delen av skärmen.

Hur fungerar skärmkontinuitet i Android?

Android hanterar konfigurationsändring av en vikbar enhet genom mekanismen configuration changes. När användaren fäller ut telefonen registrerar systemet ändringen av fönsterstorlek och startar standardcykeln för återskapande av Activity. Screen Continuity fångar upp denna process och sparar nyckeldata.

Huvudmetoden för att spara tillstånd är onRetainNonConfigurationInstance, som anropas innan Activity förstörs. Utvecklaren sparar i den datamodell, listposition och aktuell navigeringsskärm. Efter återskapande får Activity dessa data via getLastNonConfigurationInstance och återställer UI exakt till vikningsögonblicket.

För Fragments implementeras mekanismen via setRetainInstance(true), som förhindrar förstörelse av fragment vid konfigurationsändring. I Jetpack Compose används rememberSaveable, som automatiskt sparar tillstånd vid ändring av 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 }
    }
}

ScreenContinuity API i Jetpack WindowManager

Jetpack WindowManager version 1.1+ innehåller klassen ScreenContinuityController som tillhandahåller färdiga mekanismer för hantering av skärmkontinuitet. API:et hanterar automatiskt posändring och meddelar applikationen via callback-gränssnitt.

ScreenContinuityController

Central klass som registrerar lyssnare för posändring. registerContinuityListener accepterar en callback som utlöses vid varje övergång mellan tillstånd hos den vikbara enheten. Kontrollern ger också information om aktuell pos via metoden getCurrentFoldingFeature.

FoldingFeatureAdapter

Hjälpklass för att omvandla FoldingFeature-data till tillstånd som är förståeliga för applikationen. FoldingFeatureAdapter normaliserar gångjärnets koordinater och avgör om aktuell pos är HALF_OPENED, FLAT eller TABLE_TOP. Detta befriar utvecklaren från manuell beräkning av vinklar och tröskelvärden.

Integration med Jetpack Compose

För Compose-applikationer tillhandahåller WindowManager WindowSizeClass och modifierare som tar hänsyn till vikning. Komponenten BoxWithConstraints anpassar sig till ändringar av skärmdimensioner i realtid utan att återskapa Activity. Compose utlöser automatiskt recomposition vid ändring av 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()
    }
}

Exempel på implementering i Kotlin

Låt oss titta på ett komplett exempel på Activity med stöd för Screen Continuity. MainActivity hanterar tre scenarier: vikning, utfällning och halvöppet tillstånd. Data sparas via onRetainNonConfigurationInstance och återställs vid återskapande.

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
)

Nyckelelementet är klassen ContinuityState, som lagrar listan över element och scrollposition. Activity sparar den före återskapande och återställer den omedelbart efter anrop av onCreate. WindowManager-kontrollern prenumererar på posändringar och växlar layout mellan lägen.

Testning av kontinuitet på emulator och enhet

Android Studio tillhandahåller emulator för vikbar enhet med stöd för alla tre poser. För att testa Screen Continuity räcker det att skapa en virtuell enhet av typen Pixel Fold eller Samsung Galaxy Z Fold och växla pos via emulatorns kontrollpanel.

Konfigurera emulatorn

Skapa en AVD med kategorin Foldable och välj upplösning för en 7,6-tums skärm. I emulatorns utökade kontroller öppnar du fliken Folding Postures och växlar mellan poser. Varje växling utlöser en configuration change som applikationen bör hantera korrekt.

Fysisk enhet

På en verklig enhet (Galaxy Z Fold 5, Pixel Fold) utförs testning genom fysisk utfällning. Samsung DeX och Multi-Window-lägen aktiverar också kontinuitet. För felsökning använd ADB-kommandot adb shell dumpsys window policy, som visar aktuellt vikningsstatus.

Typiska problem

Huvudfelen — förlust av RecyclerView-tillstånd, återställning av text i textfält och stängning av dialogrutor. ViewModel löser dessa problem genom att lagra data i minnet oberoende av Activitys livscykel. Det är också viktigt att annotera Activity i manifestet med parametern android:configChanges om applikationen hanterar ändringar manuellt.

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