Notícias sobre produtos

Atualizações no SDK do Android XR: lançamento da prévia para desenvolvedores 4

Leitura de 5 minutos

Hoje, temos o prazer de lançar a prévia para desenvolvedores 4 do SDK do Android XR, continuando nosso foco em unificar o desenvolvimento multidispositivo para headsets, óculos XR com fio e óculos inteligentes. Para manter nossa plataforma intuitiva, estamos adotando nomes mais descritivos para nossos formatos. Os óculos com IA agora são óculos com áudio, e os óculos com IA e tela agora são óculos com tela. Essas mudanças vão aparecer na nossa documentação a partir de hoje. 

Esta versão está repleta de atualizações que ajudam você a criar experiências incríveis para dispositivos XR, possibilitar experiências imersivas mais profundas em headsets XR e simplificar o caminho para criar experiências aumentadas em óculos de áudio e tela.  Além disso, nossas bibliotecas principais, incluindo o XR Runtime, o Jetpack SceneCore e o ARCore para Jetpack XR, vão passar oficialmente para a versão Beta em breve.

Para dar acesso antecipado a hardware e recursos para criar experiências imersivas e de realidade aumentada em dispositivos futuros, como óculos com tela e áudio e o Project Aura da XREAL, estamos anunciando o Programa Android XR Developer Catalyst. Saiba mais e comece sua inscrição hoje mesmo. 

Como criar experiências de realidade aumentada para óculos de áudio e com tela

Começando com nossas bibliotecas para experiências aumentadas, a prévia para desenvolvedores 4 apresenta novas APIs que ajudam você a criar e testar seus apps.

Jetpack Projected: APIs Device Availability e ProjectedTestRule

A biblioteca Jetpack Projected ajuda a conectar as experiências no app do smartphone ao campo de visão do usuário. Adicionamos a API Device Availability, que consolida os sinais de estado de uso e conectividade em valores padrão do Android Lifecycle.State. Isso permite ajustar o comportamento dos aplicativos com base no uso do dispositivo.

val xrDevice = XrDevice.getCurrentDevice(projectedContext)

// Observe the device lifecycle flow
xrDevice.getLifecycle().currentStateFlow
    .collect { state ->
        when (state) {
            Lifecycle.State.STARTED -> { /* Device is available (worn) */ }
            Lifecycle.State.CREATED -> { /* Device is unavailable (not worn) */ }
            Lifecycle.State.DESTROYED -> { /* Device is DISCONNECTED */ }
        }
    }

Para simplificar os testes, a nova API ProjectedTestRule no artefato de teste projetado automatiza a configuração de ambientes de teste projetados. Isso ajuda você a escrever testes de unidade limpos e confiáveis sem o código boilerplate.

// from the 'androidx.xr.projected:projected-testing:1.0.0-alpha07' artifact
@get:Rule
val projectedTestRule = ProjectedTestRule()

@Test
fun testProjectedContextInitialization() {
    // by default, ProjectedTestRule automatically creates and connects
    // a projected device before each test
    val projectedContext = ProjectedContext.createProjectedDeviceContext(context)

    // assert the projected context is successfully initialized
    assertThat(projectedContext).isNotNull()
}

Jetpack Compose Glimmer: Google Sans Flex e novos componentes

Nossa biblioteca de interface para óculos com tela, o Jetpack Compose Glimmer, agora inclui a Google Sans Flex para melhorar a legibilidade em telas ópticas transparentes. Também adicionamos vários componentes interativos:

  • Pilhas: projetadas para grupos otimizados para touchpad, mostrando um item por vez.
  • Ícones de título: fornecem categorização e contexto para cards de conteúdo.
glimmer (1).gif

Como criar experiências imersivas para headsets XR e óculos XR com fio

Se você quer criar experiências totalmente imersivas para headsets XR e óculos XR com fio, temos várias atualizações importantes.

Transição Beta e Arquitetura Moderna

O XR Runtime, o Jetpack SceneCore e os recursos de percepção do ARCore para Jetpack XR (mapas de profundidade, captura de movimentos dos olhos/mãos, teste de hit e âncoras espaciais) vão passar para a versão Beta em breve. Por isso, simplificamos as APIs do Jetpack XR. Removemos os pacotes legados do Guava e do RxJava3 para priorizar uma arquitetura moderna que prioriza o Kotlin.

Jetpack SceneCore: glTF e malhas personalizadas

Estamos expandindo os recursos de modelos 3D, adicionando a capacidade de ajustar modelos 3D e acessar nós específicos com um modelo 3D. Usando GltfModelNode, é possível modificar propriedades como pose, materiais e texturas, além de executar animações para nós específicos.

// Create a new PBR material
pbrMaterial = KhronosPbrMaterial.create(
    session = xrSession,
    alphaMode = AlphaMode.OPAQUE
)

