No Google I/O deste ano, anunciamos uma atualização para experiências espaciais: a API Geospatial já está disponível como prévia no ARCore para Jetpack XR. Ao trazer o Sistema de posicionamento visual (VPS, na sigla em inglês) do Google para o Android XR, o Android XR permite ancorar conteúdo digital ao mundo físico com precisão de menos de um metro e orientação precisa em áreas compatíveis.* Para mostrar o que a API Geospatial pode fazer, nossa equipe criou uma demonstração: o tour espacial XR.

Imagine entrar em uma nova cidade, colocar um par de óculos XR com fio (como o XREAL Project Aura, que será lançado em breve) e ter instantaneamente um guia local experiente mostrando tudo. Não é necessário olhar para um mapa 2D. Em vez disso, modelos 3D orientam seu caminho, e uma voz inteligente fala sobre os marcos históricos bem na sua frente. Combinamos as APIs Geospatial, API Gemini usando o Firebase AI Logic, Embasamento do Google Maps e o SDK Jetpack XR para criar uma experiência de tour a pé imersiva e sem as mãos.

Exoneração de responsabilidade: o vídeo e o aplicativo do guia turístico são apenas para demonstração. Algumas sequências foram encurtadas. Qualquer hardware mostrado pode estar em desenvolvimento. Os detalhes do produto final podem variar.

Vamos analisar os detalhes da implementação e mostrar como unimos essas APIs para criar uma experiência espacial mundial.

1. Como identificar o usuário com a API ARCore Geospatial (VPS)

Melhore sua experiência de navegação no XR combinando o poder do GPS com a precisão do VPS. A acurácia e a orientação precisa que acompanham o VPS permitem que os waypoints 3D se alinhem ao mundo físico.

É por isso que a API Geospatial no Android XR pode ajudar você a criar experiências personalizadas. Ao usar a visão computacional avançada, o VPS tenta fornecer uma GeospatialPose (incluindo latitude, longitude e direção) mais precisa do que o GPS.

Veja como recuperamos a pose espacial do usuário mapeando a orientação do dispositivo para uma coordenada espacial:

// Retrieve the current geospatial pose from the ARCore session
val result = geospatial.createGeospatialPoseFromPose(arDevice.state.value.devicePose)
if (result is CreateGeospatialPoseFromPoseSuccess) {
    val pose = result.pose
    Log.d("VPS", "Accurate Location: ${pose.latitude}, ${pose.longitude}")
}

Como toda a experiência depende dessa precisão, monitoramos a horizontalAccuracy e a orientationYawAccuracy até que elas atendam aos nossos limites. Se o usuário estiver em um ambiente interno ou em uma área não reconhecida, pedimos que ele "caminhe até um espaço público ao ar livre e olhe ao redor".

2. Como criar o itinerário com a API Gemini e o Embasamento do Google Maps

Depois de ter um local, usamos a API Gemini usando o Firebase AI Logic para pedir ao modelo Gemini que atue como um guia turístico local. Transmitimos as coordenadas do usuário ao modelo e pedimos que ele gere uma resposta JSON estruturada contendo tours a pé nas proximidades:

   val configForTools = ToolConfig(
      functionCallingConfig = null,
      retrievalConfig = retrievalConfig {
        latLng = FirebaseLatLng(pose.latitude, pose.longitude)
        languageCode = "en"
      }
    )

    val responseJsonSchema = Schema.obj(
      mapOf(
        "locationIntro" to Schema.string(),
        "tours" to Schema.array(
          Schema.obj(
            mapOf(
              "title" to Schema.string(),
              "description" to Schema.string(),
              "stops" to Schema.array(
                Schema.obj(
                  mapOf(
                    "name" to Schema.string(),
                    "detailedName" to Schema.string(),
                    "description" to Schema.string()
                  )
                )
              )
            )
          )
        )
      )
    )

    val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
      modelName = "gemini-3.5-flash",
      tools = listOf(Tool.googleMaps()),
      generationConfig = generationConfig {
        responseMimeType = "application/json"
        responseSchema = responseJsonSchema
      }
    )

   val result = model.generateContent("The user is at latitude ${pose.latitude} and longitude ${pose.longitude}. Generate exactly 3 diverse tours near this location (e.g., historical, food, nature). All tour ideas should be walking distance only.")

