Layout da tavolo con griglia e mediaQuery

Icona di valutazione a 4 stelle

La modalità da tavolo sui dispositivi pieghevoli divide un singolo schermo in due aree di visualizzazione funzionali separate dalla piega fisica (o cerniera). La modalità da tavolo ti consente di posizionare i contenuti principali della tua app (come un video player o un canvas di gioco) nella metà superiore, mentre gli elementi interattivi (come i controlli multimediali o i pad di controllo) vengono posizionati nella metà inferiore.

Dispositivo pieghevole in modalità da tavolo che mostra contenuti video sullo schermo superiore e controlli di riproduzione sullo schermo inferiore.
Figura 1. La modalità da tavolo divide i contenuti e i controlli interattivi lungo la piega fisica.

Best practice

Per aggiungere il supporto della modalità da tavolo alla tua app, utilizza l'API Grid per definire un layout con due righe e una colonna e applica la query supporti per la postura della finestra da tavolo.

  • Rileva la postura da tavolo in modo reattivo:utilizza il componibile mediaQuery per osservare lo stato del dispositivo. Quando il dispositivo è piegato in posizione da tavolo (windowPosture == Posture.Tabletop), cambia dinamicamente il layout senza richiedere il riavvio dell'attività o una gestione complessa del ciclo di vita.
  • Struttura i layout con Grid: quando il dispositivo è in modalità da tavolo, utilizza l'API Grid (2 rows, 1 column) per separare chiaramente i contenuti visivi principali nella riga superiore above the fold e i controlli interattivi nella riga inferiore below the fold.
  • Sfrutta l'indicizzazione z implicita per gli overlay:nelle posizioni standard (non da tavolo), assegna più ID area alla stessa cella per sovrapporre i controlli al player. Grid esegue automaticamente il rendering degli elementi dal retro al fronte nell'ordine di dichiarazione.
  • Fornisci transizioni fluide:assicurati che lo stato e le posizioni di scorrimento vengano mantenuti durante la transizione tra i layout standard a schermo intero e la modalità da tavolo.

Ingredienti

  • Grid: un container di layout adattivo che ti consente di posizionare gli elementi in righe e colonne configurabili, ideale per suddividere i contenuti in diverse regioni dello schermo.
  • mediaQuery: un'API Jetpack Compose utilizzata per eseguire query sulla postura della finestra, sulle classi di dimensioni e sulle caratteristiche hardware correnti dell'app direttamente all'interno dei composabili.

Passaggi

Esegui una query sulla postura del dispositivo utilizzando mediaQuery(). Quando il dispositivo è in modalità da tavolo, organizza i contenuti dell'app in una griglia verticale con due righe e una colonna, assicurandoti che i contenuti principali rimangano in alto e i controlli rimangano accessibili in basso.

1. Definisci le configurazioni della griglia per la modalità da tavolo

All'interno di una funzione componibile, definisci gli ID delle aree di layout utilizzando un enum e configura i blocchi GridConfigurationScope per le posizioni predefinita e da tavolo.

In defaultConfig, entrambe le aree sono assegnate alla stessa cella (row = 1, column = 1). Grid utilizza l'indicizzazione z implicita, in cui i composabili dichiarati in un secondo momento nel layout vengono visualizzati sopra quelli precedenti, consentendo al controller di sovrapporre il player senza nidificazione di container aggiuntivi (per ulteriori dettagli, consulta Sovrapposizioni di elementi UI con Grid).

enum class VideoPlayerArea { Player, Controller }

object PlayerGridConfig {
    // Default: Single area layout with overlay (controls on top of player)
    val defaultConfig: GridConfigurationScope.() -> Unit = {
        row(1f)
        column(1f)
        area(areaId = VideoPlayerArea.Player, row = 1, column = 1)
        area(areaId = VideoPlayerArea.Controller, row = 1, column = 1)
    }

    // Tabletop: Two rows splitting content across the fold
    val tabletopConfig: GridConfigurationScope.() -> Unit = {
        row(0.5f)
        row(0.5f)
        column(1f)
        area(areaId = VideoPlayerArea.Player, row = 1, column = 1) // Top half above fold
        area(areaId = VideoPlayerArea.Controller, row = 2, column = 1) // Bottom half below fold
    }
}

2. Rileva la postura da tavolo e applica la configurazione a Grid

Utilizza mediaQuery per selezionare la configurazione attiva in base a windowPosture, passa config a Grid e associa i contenuti componibili agli ID area. Dichiarando VideoPlayerArea.Player prima di VideoPlayerArea.Controller, ti assicuri che quando entrambi condividono una cella in defaultConfig, i controlli vengano visualizzati sopra il player:

val config = mediaQuery {
    when (windowPosture) {
        Posture.Tabletop -> PlayerGridConfig.tabletopConfig
        else -> PlayerGridConfig.defaultConfig
    }
}

Grid(config = config) {
    Box(
        modifier = Modifier
            .gridItem(areaId = VideoPlayerArea.Player)
    ) {
        // VideoPlayerContent
    }

    Box(
        modifier = Modifier
            .gridItem(areaId = VideoPlayerArea.Controller)
    ) {
        // PlaybackControlsContent
    }
}

Risultati

Combinando mediaQuery e Grid, la tua app rileva dinamicamente quando un dispositivo pieghevole è parzialmente piegato in modalità da tavolo e regola automaticamente la sua UI in due aree di visualizzazione funzionali divise dalla piega.

Risorse aggiuntive