Instruções

Como levar o Androidify para a XR com o SDK do Jetpack XR

Leitura de 9 min
Ver o perfil de Dereck Bridie
Dereck Bridie Engenheiro de relações com desenvolvedores

O Samsung Galaxy XR já chegou, com tecnologia Android XR! Este post faz parte da nossa Semana de Destaques do Android XR, em que oferecemos recursos, como posts do blog, vídeos, exemplos de código e muito mais, todos criados para ajudar você a aprender, criar e preparar seus apps para o Android XR.

Com o lançamento do Samsung Galaxy XR, o primeiro dispositivo com Android XR está oficialmente disponível. Agora, as pessoas podem aproveitar muitos dos apps favoritos da Google Play Store em uma dimensão totalmente nova: a terceira dimensão!

A terceira dimensão é espaçosa, com muito espaço para seus apps também. Comece hoje mesmo usando as ferramentas para desenvolvedores que funcionam para seu app. Por exemplo, você pode usar o SDK do Jetpack para XR para criar experiências imersivas de XR usando ferramentas modernas de desenvolvimento do Android, como Kotlin e Compose.

Nesta postagem do blog, vamos contar nossa jornada ao levar a magia do nosso amado app Androidify para a XR e abordar os conceitos básicos do que é necessário para levar seus apps para a XR também.

Um tour pelo Androidify

O Androidify é um app de código aberto que permite criar bots do Android usando algumas das tecnologias mais recentes, como Gemini, CameraX, Navigation 3 e, claro, Jetpack Compose. O Androidify foi projetado inicialmente para funcionar bem em smartphones, dobráveis e tablets com a criação de layouts adaptáveis.

customize.png

O Androidify fica ótimo em vários formatos

Um pilar fundamental dos layouts adaptáveis são os elementos combináveis reutilizáveis. O Jetpack Compose ajuda a criar componentes de interface pequenos que podem ser organizados de diferentes maneiras para criar experiências do usuário intuitivas, não importa o tipo de dispositivo que o usuário esteja usando. Na verdade, o Androidify é compatível com o Android XR sem nenhuma modificação no app.

customize_2.png

O Androidify se adapta ao XR usando o layout responsivo para telas grandes sem mudanças no código

Os apps que não têm tratamento especial para o Android XR podem ser usados em multitarefa em uma janela de tamanho adequado e funcionam de forma muito semelhante à de uma tela grande. Por isso, o Androidify já está totalmente integrado ao Android XR, sem precisar de mais nada. Mas não queríamos parar por aí. Por isso, decidimos ir além e criar um app diferenciado para XR, oferecendo uma experiência incrível aos nossos usuários.

Como se orientar no XR

Vamos analisar os principais conceitos básicos do Android XR, começando com os dois modos em que os apps podem ser executados: Espaço Compacto e Espaço Ampliado.

homespace.png
Apps no Espaço Compacto
homespace2.png
App no Espaço Ampliado

No Espaço Compacto, vários apps podem ser executados lado a lado para que os usuários possam realizar várias tarefas em janelas diferentes. Nesse sentido, é muito parecido com o modo janela para computador em um dispositivo Android de tela grande, mas em um espaço virtual.

No Espaço Ampliado, o app não tem limites de espaço e pode usar todos os recursos espaciais do Android XR, como a UI espacial e o controle do ambiente virtual.

Embora possa parecer tentador fazer com que seu app seja executado apenas no Espaço Ampliado, os usuários podem querer realizar várias tarefas ao mesmo tempo com ele. Portanto, oferecer suporte a ambos promove uma experiência melhor.

Design para a nova dimensão do Androidify

Um app incrível começa com um ótimo design. Ivy Knight, Senior Design Advocate no Android DevRel, assumiu a tarefa de pegar os designs atuais do Androidify e criar um novo design para XR. É com você, Ivy!

