Screen Continuity: wat is het, vouw-API en aanpassing van de interface

Wat is Screen Continuity?

Screen Continuity is een Android-mechanisme dat de Activity-status behoudt bij wijziging van de fysieke configuratie van het scherm op opvouwbare apparaten. Wanneer de gebruiker de telefoon uitvouwt of opvouwt, kan het systeem de Activity herstarten met nieuwe vensterafmetingen. Continuïteit voorkomt verlies van ingevoerde gegevens, scrollpositie en het huidige scherm.

In tegenstelling tot gewone schermrotatie, waarbij Android eenvoudigweg de Activity opnieuw aanmaakt met een nieuwe oriëntatie, introduceren opvouwbare apparaten volledig nieuwe scenario's. De HALF_OPENED-houding stelt de applicatie in staat op een half scherm te werken, en FLAT — in volledig uitgevouwen tabletmodus. Zonder ondersteuning voor Screen Continuity reset elke houdingsverandering de interface naar de begintoestand.

Volgens Google I/O 2024 heeft meer dan 62% van de gebruikers van opvouwbare apparaten te maken gehad met applicaties die het schakelen tussen toestanden niet correct afhandelen. Screen Continuity lost dit probleem op API-niveau op en biedt de ontwikkelaar kant-en-klare hulpmiddelen voor het opslaan en herstellen van de UI.

Toestanden van opvouwbare apparaten: schermhoudingen

Jetpack WindowManager definieert drie basishoudingen van een opvouwbaar apparaat via de klasse FoldingFeature. Elke houding komt overeen met een bepaalde fysieke positie van het scharnier en vereist een speciale verwerking van de interface.

HALF_OPENED — halfgeopende toestand

Het apparaat bevindt zich onder een hoek van 30 tot 160 graden. Het scherm is verdeeld in twee logische gebieden. De applicatie kan inhoud op de bovenste helft en bedieningselementen op de onderste helft weergeven. Tabletop-modus voor videogesprekken en mediaspelers gebruikt precies deze houding.

FLAT — volledig uitgevouwen toestand

Het apparaat is 180 graden geopend en vormt één groot scherm. De applicatie gaat over in de tabletmodus met een vergroot werkgebied. In deze houding wordt aanbevolen een multi-paneel lay-out te tonen met navigatiebalk en gedetailleerde inhoud naast elkaar.

TABLE_TOP — laptop-houding

Het apparaat staat op een oppervlak onder een hoek van ongeveer 120 graden. De onderste helft van het scherm dient als touchscreen of toetsenbord. Touchpad-modus in deze houding maakt het mogelijk een trackpad op het onderste deel van het scherm te emuleren.

Hoe werkt schermcontinuïteit in Android?

Android verwerkt de configuratiewijziging van een opvouwbaar apparaat via het mechanisme van configuration changes. Wanneer de gebruiker de telefoon uitvouwt, registreert het systeem de verandering van de venstergrootte en start de standaardcyclus van het opnieuw aanmaken van de Activity. Screen Continuity onderschept dit proces en slaat de belangrijkste gegevens op.

De belangrijkste methode voor het opslaan van de status is onRetainNonConfigurationInstance, die wordt aangeroepen voordat de Activity wordt vernietigd. De ontwikkelaar slaat hierin het datamodel, de lijstpositie en het huidige navigatiescherm op. Na het opnieuw aanmaken ontvangt de Activity deze gegevens via getLastNonConfigurationInstance en herstelt de UI exact tot het moment van vouwen.

Voor Fragments is het mechanisme geïmplementeerd via setRetainInstance(true), dat vernietiging van de fragment bij configuratiewijziging voorkomt. In Jetpack Compose wordt rememberSaveable gebruikt, dat automatisch de status opslaat bij wijziging van 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 in Jetpack WindowManager

Jetpack WindowManager versie 1.1+ bevat de klasse ScreenContinuityController, die kant-en-klare mechanismen biedt voor het beheren van schermcontinuïteit. De API verwerkt automatisch de houdingsverandering en stelt de applicatie op de hoogte via callback-interfaces.

ScreenContinuityController

Centrale klasse die luisteraars voor houdingsverandering registreert. registerContinuityListener accepteert een callback die wordt geactiveerd bij elke overgang tussen toestanden van het opvouwbare apparaat. De controller biedt ook informatie over de huidige houding via de methode getCurrentFoldingFeature.

FoldingFeatureAdapter

Hulpklasse voor het omzetten van FoldingFeature-gegevens naar voor de applicatie begrijpelijke toestanden. FoldingFeatureAdapter normaliseert de coördinaten van het scharnier en bepaalt of de huidige houding HALF_OPENED, FLAT of TABLE_TOP is. Dit bespaart de ontwikkelaar het handmatig berekenen van hoeken en drempelwaarden.

Integratie met Jetpack Compose

Voor Compose-applicaties biedt WindowManager WindowSizeClass en modificatoren die rekening houden met het vouwen. De component BoxWithConstraints past zich in realtime aan veranderingen van de schermafmetingen aan zonder de Activity opnieuw aan te maken. Compose activeert automatisch recompositie bij wijziging van 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()
    }
}

Voorbeeldimplementatie in Kotlin

Laten we een volledig voorbeeld van een Activity met ondersteuning voor Screen Continuity bekijken. MainActivity verwerkt drie scenario's: vouwen, uitvouwen en halfgeopende toestand. Gegevens worden opgeslagen via onRetainNonConfigurationInstance en hersteld bij opnieuw aanmaken.

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
)

Het belangrijkste element is de klasse ContinuityState, die de lijst met elementen en de scrollpositie opslaat. De Activity slaat deze op voor het opnieuw aanmaken en herstelt deze direct na het aanroepen van onCreate. De WindowManager-controller abonneert zich op houdingsveranderingen en schakelt de lay-out tussen modi.

Testen van continuïteit op emulator en apparaat

Android Studio biedt een emulator van een opvouwbaar apparaat met ondersteuning voor alle drie de houdingen. Voor het testen van Screen Continuity volstaat het een virtueel apparaat van het type Pixel Fold of Samsung Galaxy Z Fold te maken en de houding te wijzigen via het bedieningspaneel van de emulator.

Emulator instellen

Maak een AVD aan met de categorie Foldable en kies een resolutie van een 7,6-inch scherm. Open in de uitgebreide bediening van de emulator het tabblad Folding Postures en schakel tussen houdingen. Elke schakeling activeert een configuration change die correct door de applicatie moet worden verwerkt.

Fysiek apparaat

Op een echt apparaat (Galaxy Z Fold 5, Pixel Fold) wordt het testen uitgevoerd door het fysiek uitvouwen. Samsung DeX en Multi-Window-modi activeren ook de continuïteit. Gebruik voor het debuggen het ADB-commando adb shell dumpsys window policy, dat de huidige vouwstatus weergeeft.

Typische problemen

De belangrijkste fouten — verlies van de RecyclerView-status, resetten van tekst in tekstvelden en sluiten van dialoogvensters. ViewModel lost deze problemen op door gegevens in het geheugen te bewaren onafhankelijk van de levenscyclus van de Activity. Het is ook belangrijk de Activity in het manifest te annoteren met de parameter android:configChanges als de applicatie wijzigingen handmatig verwerkt.

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