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) do Google para o Android XR, o Android XR permite ancorar conteúdo digital no mundo físico com precisão submetrica e orientação precisa em áreas compatíveis.* Para mostrar o que a API Geospatial pode fazer, nossa equipe criou uma demonstração: o XR Geospatial Tour.

Imagine chegar a uma nova cidade, colocar um par de óculos XR com fio (como o futuro XREAL Project Aura) e ter instantaneamente um guia local experiente mostrando tudo para você. Você não precisa ficar olhando para um mapa 2D. Em vez disso, modelos 3D guiam seu caminho, e uma voz inteligente informa sobre os marcos históricos bem na sua frente. Combinamos as APIs geoespaciais, a API Gemini usando a Firebase AI Logic, o Google Maps Grounding e o SDK Jetpack XR para criar uma experiência de tour a pé imersiva e sem usar as mãos.

Exoneração de responsabilidade: os aplicativos "Vídeo" e "Guia de passeio" 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. 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 acurácia e a orientação exata do VPS permitem que os waypoints 3D se alinhem ao mundo físico.

Por isso, 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 postura 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 o horizontalAccuracy e o orientationYawAccuracy até que eles atendam aos nossos limites. Se o usuário estiver em um ambiente fechado 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 uma localização, usamos a API Gemini com o Firebase AI Logic para pedir ao modelo do 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 com passeios 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 o Embasamento do Google Maps para embasar a IA.

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

Para que o guia pareça estar realmente presente, implementamos narrações 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. Saiba 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. Dando vida a ele 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 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 o InteractableComponent para responder aos toques do usuário.

Ao combinar AnimatedSpatialVisibility para superfícies tradicionais da interface do Compose com elementos 3D do SceneCoreEntity, é possível combinar dados com o mundo físico de maneira integrada.

@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()
                        }
                    })
                }
            }
        )
    }
}

Descubra o que é possível fazer 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 está menor do que nunca para desenvolvedores Android. Com a API Geospatial agora disponível em prévia no 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 conhecer o Android XR, estamos abrindo as inscrições para o Programa Catalyst para desenvolvedores do Android XR, que inclui o Projeto Aura da XREAL. A partir de hoje, você pode se inscrever para ter acesso a um devkit do Projeto Aura da XREAL ou ao nosso devkit de óculos com tela virtual 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.