// Load a texture.
val texture = Texture.create(
    session = xrSession,
    path = Path("textures/texture_name.png")
)

// Apply the texture and configure occlusion to define how the material handles ambient lighting.
pbrMaterial.setOcclusionTexture(
    texture = texture,
    strength = 0.5f
)

// Access the hierarchy of nodes within the model entity.
val entityNodes = entity.nodes

// Find the specific node to apply the material override.
val myEntityNode = entityNodes.find { it.name == "node_name" }

// Apply the PBR material to the node.
myEntityNode?.setMaterialOverride(
   material = newMaterial
)

Também estamos trazendo as malhas personalizadas para o SceneCore. Com as malhas personalizadas, é possível criar geometrias de forma programática, o que é ideal para criar modelos 3D personalizados. Esse recurso será lançado como experimental. Faça um teste e conte o que achou.

// Create the mesh
val roadMesh =
    CustomMesh.BuilderFromMeshData(session, roadVertexLayout)
        .addVertexData(ByteBufferRegion(roadDataBuffer, 0, vertexDataSize))
        .setIndexData(ByteBufferRegion(roadDataBuffer, vertexDataSize, indexDataSize))
        .setTopology(MeshSubsetTopology.TRIANGLES)
        .build()

// Define the material
val roadMaterial = KhronosPbrMaterial.create(session, AlphaMode.OPAQUE)

// Instantiate the entity using the custom mesh and material
val roadEntity =
    MeshEntity.create(
        session,
        roadMesh,
        listOf(roadMaterial),
        pose = roadPose,
    )

Compose para XR: suporte nativo a glTF

Agora temos suporte nativo ao glTF diretamente no Compose para XR com o  SpatialGltfModel. Use isso com SpatiallGltfModelState para acessar nós e animações no modelo glTF ou use-os para adicionar texturas e materiais aos seus modelos 3D.

val myGltfModelState = rememberSpatialGltfModelState(
        source = SpatialGltfModelSource.fromPath(
            Paths.get("models/my_animated_model.glb")
        )
    )

    val myGltfAnimation =
        myGltfModelState.animations.find { it.name == "animation_name" }

    DisposableEffect(myGltfAnimation) {
        myGltfAnimation?.loop()

        onDispose {
            myGltfAnimation?.stop()
        }
    }

    SpatialGltfModel(state = myGltfModelState, modifier = modifier)

ARCore para Jetpack XR: pré-lançamento da API Geospatial para óculos XR com fio

Também estamos oferecendo um pré-lançamento da API Geospatial para óculos XR com fio no ARCore para Jetpack XR. Essa atualização permite a ancoragem de alta precisão de conteúdo digital vinculado a locais do mundo real em mais de 87 países.

Ao combinar o Sistema de Posicionamento Visual (VPS) do ARCore com os recursos de raciocínio e áudio da API Gemini Live, você pode criar experiências que entendem o contexto, incluindo a localização e a posição do usuário. Imagine criar um tour imersivo guiado por IA que oferece audiodescrições em tempo real de lugares próximos, misturando informações digitais com o ambiente físico.

Comece a construir o futuro hoje mesmo

Este é um momento incrível para desenvolver para o Android XR. Com o SDK do Jetpack para XR chegando em breve à versão Beta e um conjunto robusto de novas ferramentas ao seu alcance, explore cada uma das áreas a seguir para preparar as experiências do seu app para XR.  

Leia a documentação, confira as amostras e os experimentos de XR

Acesse o site oficial para desenvolvedores Android para conferir guias técnicos completos, referências de API e instruções sobre como configurar o novo emulador. Inspire-se com nossas amostras e experimentos. Veja como usamos essas APIs para criar layouts espaciais imersivos, carregar modelos 3D, explorar áudio espacial e muito mais.

Confira as novidades para mecanismos de jogo

Adicionamos suporte oficial ao Unreal Engine e ao Godot, além de lançar duas novas ferramentas para acelerar o desenvolvimento para Android XR com o Unity e o Android XR Interaction Framework. E, com base no seu feedback, estamos lançando o Android XR Engine Hub para que você possa executar suas experiências diretamente do seu mecanismo preferido,

Inscreva-se no Programa Android XR Developer Catalyst.

Não perca a chance de criar para o hardware mais recente do Android XR. Inscreva-se hoje mesmo para ter acesso a hardware de pré-lançamento, incluindo nosso protótipo de óculos de áudio e tela e o Project Aura da XREAL.

Saiba mais e se inscreva hoje mesmo

Estamos ansiosos para ver as experiências incríveis de XR que você vai criar enquanto nos preparamos para o lançamento de mais dispositivos Android XR ainda este ano.

Confira este anúncio e todas as atualizações do Google I/O 2026 em io.google.

Escrito por:
Continue lendo