Cómo crear una guía turística de realidad mixta con Android XR, la API de Geospatial y Gemini

En el Google I/O de este año, anunciamos una actualización para las experiencias espaciales: la API de Geospatial ahora está disponible como vista previa en ARCore para Jetpack XR. Al incorporar el Sistema de Posicionamiento Visual (VPS) de Google a Android XR, Android XR permite anclar contenido digital al mundo físico con una precisión inferior a un metro y una orientación precisa en las áreas compatibles.* Para explorar lo que podría desbloquear la API de Geospatial, nuestro equipo creó una demostración: el recorrido geoespacial de XR.

Imagina que entras en una ciudad nueva, te pones un par de lentes de XR con cable (como el próximo Project Aura de XREAL) y, al instante, tienes una guía local experta que te muestra los alrededores. No necesitas mirar un mapa 2D. En cambio, los modelos 3D guían tu camino con suavidad y una voz inteligente te cuenta sobre los lugares históricos que tienes frente a ti. Combinamos las APIs de Geospatial, la API de Gemini con Firebase AI Logic, la Fundamentación de Google Maps y el SDK de Jetpack XR para crear una experiencia de recorrido a pie inmersiva y sin manos.

Renuncia de responsabilidad: El video y la aplicación de guía turística son solo para fines de demostración. Se acortaron algunas secuencias. Es posible que el hardware que se muestra esté en desarrollo. Los detalles del producto final pueden variar.

Analicemos los detalles de la implementación y mostremos cómo unimos estas APIs para crear una experiencia espacial a escala mundial.

1. Cómo identificar al usuario con la API de ARCore Geospatial (VPS)

Mejora tu experiencia de navegación en XR combinando la potencia del GPS con la precisión del VPS. La precisión y la orientación precisa que ofrece el VPS permiten que los puntos de referencia 3D se alineen con el mundo físico.

Por eso, la API de Geospatial en Android XR puede ayudarte a crear experiencias personalizadas. Con el uso de la visión artificial avanzada, el VPS intenta proporcionar una GeospatialPose (incluida la latitud, la longitud y el rumbo) que sea más precisa que el GPS.

Esta es la forma en que recuperamos la posición geoespacial del usuario asignando la orientación del dispositivo a una 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}")
}

Debido a que toda la experiencia depende de esta precisión, supervisamos horizontalAccuracy y orientationYawAccuracy hasta que cumplen con nuestros umbrales. Si el usuario está en el interior o en un área no reconocida, le pedimos que "camine a un espacio público al aire libre y mire a su alrededor".

2. Cómo crear el itinerario con la API de Gemini y la Fundamentación de Google Maps

Una vez que tenemos una ubicación, usamos la API de Gemini con Firebase AI Logic para pedirle al modelo de Gemini que actúe como guía turística local. Pasamos las coordenadas del usuario al modelo y le pedimos que genere una respuesta JSON estructurada que contenga recorridos a pie cercanos:

   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.")

Los modelos de lenguaje grandes son excelentes para generar descripciones enriquecidas, pero a veces pueden alucinar coordenadas exactas de latitud y longitud. Para resolver este problema, usamos Fundamentación de Google Maps para fundamentar la IA.

3. Una voz que te guía: Gemini 2.5 TTS

Para que la guía turística se sienta realmente presente, implementamos voces en off dinámicas.

Con el gemini-2.5-flash-tts model, podemos configurar la configuración de generación de nuestro modelo para que muestre datos de audio de forma nativa en lugar de solo texto. Esta es la forma en que puedes solicitar 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. Cómo darle vida en 3D con Jetpack XR

La pieza final del rompecabezas es renderizar estos datos en el campo de visión del usuario. El SDK de Jetpack XR facilita la transición de una IU de Android 2D a la computación espacial.

Usamos Jetpack Compose para XR para compilar componentes espaciales. Para representar los puntos de interés a lo largo del recorrido, creamos un elemento componible llamado InfoSphere, que contiene un GltfModel de un orbe 3D que flota en el espacio y con el que se puede interactuar para revelar información.

Con el SDK de Jetpack XR, podemos colocar modelos 3D junto con la IU de Compose usando SpatialBox y SceneCoreEntity. También usamos InteractableComponent para responder a los toques del usuario.

Al combinar AnimatedSpatialVisibility para las superficies de la IU de Compose tradicionales con elementos 3D de SceneCoreEntity, podemos combinar datos sin problemas en el 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()
                        }
                    })
                }
            }
        )
    }
}

Explora lo que es posible con Android XR hoy mismo

La creación de la app de recorrido geoespacial de XR nos demostró que la barrera de entrada para las experiencias espaciales a escala mundial es más baja que nunca para los desarrolladores de Android. Con la API de Geospatial ahora disponible en versión preliminar en Android XR, tus apps pueden comprender sin problemas el mundo físico que las rodea. Al combinar las APIs de Compose para XR con los datos de ubicación de alta precisión del VPS y las capacidades generativas de Gemini, podemos crear experiencias que comprendan dónde está el usuario y qué está mirando.

Para ayudarte a usar Android XR, nos complace abrir las solicitudes para el Programa de Catalyst para desarrolladores de Android XR, que incluye el Project Aura de XREAL. A partir de hoy, puedes solicitar acceso a un kit de desarrollo de Project Aura de XREAL o a nuestro kit de desarrollo de lentes de visualización en los próximos meses.

*Renuncia de responsabilidad: Disponible en dispositivos determinados. Se requiere una conexión a Internet. Funciona en plataformas y apps compatibles. Los resultados pueden variar.