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 versión preliminar 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 admitidas.* Para explorar lo que podría desbloquear la API de Geospatial, nuestro equipo creó una demostración: el XR Geospatial Tour.

Imagina que entras en una ciudad nueva, te pones un par de lentes XR con cable (como el próximo XREAL Project Aura) y, al instante, tienes un guía local experto que te muestra la ciudad. No necesitas mirar un mapa en 2D. En cambio, los modelos en 3D te guían suavemente por el camino, 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 con manos libres.

Renuncia de responsabilidad: Las aplicaciones de Video y Tour Guide son solo para fines de demostración. Se acortaron algunas secuencias. Es posible que el hardware que se muestra esté en desarrollo, por lo que los detalles del producto final pueden variar.

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

1. Cómo determinar la ubicación del 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 exactitud 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 la visión artificial avanzada, el VPS intenta proporcionar una GeospatialPose (que incluye la latitud, la longitud y la orientación) más precisa que el GPS.

A continuación, se explica cómo 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}")
}

Dado 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 a través de Firebase AI Logic para indicarle al modelo de Gemini que actúe como guía turístico local. Pasamos las coordenadas del usuario al modelo y le pedimos que genere una respuesta JSON estructurada que contenga los 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 extenso son excelentes para generar descripciones enriquecidas, pero a veces pueden alucinar coordenadas exactas de latitud y longitud. Para resolver este problema, usamos la Fundamentación de Google Maps para fundamentar la IA.

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

Para que el guía del recorrido se sienta realmente presente, implementamos voces en off dinámicas.

Con gemini-2.5-flash-tts model, podemos configurar nuestro archivo de configuración de generación de modelos para que muestre datos de audio de forma nativa en lugar de solo texto. Sigue estos pasos para solicitar el 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 dar vida a los objetos 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 XR de Jetpack facilita la transición intuitiva 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 una esfera 3D que flota en el espacio y con la 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.

Cuando combinamos 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 las posibilidades de Android XR hoy mismo

La creación de la app de XR Geospatial Tour 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. Si combinamos las APIs de Compose for 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 probar Android XR, nos complace anunciar que ya se pueden enviar solicitudes para el Programa Catalyst para desarrolladores de Android XR, que incluye el Proyecto 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 pantalla en los próximos meses. 

*Aviso importante: Disponible en dispositivos seleccionados. Se requiere una conexión a Internet. Funciona en plataformas y apps compatibles. Los resultados pueden variar.