Screen Continuity: Was es ist, Fold-API und Schnittstellenanpassung

Was ist Screen Continuity?

Screen Continuity ist ein Android-Mechanismus, der den Activity-Zustand bei Änderung der physischen Bildschirmkonfiguration auf Faltgeräten bewahrt. Wenn der Benutzer das Telefon entfaltet oder faltet, kann das System die Activity mit neuen Fensterabmessungen neu starten. Die Kontinuität verhindert den Verlust von eingegebenen Daten, der Scrollposition und des aktuellen Bildschirms.

Im Gegensatz zu einer einfachen Bildschirmdrehung, bei der Android die Activity lediglich mit einer neuen Ausrichtung neu erstellt, führen Faltgeräte grundlegend neue Szenarien ein. Die Haltung HALF_OPENED ermöglicht der App, auf einem halben Bildschirm zu arbeiten, während FLAT im vollständig entfalteten Tablet-Modus arbeitet. Ohne Screen Continuity-Unterstützung setzt jede Haltungsänderung die Schnittstelle auf den Ausgangszustand zurück.

Laut Google I/O 2024 sind mehr als 62% der Faltgeräte-Nutzer auf Apps gestoßen, die den Zustandswechsel falsch behandeln. Screen Continuity löst dieses Problem auf API-Ebene und bietet dem Entwickler fertige Werkzeuge zum Speichern und Wiederherstellen der Benutzeroberfläche.

Zustände von Faltgeräten: Bildschirmhaltungen

Jetpack WindowManager definiert drei grundlegende Haltungen für Faltgeräte über die Klasse FoldingFeature. Jede Haltung entspricht einer bestimmten physischen Scharnierposition und erfordert eine spezielle Schnittstellenbehandlung.

HALF_OPENED — Halbgefalteter Zustand

Das Gerät befindet sich in einem Winkel von 30 bis 160 Grad. Der Bildschirm ist in zwei logische Bereiche geteilt. Die App kann Inhalte auf der oberen Hälfte und Steuerelemente auf der unteren Hälfte anzeigen. Der Tabletop-Modus für Videoanrufe und Mediaplayer verwendet diese Haltung.

FLAT — Vollständig entfalteter Zustand

Das Gerät ist um 180 Grad geöffnet und bildet einen einzigen großen Bildschirm. Die App wechselt in den Tablet-Modus mit einem vergrößerten Arbeitsbereich. In dieser Haltung wird empfohlen, ein Multi-Pane-Layout mit einem Navigationsbereich und detaillierten Inhalten nebeneinander anzuzeigen.

TABLE_TOP — Laptop-Haltung

Das Gerät steht auf einer Oberfläche in einem Winkel von etwa 120 Grad. Die untere Bildschirmhälfte dient als Touchpanel oder Tastatur. Der Touchpad-Modus in dieser Haltung ermöglicht die Emulation eines Trackpads auf dem unteren Teil des Bildschirms.

Wie funktioniert die Bildschirmkontinuität in Android?

Android behandelt Konfigurationsänderungen von Faltgeräten über den Mechanismus der Configuration Changes. Wenn der Benutzer das Telefon entfaltet, erkennt das System die Fenstergrößenänderung und startet den standardmäßigen Activity-Neuerstellungszyklus. Screen Continuity fängt diesen Prozess ab und speichert wichtige Daten.

Die Hauptmethode zum Speichern des Zustands ist onRetainNonConfigurationInstance, die vor der Zerstörung der Activity aufgerufen wird. Der Entwickler speichert darin das Datenmodell, die Listenposition und den aktuellen Navigationsbildschirm. Nach der Neuerstellung empfängt die Activity diese Daten über getLastNonConfigurationInstance und stellt die UI genau so wieder her, wie sie vor dem Falten war.

