Como criar um guia turístico de realidade mista com o Android XR, a API Geospatial e o Gemini

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 sistema operacional 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 oferecer, nossa equipe criou uma demonstração: o tour geoespacial de XR.

Imagine entrar em uma nova cidade, colocar um ó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 é preciso 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, a API Gemini usando o Firebase AI Logic, o Embasamento do Google Maps e o SDK do Jetpack para XR para criar uma experiência de tour a pé imersiva e sem as mãos.

Aviso legal: o vídeo e o aplicativo do guia turístico são apenas para fins de demonstração. Algumas sequências foram reduzidas. 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 em escala mundial.

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

Melhore sua experiência de navegação em XR combinando o poder do GPS com a precisão do VPS. A precisão e a orientação 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 geoespacial do usuário mapeando a orientação do dispositivo para uma coordenada geoespacial:

// 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, vamos pedir 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 com o Firebase AI Logic para pedir que o modelo Gemini atue como um guia turístico local. Transmitimos as coordenadas do usuário para o 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 a geração de modelos para retornar dados de áudio de forma nativa 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 do Jetpack para 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 usado para revelar informações.

Usando o SDK do Jetpack para 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 do SceneCoreEntity, podemos mesclar dados ao 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 em escala mundial é menor do que nunca para desenvolvedores Android. Com a API Geospatial já disponível na prévia do Android XR, seus apps podem entender 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 de exibição nos próximos meses.

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