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

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 nomes mais descritivos para nossos formatos. Os óculos com IA agora são óculos com áudio, e os óculos com tela de IA agora são óculos com tela virtual. 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 aumentadas em óculos de áudio e óculos com tela virtual. Além disso, nossas bibliotecas principais, incluindo o ambiente de execução de XR, 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 aumentadas em dispositivos futuros, como óculos de áudio e tela e o Project Aura da XREAL, anunciamos 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 de 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 DeviceAvailability e ProjectedTestRule

A biblioteca Projected do Jetpack ajuda a conectar as experiências de apps do smartphone ao campo de visão do usuário. Adicionamos a API Device Availability,que consolida o estado de desgaste e os indicadores de conectividade em valores padrão do Android Lifecycle.State. Isso permite ajustar o comportamento dos aplicativos com base no uso ou não 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 projected-testing 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()
}

Glimmer do Jetpack Compose: Google Sans Flex e novos componentes

Nossa biblioteca de interface para óculos com tela virtual, 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: oferecem categorização e contexto para cards de conteúdo.

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

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

Transição da 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 ocorrência e ancoragens 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 foco no Kotlin.

Jetpack SceneCore: glTF e malhas personalizadas

Estamos ampliando os recursos de modelos 3D com a capacidade de ajustar esses modelos e acessar nós específicos com um modelo 3D. Com 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 malhas personalizadas para o SceneCore. Com as malhas personalizadas, é possível criar geometria de maneira programática e dinâmica, o que é ideal para criar modelos 3D personalizados. Esse recurso será lançado como experimental. Faça um teste e conte o que você 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 para glTF diretamente no Compose para 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 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 contextuais que entendem a localização e a posição do usuário. Imagine criar um tour a pé imersivo guiado por IA que oferece descrições de áudio em tempo real de lugares próximos, misturando informações digitais com o ambiente físico.

Comece a construir o futuro hoje

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

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

Acesse o site oficial para desenvolvedores Android para conferir guias técnicos completos, Referência da API e instruções sobre como configurar o novo emulador. Inspire-se com nossas amostras 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
• Conheça exemplos de XR
• Conheça os experimentos de XR

Confira as novidades para mecanismos de jogos

Adicionamos suporte oficial ao Unreal Engine e ao Godot, além de lançarmos duas novas ferramentas para acelerar o desenvolvimento do Android XR com o Unity e o Android XR Interaction Framework. 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.

•  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 Android XR mais recente. Inscreva-se hoje para ter acesso a hardware de pré-lançamento, incluindo nosso protótipo de óculos de áudio e display e o Projeto Aura da XREAL.

Saiba mais e se inscreva hoje

Estamos ansiosos para ver as experiências incríveis 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.