Informuj o zwijaniu aplikacji

Duże rozłożone wyświetlacze i unikalne stany złożenia umożliwiają nowe sposoby korzystania z urządzeń składanych. Aby aplikacja rozpoznawała składanie w Jetpack Compose, użyj biblioteki Compose Material 3 Adaptive, która udostępnia interfejsy API do obsługi funkcji okien na urządzeniach składanych, takich jak zagięcia, zawiasy i pozycje urządzenia. Jeśli aplikacja rozpoznaje zgięcie, może dostosować układ, aby uniknąć umieszczania ważnych treści w obszarze zgięć lub zawiasów i używać ich jako naturalnych separatorów.

Wiedza o tym, czy urządzenie obsługuje konfiguracje takie jak tryb stołowy czy książkowy, może pomóc w podejmowaniu decyzji dotyczących obsługi różnych układów lub udostępniania określonych funkcji.

Informacje o oknie

W Jetpack Compose użyj funkcji typu „composable” collectFoldingFeaturesAsState(), aby obserwować informacje o składaniu okna. collectFoldingFeaturesAsState() zbiera bieżące funkcje składania okna z WindowInfoTracker do funkcji Compose State zawierającej listę obiektów FoldingFeature.

Funkcja collectFoldingFeaturesAsState() zwraca obiekt State, więc funkcje kompozycyjne są automatycznie rekomponowane, gdy zmienia się stan złożenia lub pozycja urządzenia, bez konieczności ręcznego zarządzania cyklem życia lub pobierania danych z przepływu:

@Composable
fun FoldAwareScreen() {
    val foldingFeatures by collectFoldingFeaturesAsState()

    // Access folding features for the current window.
    val foldFeature = foldingFeatures.firstOrNull()
    if (foldFeature != null) {
        // Adapt layout based on the fold feature.
    }
}

Funkcje składanych wyświetlaczy

Lista elementów FoldingFeature zwracanych przez collectFoldingFeaturesAsState() (podtyp DisplayFeature) zawiera informacje o składanych wyświetlaczach, w tym te właściwości:

  • state: stan złożenia urządzenia, FLAT lub HALF_OPENED

  • orientation: orientacja zgięcia lub zawiasu, HORIZONTAL lub VERTICAL

  • occlusionType: czy zagięcie lub zawias zasłania część wyświetlacza, NONE lub FULL.

  • isSeparating: czy zagięcie lub zawias tworzy 2 logiczne obszary wyświetlania (prawda lub fałsz)

Urządzenie składane, które jest HALF_OPENED, zawsze zgłasza isSeparating jako wartość „prawda”, ponieważ ekran jest podzielony na 2 obszary wyświetlania. Ponadto isSeparating ma zawsze wartość „true” na urządzeniu z 2 ekranami, gdy aplikacja obejmuje oba ekrany.

Właściwość FoldingFeature bounds (dziedziczona z DisplayFeature) reprezentuje prostokąt ograniczający elementu składanego, takiego jak zagięcie lub zawias. Granice mogą służyć do pozycjonowania elementów na ekranie względem obiektu:

@Composable
fun FoldFeatureDemo() {
    val foldingFeatures by collectFoldingFeaturesAsState()
    val foldFeature = foldingFeatures.firstOrNull()

    if (foldFeature != null) {
        val isSeparating = foldFeature.isSeparating
        val occlusionType = foldFeature.occlusionType
        val bounds = foldFeature.bounds
        // Use bounds and properties to position content.
    }
}

Tryb na stole

Korzystając z informacji zawartych w obiekcie FoldingFeature, aplikacja może obsługiwać pozycje takie jak tryb stołu, w którym telefon leży na powierzchni, zawias jest w pozycji poziomej, a składany ekran jest otwarty do połowy.

Tryb stołowy umożliwia użytkownikom wygodne korzystanie z telefonu bez konieczności trzymania go w rękach. Tryb stołu świetnie sprawdza się podczas oglądania multimediów, robienia zdjęć i prowadzenia rozmów wideo.

Aplikacja odtwarzacza wideo w trybie na stole z odtwarzaniem filmu w pionowej części ekranu i elementami sterującymi odtwarzaniem w dolnej, poziomej części.
Rysunek 1. Aplikacja odtwarzacza wideo w trybie na stole – film jest wyświetlany na pionowej części ekranu, a elementy sterujące odtwarzaniem na części poziomej.

