Cómo crear un guía turístico 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 ya está disponible como versión preliminar en ARCore para Jetpack XR. Con la incorporación del sistema de posicionamiento visual (VPS) de Google a Android XR, este sistema operativo permite fijar contenido digital al mundo físico con una precisión de menos de un metro y una orientación exacta en las áreas compatibles.* Para explorar lo que la API de Geospatial podría desbloquear, nuestro equipo creó una demostración: el XR Geospatial Tour.

Imagina que llegas a una ciudad nueva, te pones un par de lentes de RE con cable (como los próximos XREAL Project Aura) y, al instante, tienes un guía local experto que te muestra los alrededores. No necesitas mirar un mapa en 2D, sino que los modelos en 3D te guían con delicadeza y una voz inteligente te habla de los puntos de referencia históricos que tienes delante. Combinamos las APIs de Geospatial, la API de Gemini con Firebase AI Logic, la vinculación con Google Maps y el SDK de Jetpack XR para crear una experiencia de recorrido a pie inmersiva y sin usar las manos.

Exención de responsabilidad: El video y la aplicación de Tour Guide son solo con 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 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 precisión y la orientación exacta que ofrece el VPS permiten que los puntos de referencia en 3D se alineen con el mundo físico.

Por este motivo, 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 latitud, longitud y orientación) que es más precisa que el GPS.

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

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

2. Crea 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 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 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 de latitud y longitud exactas. Para resolver este problema, usamos la fundamentación de Google Maps para fundamentar la IA.

3. Una voz que te guiará: TTS de Gemini 2.5

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

Con gemini-2.5-flash-tts model, podemos configurar nuestro parámetro de generación del modelo para que devuelva 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 al contenido en 3D con Jetpack XR

La última pieza del rompecabezas es renderizar estos datos en el campo visual del usuario. El SDK de Jetpack XR hace que la transición de una IU de Android en 2D a la computación espacial sea intuitiva.

Usamos Jetpack Compose para XR para compilar componentes espaciales. Para representar los lugares 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 las presiones del usuario.

Si combinamos AnimatedSpatialVisibility para las plataformas de IU de Compose tradicionales con los 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, que ahora está 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 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 se encuentra el usuario y qué está mirando.

Para ayudarte a comenzar a usar Android XR, nos complace abrir las postulaciones para el Programa de catalizadores para desarrolladores de Android XR, que incluye el Project Aura de XREAL. A partir de hoy, puedes postularte para obtener acceso a un kit de desarrollo de Project Aura de XREAL o a nuestro kit de desarrollo de lentes con 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.