Os modelos de linguagem grandes são ótimos para gerar descrições detalhadas, mas às vezes podem alucinar coordenadas exatas de latitude/longitude. Para resolver isso, usamos Embasamento do Google Maps para fundamentar a IA.

3. Uma voz para guiar você: Gemini 2.5 TTS

Para que o guia turístico pareça realmente presente, implementamos dublagens dinâmicas.

Usando o gemini-2.5-flash-tts model, podemos configurar nossa configuração de geração de modelos para retornar dados de áudio nativamente em vez de apenas texto. Veja como solicitar o ResponseModality.AUDIO:

val ttsModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-2.5-flash-tts",
        generationConfig = generationConfig {
            // Instruct the model to return Audio
            responseModalities = listOf(ResponseModality.AUDIO)
        }
    )

val response = ttsModel.generateContent("Say in a neutral but positive voice:\n$prompt")

// Extract the raw audio bytes from the response
val audioBytes = response.candidates.firstOrNull()?.content?.parts
    ?.filterIsInstance<InlineDataPart>()
    ?.firstOrNull { it.mimeType.contains("audio") }?.inlineData

4. Como dar vida em 3D com o Jetpack XR

A peça final do quebra-cabeça é renderizar esses dados no campo de visão do usuário. O SDK Jetpack XR facilita a transição de uma interface do Android 2D para a computação espacial.

Usamos o Jetpack Compose para XR para criar componentes espaciais. Para representar pontos de interesse ao longo do tour, criamos um elemento combinável chamado InfoSphere, que contém um GltfModel de um orbe 3D que flutua no espaço e pode ser interagido para revelar informações.

Usando o SDK Jetpack XR, podemos colocar modelos 3D ao lado da interface do Compose usando SpatialBox e SceneCoreEntity. Também usamos InteractableComponent para responder a toques do usuário.

Ao combinar AnimatedSpatialVisibility para superfícies tradicionais da interface do Compose com elementos 3D SceneCoreEntity, podemos mesclar dados perfeitamente no mundo físico.

@Composable
fun InfoSphere(
    content: InfoBubbleContent,
    session: Session,
    sphereModel: GltfModel,
    isSelected: Boolean,
    onClick: () -> Unit
) {
    // SpatialBox lets us arrange 3D components and SpatialPanels together
    SpatialBox(
        SubspaceModifier
            .offset(x = 2.dp, y = 1.dp, z = (-3).dp) // Positioned in 3D space
    ) {
        // Smoothly animate the visibility of our 2D Compose UI Panel
        AnimatedSpatialVisibility(visible = isSelected) {
            SpatialPanel {
                InfoBubble(content) // Regular 2D Compose UI
            }
        }
        // Render our interactive 3D sphere
        SceneCoreEntity(
            factory = {
                GltfModelEntity.create(session, sphereModel).also { entity ->
                    // Make the 3D model respond to user taps
                    entity.addComponent(InteractableComponent.create(session) { inputEvent ->
                        if (inputEvent.action == InputEvent.Action.UP) {
                            onClick()
                        }
                    })
                }
            }
        )
    }
}

Saiba o que é possível com o Android XR hoje

A criação do app XR Geospatial Tour mostrou que a barreira de entrada para experiências espaciais mundiais é menor do que nunca para desenvolvedores Android. Com a API Geospatial agora disponível na prévia do Android XR, seus apps podem entender perfeitamente o mundo físico ao redor. Ao combinar as APIs do Compose para XR com os dados de localização de alta precisão do VPS e os recursos generativos do Gemini, podemos criar experiências que entendem onde o usuário está e o que ele está olhando.

Para ajudar você a usar o Android XR, temos o prazer de abrir inscrições para o Programa de catalisador de desenvolvedores do Android XR, que inclui o XREAL Project Aura. A partir de hoje, você pode se inscrever para ter acesso a um kit de desenvolvimento do XREAL Project Aura ou ao nosso kit de desenvolvimento de óculos com tela virtual nos próximos meses.

*Exoneração de responsabilidade: disponível em alguns dispositivos. É necessário ter uma conexão de Internet. Funciona em apps e plataformas compatíveis. Os resultados podem variar.