Für Fragments wird der Mechanismus über setRetainInstance(true) implementiert, der die Zerstörung des Fragments bei Konfigurationsänderungen verhindert. In Jetpack Compose wird rememberSaveable verwendet, das den Zustand bei Änderung der Window Metrics automatisch speichert.

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 Version 1.1+ enthält die Klasse ScreenContinuityController, die fertige Mechanismen zur Verwaltung der Bildschirmkontinuität bietet. Die API behandelt Haltungsänderungen automatisch und benachrichtigt die App über Callback-Schnittstellen.

ScreenContinuityController

Die zentrale Klasse, die Haltungsänderungs-Listener registriert. registerContinuityListener akzeptiert einen Callback, der bei jedem Übergang zwischen Faltgerätezuständen ausgelöst wird. Der Controller bietet auch Informationen über die aktuelle Haltung über die Methode getCurrentFoldingFeature.

FoldingFeatureAdapter

Eine Hilfsklasse zur Umwandlung von FoldingFeature-Daten in app-lesbare Zustände. FoldingFeatureAdapter normalisiert Scharnierkoordinaten und bestimmt, ob die aktuelle Haltung HALF_OPENED, FLAT oder TABLE_TOP ist. Dies erspart dem Entwickler manuelle Winkel- und Schwellwertberechnungen.

Integration mit Jetpack Compose

Für Compose-Apps bietet WindowManager WindowSizeClass und Modifikatoren, die die Faltung berücksichtigen. Die Komponente BoxWithConstraints passt sich in Echtzeit an Bildschirmgrößenänderungen ohne Activity-Neuerstellung an. Compose löst automatisch eine Neuzusammensetzung aus, wenn sich WindowMetrics ändern.

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

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

Implementierungsbeispiel in Kotlin

Betrachten wir ein vollständiges Activity-Beispiel mit Screen Continuity-Unterstützung. MainActivity behandelt drei Szenarien: Falten, Entfalten und halbgefalteten Zustand. Daten werden über onRetainNonConfigurationInstance gespeichert und bei der Neuerstellung wiederhergestellt.

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
)

Das Schlüsselelement ist die Klasse ContinuityState, die die Artikel liste und die Scrollposition speichert. Die Activity speichert sie vor der Neuerstellung und stellt sie sofort nach dem Aufruf von onCreate wieder her. Der WindowManager-Controller abonniert Haltungsänderungen und wechselt das Layout zwischen den Modi.

Testen der Kontinuität auf Emulator und Gerät

Android Studio bietet einen Faltgeräte-Emulator mit Unterstützung für alle drei Haltungen. Zum Testen von Screen Continuity erstellen Sie einfach ein virtuelles Gerät vom Typ Pixel Fold oder Samsung Galaxy Z Fold und wechseln die Haltungen über das Bedienfeld des Emulators.

Emulator-Einrichtung

Erstellen Sie ein AVD mit der Kategorie Foldable und wählen Sie eine 7,6-Zoll-Bildschirmauflösung. Öffnen Sie in den erweiterten Steuerelementen des Emulators die Registerkarte Folding Postures und wechseln Sie zwischen den Haltungen. Jeder Wechsel löst eine Configuration Change aus, die die App korrekt behandeln muss.

Physisches Gerät

Auf einem echten Gerät (Galaxy Z Fold 5, Pixel Fold) erfolgen Tests durch physisches Falten und Entfalten. Die Modi Samsung DeX und Multi-Window aktivieren ebenfalls die Kontinuität. Verwenden Sie zum Debuggen den ADB-Befehl adb shell dumpsys window policy, der den aktuellen Faltzustand anzeigt.

Häufige Probleme

Zu den Hauptfehlern gehören RecyclerView-Zustandsverlust, Zurücksetzen von Textfeldinhalten und Schließen von Dialogfenstern. ViewModel löst diese Probleme, indem es Daten unabhängig vom Activity-Lebenszyklus im Speicher hält. Wichtig ist auch, die Activity im Manifest mit dem Parameter android:configChanges zu annotieren, wenn die App Änderungen manuell behandelt.

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