O design para XR exigia uma abordagem única, mas ainda tinha muito em comum com o design para dispositivos móveis. Começamos pensando na contenção: como organizar e agrupar nossos elementos da interface no subespaço, seja mostrando limites claramente ou sugerindo-os de forma sutil. Também aprendemos a usar todos os tamanhos de elementos da interface espacial, que se ajustam e se movem em resposta ao usuário. Como fizemos com o Androidify, crie com layouts adaptáveis para dividir seus layouts em partes para a interface espacial.

Como iniciar o design com o Home Space

Felizmente, o Android XR permite que você comece com o app como ele é hoje para o Espaço Compacto. Assim, podemos fazer a transição para os designs de XR expandidos apenas adicionando uma barra de ferramentas de janela e um botão de transição para o Espaço Ampliado.

Também consideramos possíveis recursos de hardware e como o usuário interagiria com eles. Os layouts para dispositivos móveis do Androidify se adaptam a várias posições, tamanhos de classe e número de câmeras para oferecer mais opções de fotos. Seguindo esse modelo, também tivemos que adaptar o layout da câmera para dispositivos de headset. Também precisamos fazer ajustes para que o texto funcione, considerando a proximidade da interface com o usuário.

Como projetar para a mudança maior para o Espaço Ampliado

O Espaço Ampliado foi a maior mudança, mas nos deu mais espaço criativo para adaptar nosso design. 

tablet_to_xr.webp
Do tablet para o XR

O Androidify usa contenção visual, ou painéis, para agrupar recursos com um plano de fundo e um contorno, como o painel "Tirar ou escolher uma foto". Também usamos componentes como a barra de apps da parte de cima da tela para criar uma contenção natural ao enquadrar os outros painéis. Por fim, a contenção intrínseca é sugerida pela proximidade de determinados elementos com outros, como o botão "Iniciar transformação", que fica perto do painel "Escolher a cor do meu bot".

Painéis espaciais para facilitar a separação. Para decidir como adaptar seus designs para dispositivos móveis para painéis espaciais, tente remover as superfícies, começando pela que está mais atrás e avançando. Veja quantos planos de fundo você consegue remover e o que sobra. Depois de fazermos esse exercício para o Androidify, o grande rabisco verde do Android foi o que restou. O rabisco não só serviu como um momento de branding e plano de fundo, mas também como uma âncora para o conteúdo no espaço 3D.

Ao estabelecer essa âncora, ficou mais fácil imaginar como os elementos poderiam se mover ao redor dela e como poderíamos usar a proximidade para destacar e traduzir o restante da experiência do usuário.

Outras dicas de design para ajudar seu app a se tornar espacial

  • Deixe as coisas sem limites: separe os componentes e dê a eles um espaço real (espacial). É hora de dar um pouco de espaço para os elementos da interface.
  • Remover superfícies: oculte o plano de fundo e veja o que isso faz com seus designs.
  • Motivar com movimento: como você está usando as transições no seu app? Use esse personagem para imaginar seu app entrando na RV.
  • Escolha uma âncora: não perca seus usuários no espaço. Ter um elemento que ajude a coletar ou fundamentar a interface.

Para saber mais sobre os padrões de design de interface de XR, confira Design para Android XR no site para desenvolvedores Android.

Noções básicas da interface espacial

Agora que falamos sobre a experiência da Ivy ao adaptar a mentalidade dela durante o design do Androidify para XR, vamos falar sobre o desenvolvimento de interfaces espaciais. Desenvolver uma interface espacial com o SDK do Jetpack para XR será familiar se você já trabalha com ferramentas e bibliotecas modernas do Android. Você vai encontrar conceitos que já conhece, como a criação de layouts com o Compose. Na verdade, os layouts espaciais são muito semelhantes aos layouts 2D que usam linhas, colunas e espaçadores:

spatialrows.png

Esses elementos são organizados em SpatialRows e SpatialColumns

Os elementos espaciais mostrados aqui são combináveis SpatialPanel, que permitem mostrar conteúdo 2D, como texto, botões e vídeos.

Subspace {
    SpatialPanel(
        SubspaceModifier
            .height(824.dp)
            .width(1400.dp)
    ) {
        Text("I'm a panel!")
    }
}