Użyj FoldingFeature.State i FoldingFeature.Orientation z collectFoldingFeaturesAsState(), aby określić, czy urządzenie jest w pozycji na stole:

@Composable
fun TabletopContent() {
    val foldingFeatures by collectFoldingFeaturesAsState()
    val foldFeature = foldingFeatures.firstOrNull()

    val isTableTopPosture = foldFeature != null &&
        foldFeature.state == FoldingFeature.State.HALF_OPENED &&
        foldFeature.orientation == FoldingFeature.Orientation.HORIZONTAL

    if (isTableTopPosture) {
        // Tabletop layout: separate content and controls across the fold.
    } else {
        // Standard layout.
    }
}

Możesz też sprawdzić, czy okno jest w trybie na stole, sprawdzając właściwość Posture zwracaną przez currentWindowAdaptiveInfoV2():

val adaptiveInfo = currentWindowAdaptiveInfoV2()
val isTabletop = adaptiveInfo.windowPosture.isTabletop

Gdy już wiesz, że urządzenie jest w pozycji na stole, odpowiednio zaktualizuj układ aplikacji. W przypadku aplikacji do multimediów oznacza to zwykle umieszczenie odtwarzania w części strony widocznej na ekranie, a elementów sterujących i dodatkowych treści tuż pod nim, aby umożliwić oglądanie lub słuchanie bez użycia rąk.

Przykłady

Pozycja książki

Inną unikalną funkcją składanego urządzenia jest tryb książki, w którym urządzenie jest do połowy otwarte, a zawias jest ustawiony pionowo. Układ książki świetnie sprawdza się podczas czytania e-booków. Dzięki układowi dwustronicowemu na dużym ekranie urządzenia składanego, które otwiera się jak oprawiona książka, tryb książki pozwala na czytanie jak w przypadku prawdziwej książki.

Można go też używać do robienia zdjęć, jeśli chcesz uchwycić inny format obrazu, robiąc zdjęcia bez użycia rąk.

Zaimplementuj tryb książki, korzystając z tych samych technik co w przypadku trybu na stole. Sprawdź, czy orientacja funkcji składania jest pionowa, a nie pozioma:

@Composable
fun BookContent() {
    val foldingFeatures by collectFoldingFeaturesAsState()
    val foldFeature = foldingFeatures.firstOrNull()

    val isBookPosture = foldFeature != null &&
        foldFeature.state == FoldingFeature.State.HALF_OPENED &&
        foldFeature.orientation == FoldingFeature.Orientation.VERTICAL

    if (isBookPosture) {
        // Book posture layout: two-page layout across the vertical fold.
    } else {
        // Standard single-page layout.
    }
}

Zmiany rozmiaru okna

Obszar wyświetlania aplikacji może się zmieniać w wyniku zmiany konfiguracji urządzenia, np. gdy urządzenie jest złożone lub rozłożone, obrócone lub gdy jego rozmiar został zmieniony w trybie wielu okien.

Aby pobrać bieżącą klasę rozmiaru okna i dostosować się do zmian rozmiaru w Jetpack Compose, użyj funkcji typu „composable” currentWindowAdaptiveInfoV2() z biblioteki Compose Material 3 Adaptive. currentWindowAdaptiveInfoV2() zwraca instancję WindowAdaptiveInfo, która udostępnia WindowSizeClass bieżącego okna (domyślnie z obsługą dużych i bardzo dużych punktów przerwania), a także windowPosture urządzenia:

@Composable
fun AdaptiveApp() {
    val adaptiveInfo = currentWindowAdaptiveInfoV2()
    val windowSizeClass = adaptiveInfo.windowSizeClass

    when {
        windowSizeClass.isWidthAtLeastBreakpoint(
            WIDTH_DP_EXPANDED_LOWER_BOUND
        ) -> {
            // Expanded layout
        }
        windowSizeClass.isWidthAtLeastBreakpoint(
            WIDTH_DP_MEDIUM_LOWER_BOUND
        ) -> {
            // Medium layout
        }
        else -> {
            // Compact layout
        }
    }
}

Zobacz Korzystanie z klas rozmiarów okien.

Dodatkowe materiały

Więcej informacji o układach uwzględniających zgięcie i urządzeniach składanych znajdziesz w tych materiałach:

Przykłady

  • Przykładowa aplikacja Jetpack WindowManager: przykład użycia biblioteki Jetpack WindowManager.
  • Jetcaster: implementacja pozycji na stole za pomocą Compose

Codelabs