Layout de postura na mesa com Grid e mediaQuery

Ícone de classificação de 4 estrelas

A postura de mesa em dispositivos dobráveis divide uma única tela em duas áreas de exibição funcionais separadas pela dobra física (ou articulação). A postura de mesa permite colocar o conteúdo principal do app (como um player de vídeo ou uma tela de jogo) na metade de cima e os elementos interativos (como controles de mídia ou de jogo) na metade de baixo.

Dispositivo dobrável no modo de mesa mostrando conteúdo de vídeo na tela de cima e controles de mídia na tela de baixo.
Figura 1. A postura de mesa divide o conteúdo e os controles interativos na dobra física.

Práticas recomendadas

Para adicionar suporte ao modo de mesa ao app, use a API Grid para definir um layout com duas linhas e uma coluna e aplique a consulta de mídia de postura de janela do modo de mesa.

  • Detectar a posição de mesa de forma reativa:use o elemento combinável mediaQuery para observar o estado do dispositivo. Quando o dispositivo é dobrado na postura de mesa (windowPosture == Posture.Tabletop), mude o layout de forma dinâmica sem precisar reiniciar a atividade ou lidar com um ciclo de vida complexo.
  • Estruturar layouts com Grid:na postura de mesa, use a API Grid (2 rows, 1 column) para separar de forma clara o conteúdo visual principal na linha de cima, acima da dobra, e os controles interativos na linha de baixo, abaixo da dobra.
  • Aproveite o Z-index implícito para sobreposições:em posições padrão (não em modo mesa), atribua vários IDs de área à mesma célula para sobrepor controles ao player. O Grid renderiza automaticamente os itens de trás para frente na ordem de declaração.
  • Ofereça transições suaves:garanta que o estado e as posições de rolagem sejam preservados ao alternar entre layouts padrão de tela cheia e a postura de mesa.

Ingredientes

  • Grid: um contêiner de layout adaptável que permite posicionar itens em linhas e colunas configuráveis, ideal para dividir o conteúdo em diferentes regiões da tela.
  • mediaQuery: uma API do Jetpack Compose usada para consultar a postura atual da janela do app, as classes de tamanho e as características de hardware diretamente nos elementos combináveis.

Etapas

Consulte a postura do dispositivo usando mediaQuery(). Quando o dispositivo estiver na postura de mesa, organize o conteúdo do app em uma grade vertical com duas linhas e uma coluna, garantindo que o conteúdo principal fique na parte de cima e os controles fiquem acessíveis na parte de baixo.

1. Definir configurações de grade para o modo de mesa

Dentro de uma função combinável, defina os IDs de área de layout usando um tipo enumerado e configure blocos GridConfigurationScope para as posições padrão e de mesa.

Em defaultConfig, as duas áreas são atribuídas à mesma célula (row = 1, column = 1). O Grid usa indexação Z implícita, em que os elementos combináveis declarados posteriormente no layout são renderizados sobre os anteriores, permitindo que o controlador se sobreponha ao player sem aninhamento extra de contêineres. Consulte Sobreposições de elementos da interface com o Grid para mais detalhes.

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. Detectar a postura de mesa e aplicar a configuração à grade

Use mediaQuery para selecionar a configuração ativa com base em windowPosture, transmita config para Grid e vincule o conteúdo combinável aos IDs de área. Declarar VideoPlayerArea.Player antes de VideoPlayerArea.Controller garante que, quando ambos compartilharem uma célula em defaultConfig, os controles sejam renderizados acima do 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
    }
}

Resultados

Ao combinar mediaQuery e Grid, seu app detecta dinamicamente quando um dispositivo dobrável está parcialmente dobrado na postura de mesa e ajusta automaticamente a interface em duas áreas de exibição funcionais divididas pela dobra.

Outros recursos