Um SpatialPanel é um subspace composable. Os elementos combináveis do Subspace precisam estar contidos em um Subspace e são modificados por objetos SubspaceModifier. Os subespaços podem ser colocados em qualquer lugar na hierarquia da interface do app e só podem conter elementos de composição de subespaço. Os objetos SubspaceModifier também são muito semelhantes aos objetos Modifier: eles controlam parâmetros como tamanho e posicionamento.

Um Orbiter pode ser anexado a um SpatialPanel e se mover com o conteúdo ao qual está anexado. Elas costumam ser usadas para fornecer controles contextuais sobre o conteúdo ao qual estão anexadas, dando o foco principal ao conteúdo. Eles podem ser colocados em qualquer um dos quatro lados do conteúdo, a uma distância configurável.

orbiter.png
Um orbitador é anexado à parte de baixo de um SpatialPanel

Há muitos outros elementos da interface espacial, mas esses são os principais que usamos para criar layouts espaciais para o Androidify.

Começar a usar o desenvolvimento de XR

Vamos começar com a configuração do projeto. Adicionamos a dependência do Jetpack XR Compose, que pode ser encontrada na página Dependências do Jetpack XR.

Adicionamos o código de um botão que faz a transição do usuário para o Espaço Ampliado, começando pela detecção da capacidade de fazer isso:

@Composable
fun couldRequestFullSpace(): Boolean =
   LocalSpatialConfiguration.current.hasXrSpatialFeature && 
   !LocalSpatialCapabilities.current.isSpatialUiEnabled
}

Em seguida, criamos um novo componente de botão que usa o ícone Expandir conteúdo nos layouts atuais e atribuímos a ele um comportamento onClick:

@Composable

fun RequestFullSpaceIconButton() {
   if (!couldRequestFullSpace()) return
   val session = LocalSession.current ?: return

   IconButton(
       onClick = {
           session.scene.requestFullSpaceMode()
       },
   ) {
       Icon(
           imageVector =  
               vectorResource(R.drawable.expand_content_24px),
           contentDescription = 
               stringResource("To Full Space"),
       )
   }
}

Agora, clicar nesse botão mostra apenas o layout médio no Espaço Ampliado. Podemos verificar os recursos espaciais e determinar se a interface espacial pode ser mostrada. Nesse caso, vamos mostrar nosso novo layout espacial:

@Composable

fun HomeScreenContents(layoutType: HomeScreenLayoutType) {
   val layoutType = when {
      LocalSpatialCapabilities.current.isSpatialUiEnabled -> 
          HomeScreenLayoutType.Spatial
      isAtLeastMedium() -> HomeScreenLayoutType.Medium
      else -> HomeScreenLayoutType.Compact
   }

   when (layoutType) {
      HomeScreenLayoutType.Compact ->
          HomeScreenCompactPager(...)

      HomeScreenLayoutType.Medium ->
          HomeScreenMediumContents(...)

      HomeScreenLayoutType.Spatial ->
          HomeScreenContentsSpatial(...)
   }
}

Implementar o design da tela inicial

Vamos voltar ao design espacial da tela inicial no Espaço Ampliado para entender como ele foi implementado.

customize_3.png

Identificamos dois elementos SpatialPanel aqui: um painel em que a placa de vídeo está à direita e outro que contém a interface principal. Por fim, há um Orbiter acoplado à parte de cima. Vamos começar com o painel do player de vídeo:

@Composable
fun HomeScreenContentsSpatial(...) {
   Subspace {
      SpatialPanel(SubspaceModifier
                   .fillMaxWidth(0.2f)
                   .fillMaxHeight(0.8f)
                   .aspectRatio(0.77f)
                   .rotate(0f, 0f, 5f),
      ) {
          VideoPlayer(videoLink)
      }
   }
}

Reutilizamos o componente VideoPlayer 2D dos layouts normais em um SpatialPanel sem outras mudanças. Veja como ele fica de forma independente:

bluetiel.png

O painel de conteúdo principal seguiu a mesma história: reutilizamos o conteúdo do painel médio em um SpatialPanel.

