Creazione di una guida turistica in realtà mista con Android XR, l'API Geospatial e Gemini

Al Google I/O di quest'anno, abbiamo annunciato un aggiornamento per le esperienze spaziali: l'API Geospatial è ora disponibile come anteprima in ARCore per Jetpack XR. Integrando il Visual Positioning System (VPS) di Google in Android XR, Android XR consente di ancorare i contenuti digitali al mondo fisico con una precisione inferiore al metro e un orientamento preciso nelle aree supportate.* Per esplorare le potenzialità dell'API Geospatial, il nostro team ha creato una demo: l'XR Geospatial Tour.

Immagina di entrare in una nuova città, indossare un paio di occhiali XR con cavo (come il futuro XREAL Project Aura) e avere subito una guida locale esperta che ti mostri i dintorni. Non devi fissare una mappa 2D: i modelli 3D ti guidano delicatamente lungo il percorso e una voce intelligente ti parla dei monumenti storici che hai di fronte. Abbiamo combinato le API Geospatial, l'API Gemini utilizzando Firebase AI Logic, Google Maps Grounding e l'SDK Jetpack XR per creare un'esperienza di tour a piedi immersiva e a mani libere.

Disclaimer: le applicazioni Video e Guida turistica sono solo a scopo dimostrativo. Alcune sequenze sono state abbreviate. L'hardware raffigurato potrebbe essere in fase di sviluppo; i dettagli del prodotto finale potrebbero variare.

Vediamo i dettagli dell'implementazione e mostriamo come abbiamo collegato queste API per creare un'esperienza spaziale su scala mondiale.

1. Individuare con precisione l'utente con l'API ARCore Geospatial (VPS)

Migliora la tua esperienza di navigazione in XR combinando la potenza del GPS con la precisione del VPS. L'accuratezza e l'orientamento preciso offerti da VPS consentono ai waypoint 3D di allinearsi al mondo fisico.

Ecco perché l'API Geospatial su Android XR può aiutarti a creare esperienze personalizzate. Utilizzando la visione artificiale avanzata, VPS tenta di fornire una GeospatialPose (inclusi latitudine, longitudine e orientamento) più precisa del GPS.

Ecco come recuperiamo la postura spaziale dell'utente mappando l'orientamento del dispositivo a una coordinata spaziale:

// 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}")
}

Poiché l'intera esperienza si basa su questa precisione, monitoriamo horizontalAccuracy e orientationYawAccuracy finché non raggiungono le nostre soglie. Se l'utente si trova in un ambiente interno o in una zona non riconosciuta, gli viene chiesto di "recarsi in uno spazio pubblico all'aperto e guardarsi intorno".

2. Creazione dell'itinerario con l'API Gemini e il grounding di Google Maps

Una volta individuata una posizione, utilizziamo l'API Gemini con Firebase AI Logic per chiedere al modello Gemini di fungere da guida turistica locale. Trasmettiamo le coordinate dell'utente al modello e gli chiediamo di restituire una risposta JSON strutturata contenente i tour a piedi nelle vicinanze:

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

I modelli linguistici di grandi dimensioni sono ottimi per generare descrizioni dettagliate, ma a volte possono inventare coordinate esatte di latitudine/longitudine. Per risolvere il problema, abbiamo utilizzato il grounding di Google Maps per ancorare l'AI.

3. Una voce che ti guida: Gemini 2.5 TTS

Per rendere la guida turistica davvero presente, abbiamo implementato voci fuori campo dinamiche.

Utilizzando gemini-2.5-flash-tts model, possiamo configurare la configurazione di generazione del modello in modo che restituisca in modo nativo i dati audio anziché solo il testo. Ecco come richiedere l'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. Dare vita al mondo in 3D con Jetpack XR

L'ultimo pezzo del puzzle è il rendering di questi dati nel campo visivo dell'utente. L'SDK Jetpack XR rende intuitivo il passaggio da un'interfaccia utente Android 2D allo spatial computing.

Abbiamo utilizzato Jetpack Compose per XR per creare componenti spaziali. Per rappresentare i punti di interesse lungo il tour, abbiamo creato un elemento componibile chiamato InfoSphere, che contiene un GltfModel di una sfera 3D che fluttua nello spazio e con cui è possibile interagire per visualizzare informazioni.

Utilizzando Jetpack XR SDK, possiamo posizionare modelli 3D accanto all'interfaccia utente Compose utilizzando SpatialBox e SceneCoreEntity. Abbiamo anche utilizzato InteractableComponent per rispondere ai tocchi degli utenti.

Combinando AnimatedSpatialVisibility per le superfici UI di Compose tradizionali con gli elementi 3D SceneCoreEntity, possiamo integrare perfettamente i dati nel mondo fisico.

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

Esplora le possibilità offerte da Android XR oggi

La creazione dell'app XR Geospatial Tour ci ha dimostrato che la barriera all'ingresso per le esperienze spaziali su scala mondiale è più bassa che mai per gli sviluppatori Android. Con l'API Geospatial ora disponibile in anteprima su Android XR, le tue app possono comprendere facilmente il mondo fisico che le circonda. Combinando le API di Compose for XR con i dati di localizzazione ad alta precisione di VPS e le funzionalità generative di Gemini, possiamo creare esperienze che comprendono sia la posizione dell'utente sia ciò che sta guardando.

Per aiutarti a fare pratica con Android XR, siamo felici di aprire le candidature per il programma Android XR Developer Catalyst, che include XREAL Project Aura. A partire da oggi, nei prossimi mesi potrai richiedere l'accesso a un devkit XREAL Project Aura o al nostro devkit per occhiali con display. 

*Disclaimer: disponibile su dispositivi selezionati. È necessaria una connessione a internet. Funziona su app e piattaforme compatibili. I risultati possono variare.