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 agora está disponível como pré-lançamento 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 ao mundo físico com precisão submétrica 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 em uma cidade nova, colocar um par de óculos XR com fio (como o próximo Project Aura da XREAL) e, instantaneamente, ter 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 com cuidado, e uma voz inteligente fala sobre os pontos históricos bem na sua frente. Combinamos as APIs Geospatial, API Gemini usando a Firebase AI Logic, embasamento do Google Maps e SDK do Jetpack XR para criar uma experiência de passeio imersiva e sem usar as mãos.

Exoneração de responsabilidade: o vídeo e o aplicativo Tour Guide são apenas para fins de demonstração. Algumas sequências foram reduzidas. Os hardwares mostrados podem 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 exata do VPS permitem que os waypoints 3D se alinhem com o mundo físico.

Por isso, a API Geospatial no Android XR pode ajudar você a criar experiências personalizadas. Usando 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 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 "vá para 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 termos um local, usamos a API Gemini com o Firebase AI Logic para pedir que o modelo do Gemini atue como um guia turístico local. Passamos as coordenadas do usuário para o modelo e pedimos que ele gere uma resposta JSON estruturada com passeios a pé por perto:

   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 ricas, 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 turístico pareça realmente presente, implementamos narrações dinâmicas.

Usando o gemini-2.5-flash-tts model, podemos configurar a geração do modelo 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. Dando vida em 3D com o Jetpack XR

A última peça 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 2D do Android 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 globo 3D que flutua no espaço e pode ser interagido para revelar informações.

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

Ao combinar AnimatedSpatialVisibility para superfícies de interface tradicionais do Compose com elementos 3D do SceneCoreEntity, podemos combinar dados com o mundo físico de forma 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 com o Android XR hoje mesmo

A criação do app XR Geospatial Tour nos mostrou que a barreira de entrada para experiências espaciais em escala mundial está mais baixa do que nunca para desenvolvedores Android. Com a API Geospatial já disponível em pré-lançamento no Android XR, seus apps podem entender o mundo físico ao redor deles. 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á vendo.

Para ajudar você a colocar a mão na massa com o Android XR, temos o prazer de abrir as inscrições para o Programa de Catalisadores para Desenvolvedores do Android XR, que inclui o Project Aura da XREAL. A partir de hoje, você pode se inscrever para receber um kit de desenvolvimento do Project Aura da XREAL ou um kit de desenvolvimento dos nossos óculos de tela 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.