SpatialPanel(SubspaceModifier.fillMaxSize(),
             resizePolicy = ResizePolicy(
                 shouldMaintainAspectRatio = true
             ),
             dragPolicy = MovePolicy()
) {
    Box {
        FillBackground(R.drawable.squiggle_full)
        HomeScreenSpatialMainContent(...)
    }
}

Atribuímos a esse painel uma ResizePolicy, que oferece algumas alças perto das bordas para que o usuário possa redimensionar o painel. Ele também tem uma MovePolicy, que permite ao usuário arrastá-lo.

customize_4.png

Colocá-los no mesmo Subspace os torna independentes um do outro. Por isso, tornamos o painel VideoPlayer um filho do painel de conteúdo principal. Isso faz com que o painel VideoPlayer se mova quando o painel de conteúdo principal é arrastado por uma relação pai-filho.

@Composable
fun HomeScreenContentsSpatial(...) {
   Subspace {
       SpatialPanel(SubspaceModifier..., resizePolicy, dragPolicy) {
           Box {
               FillBackground(R.drawable.squiggle_full)
               HomeScreenSpatialMainContent(...)
           }
           Subspace {
              SpatialPanel(SubspaceModifier...) {
                  VideoPlayer(videoLink)
              }
           }
       }
   }
}

Foi assim que fizemos a primeira tela.

Passando para as outras telas

Também vou falar brevemente sobre algumas das outras telas, destacando considerações específicas feitas para cada uma delas.

fullspace.png
A tela de criação no Espaço Ampliado

Aqui, usamos os elementos combináveis SpatialRow e SpatialColumn para criar um layout que se ajusta ao espaço de visualização recomendado, reutilizando componentes do layout médio.

fullspace_2.png

Tela de resultados no Espaço Ampliado: um bot gerado com um comando: boné de beisebol vermelho, óculos de sol aviador, camiseta azul-clara, shorts xadrez vermelho e branco, chinelos verdes e segurando uma raquete de tênis.


A tela de resultados mostra as citações complementares usando um efeito de difusão, permitindo que elas desapareçam perto das bordas da tela. Ele também usa uma transição 3D real ao visualizar a entrada usada, virando a imagem no espaço.

Publicar na Google Play Store

Agora que o app está pronto para XR com os layouts espaciais, vamos lançá-lo na Google Play Store. Fizemos uma última mudança importante no arquivo AndroidManifest.xml do app:

<!-- Androidify can use XR features if they're available; they're not required. -->
<uses-feature android:name="android.software.xr.api.spatial" 
              android:required="false" />

Isso informa à Google Play Store que o app tem recursos diferenciados de XR, mostrando um selo que informa aos usuários que o app foi feito pensando em XR:

androidify2.png
Androidify como mostrado na Google Play Store no Android XR


Ao fazer upload da versão, não é necessário seguir etapas especiais para lançar no XR: o mesmo app é distribuído normalmente para usuários na faixa para dispositivos móveis e para usuários em um dispositivo XR. No entanto, você pode adicionar capturas de tela específicas de XR do seu app ou até mesmo fazer upload de uma prévia imersiva do app usando um recurso de vídeo espacial. Em dispositivos Android XR, a Google Play Store mostra automaticamente uma prévia imersiva em 3D, permitindo que os usuários experimentem a profundidade e a escala do conteúdo antes de instalar o app.

Comece a criar suas próprias experiências hoje mesmo

O Androidify é um ótimo exemplo de como espacializar um app 2D do Jetpack Compose. Hoje, mostramos todo o processo de desenvolvimento de uma interface espacial para o Androidify, desde o design até o código e a publicação. Modificamos os designs atuais para que funcionem com paradigmas espaciais, usamos os elementos de composição SpatialPanel e Orbiter para criar layouts espaciais que aparecem quando o usuário entra no Espaço Ampliado e, por fim, lançamos a nova versão do app na Google Play Store.

Esperamos que esta postagem do blog tenha ajudado você a entender como levar seus próprios apps para o Android XR. Confira mais alguns links que podem ajudar você:

Escrito por:
Continue lendo