Hoje, temos o prazer de lançar a prévia para desenvolvedores 4 do SDK do Android XR, continuando nosso foco na unificação do desenvolvimento entre dispositivos para headsets, óculos XR com fio e óculos inteligentes. Para manter nossa plataforma intuitiva, estamos adotando uma nomenclatura mais descritiva para nossos formatos. Os óculos com IA agora são óculos de áudio e os óculos com IA com tela agora são óculos de 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, ativar experiências imersivas mais profundas em headsets XR e simplificar o caminho para criar experiências de realidade aumentada 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, serão oficialmente movidas para a versão Beta em breve.

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

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

Começando com nossas bibliotecas para experiências de realidade aumentada, 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 do app do smartphone ao campo de visão do usuário. Adicionamos a API Device Availability, que consolida o estado de uso e os indicadores de conectividade em valores padrão Lifecycle.State do Android. 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 ProjectedTestRule API 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 de tela, o Jetpack Compose Glimmer, agora inclui Google Sans Flex para melhorar a legibilidade em telas ópticas. Também adicionamos vários componentes interativos:

• _Stacks_: projetado para grupos otimizados para touchpad, mostrando um item por vez.
• _Title Chips_: oferece categorização e contexto para cards de conteúdo.

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

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

Transição para a versã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, Rastreamento de olhos/mãos, teste de detecção de toque e Âncoras espaciais) serão movidos para a versão Beta em breve. Por isso, simplificamos as APIs do Jetpack XR. Removemos os pacotes legados do Guava e do RxJava3 em favor de uma arquitetura moderna e com o Kotlin como linguagem principal.

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 e até mesmo 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 malhas personalizadas para o SceneCore. As malhas personalizadas permitem criar geometria de maneira 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 for XR: suporte nativo a glTF

Agora temos suporte nativo a glTF diretamente no Compose for XR com SpatialGltfModel. Use isso com SpatiallGltfModelState para acessar nós e animações no modelo glTF ou 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évia da API Geospatial para óculos XR com fio

Também estamos oferecendo uma prévia 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 reais em mais de 87 países.

Ao combinar o Visual Positioning System (VPS) do ARCore com os recursos de raciocínio e áudio da API Gemini Live, é possível criar experiências contextuais que entendem o local e a posição do usuário. Imagine criar um passeio a pé imersivo e guiado por IA que oferece descrições de áudio em tempo real de lugares próximos, combinando informações digitais com o ambiente físico.

Comece a construir o futuro hoje mesmo

É um ótimo momento para desenvolver para o Android XR. Com o SDK do Jetpack XR sendo movido para a versão Beta em breve e um conjunto robusto de novas ferramentas à sua disposição, explore cada uma das áreas a seguir para preparar as experiências do seu app para XR.  

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

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

• Acesse a página da Web do Android XR
• Confira exemplos de XR
• Confira experimentos de XR

Confira as novidades para mecanismos de jogos

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

•  Leia a postagem do blog sobre as novidades do Android XR e dos mecanismos de jogos

Inscreva-se no Programa Catalyst para desenvolvedores do Android XR

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

Saiba mais e inscreva-se hoje mesmo

Estamos ansiosos para ver as incríveis experiências de XR que você vai criar à medida que avançamos 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.