Fai conoscere l'app

I grandi display aperti e gli stati piegati unici consentono nuove esperienze utente sui dispositivi pieghevoli. Per rendere la tua app compatibile con i dispositivi pieghevoli in Jetpack Compose, utilizza la libreria Compose Material 3 Adaptive, che fornisce API per le funzionalità delle finestre dei dispositivi pieghevoli, come pieghe, cerniere e posizioni del dispositivo. Quando l'app è compatibile con la piegatura, può adattare il layout per evitare di posizionare contenuti importanti nell'area delle pieghe o delle cerniere e utilizzare queste ultime come separatori naturali.

Sapere se un dispositivo supporta configurazioni come la modalità da tavolo o a libro può guidare le decisioni relative al supporto di layout diversi o alla fornitura di funzionalità specifiche.

Informazioni sulla finestra

In Jetpack Compose, utilizza la funzione componibile collectFoldingFeaturesAsState() per osservare le informazioni sulla piegatura della finestra. collectFoldingFeaturesAsState() raccoglie le funzionalità di piegatura della finestra corrente da WindowInfoTracker in un State di Compose contenente un elenco di oggetti FoldingFeature.

Poiché collectFoldingFeaturesAsState() restituisce un State di Compose, i tuoi componibili vengono ricomposti automaticamente ogni volta che lo stato di piegatura o la postura del dispositivo cambiano, senza richiedere la gestione manuale del ciclo di vita o la raccolta di flussi:

@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.
    }
}

Funzionalità dei display pieghevoli

L'elenco di elementi FoldingFeature restituiti da collectFoldingFeaturesAsState() (un sottotipo di DisplayFeature) fornisce informazioni sui display pieghevoli, incluse le seguenti proprietà:

  • state: lo stato di piegatura del dispositivo, FLAT o HALF_OPENED

  • orientation: l'orientamento della piega o della cerniera, HORIZONTAL o VERTICAL

  • occlusionType: indica se la piega o la cerniera nasconde parte del display, NONE o FULL

  • isSeparating: indica se la piega o la cerniera crea due aree di visualizzazione logiche, true o false

Un dispositivo pieghevole HALF_OPENED segnala sempre isSeparating come true perché lo schermo è separato in due aree di visualizzazione. Inoltre, isSeparating è sempre true su un dispositivo con doppio schermo quando l'applicazione si estende su entrambi gli schermi.

La proprietà FoldingFeature bounds (ereditata da DisplayFeature) rappresenta il rettangolo di delimitazione di una funzionalità di piegatura, ad esempio una piega o una cerniera. I limiti possono essere utilizzati per posizionare gli elementi sullo schermo in relazione alla caratteristica:

@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.
    }
}

Posizione da tavolo

Utilizzando le informazioni incluse nell'oggetto FoldingFeature, la tua app può supportare posizioni come quella da tavolo, in cui lo smartphone è appoggiato su una superficie, la cerniera è in posizione orizzontale e lo schermo pieghevole è aperto a metà.

La posizione da tavolo offre agli utenti la comodità di utilizzare lo smartphone senza tenerlo in mano. La posizione da tavolo è ideale per guardare contenuti multimediali, scattare foto ed effettuare videochiamate.

Un'app di video player in modalità da tavolo con riproduzione video sulla parte verticale dello schermo e controlli di riproduzione sulla parte orizzontale inferiore.
Figura 1. Un'app di video player in modalità da tavolo: video sulla parte verticale dello schermo; controlli di riproduzione sulla parte orizzontale.

Utilizza FoldingFeature.State e FoldingFeature.Orientation da collectFoldingFeaturesAsState() per determinare se il dispositivo è in modalità da tavolo:

@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.
    }
}

In alternativa, puoi determinare se la finestra è in posizione da tavolo controllando la proprietà Posture restituita da currentWindowAdaptiveInfoV2():

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

Una volta che sai che il dispositivo è in modalità da tavolo, aggiorna il layout dell'app di conseguenza. Per le app multimediali, questo in genere significa posizionare la riproduzione above the fold e i controlli e i contenuti supplementari subito dopo per un'esperienza di visualizzazione o ascolto hands-free.

Esempi

Postura libro

Un'altra funzionalità esclusiva dei pieghevoli è la posizione libro, in cui il dispositivo è aperto a metà e la cerniera è verticale. La modalità Libro è ideale per leggere ebook. Con un layout a due pagine su uno schermo di grandi dimensioni pieghevole aperto come un libro rilegato, la postura libro cattura l'esperienza di lettura di un libro reale.

Può essere utilizzata anche per la fotografia se vuoi acquisire un formato diverso mentre scatti foto con comandi vocali.

Implementa la postura a libro con le stesse tecniche utilizzate per la postura su un piano. Verifica che l'orientamento della funzionalità di piegatura sia verticale anziché orizzontale:

@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.
    }
}

Modifiche alle dimensioni della finestra

L'area di visualizzazione di un'app può cambiare in seguito a una modifica della configurazione del dispositivo, ad esempio quando il dispositivo viene piegato o aperto, ruotato o ridimensionato in modalità multi-finestra.

Per recuperare la classe di dimensioni della finestra corrente e adattarla alle modifiche delle dimensioni in Jetpack Compose, utilizza la funzione componibile currentWindowAdaptiveInfoV2() della libreria Compose Material 3 Adaptive. currentWindowAdaptiveInfoV2() restituisce un'istanza WindowAdaptiveInfo che fornisce la WindowSizeClass della finestra corrente (con supporto per i breakpoint grandi ed extra-large per impostazione predefinita), nonché il windowPosture del dispositivo:

@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
        }
    }
}

Consulta Utilizza le classi di dimensioni delle finestre.

Risorse aggiuntive

Per scoprire di più sui layout sensibili alla piega e sui dispositivi pieghevoli, consulta le seguenti risorse:

Esempi

Codelab