Mixed-Reality-Tourguide mit Android XR, der Geospatial API und Gemini erstellen

Auf der diesjährigen Google I/O haben wir ein Update für räumliche Erlebnisse angekündigt: Die Geospatial API ist jetzt als Vorschau in ARCore for Jetpack XR verfügbar. Durch die Integration des Visual Positioning System (VPS) von Google in Android XR können digitale Inhalte in unterstützten Bereichen mit einer Genauigkeit von weniger als einem Meter und einer präzisen Ausrichtung in der realen Welt verankert werden.* Um die Möglichkeiten der Geospatial API zu demonstrieren, hat unser Team eine Demo-App entwickelt: die XR Geospatial Tour.

Stell dir vor, du kommst in eine neue Stadt, setzt eine kabelgebundene XR-Brille auf (z. B. das kommende XREAL Project Aura) und hast sofort einen ortskundigen Guide, der dir alles zeigt. Du musst nicht auf eine 2D-Karte schauen, sondern wirst von 3D-Modellen geführt und eine intelligente Stimme erzählt dir etwas über die historischen Sehenswürdigkeiten direkt vor dir. Wir haben die Geospatial APIs, Gemini API mit Firebase AI Logic, Google Maps Grounding und das Jetpack XR SDK kombiniert, um eine immersive Tour zu erstellen, bei der du die Hände frei hast.

Haftungsausschluss: Das Video und die Tourguide-App dienen nur zu Demonstrationszwecken. Einige Sequenzen wurden gekürzt. Die gezeigte Hardware befindet sich möglicherweise noch in der Entwicklung. Die Eigenschaften des finalen Produkts können abweichen.

Wir sehen uns die Implementierungsdetails an und zeigen, wie wir diese APIs kombiniert haben, um ein räumliches Erlebnis im Weltmaßstab zu schaffen.

1. Nutzer mit der ARCore Geospatial API (VPS) lokalisieren

Kombiniere die Leistung von GPS mit der Präzision von VPS, um die Navigation auf XR-Geräten zu verbessern. Dank der Genauigkeit und präzisen Ausrichtung von VPS können 3D-Wegpunkte an der realen Welt ausgerichtet werden.

Deshalb kannst du mit der Geospatial API unter Android XR benutzerdefinierte Erlebnisse erstellen. VPS verwendet fortschrittliche Computer Vision, um eine GeospatialPose (einschließlich Breiten- und Längengrad sowie Ausrichtung) zu liefern, die genauer als GPS ist.

So rufen wir die GeospatialPose des Nutzers ab, indem wir die Ausrichtung des Geräts einer geografischen Koordinate zuordnen:

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

Da das gesamte Erlebnis von dieser Genauigkeit abhängt, beobachten wir horizontalAccuracy und orientationYawAccuracy, bis sie unsere Grenzwerte erreichen. Wenn sich der Nutzer in einem Gebäude oder in einem nicht erkannten Bereich befindet, fordern wir ihn auf, „zu einem öffentlichen Ort im Freien zu gehen und sich umzusehen“.

2. Route mit der Gemini API und Google Maps Grounding erstellen

Sobald wir einen Standort haben, verwenden wir die Gemini API mit Firebase AI Logic, um das Gemini-Modell als lokalen Tourguide zu nutzen. Wir übergeben die Koordinaten des Nutzers an das Modell und bitten es, eine strukturierte JSON-Antwort mit nahe gelegenen Touren auszugeben:

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

Große Sprachmodelle können zwar detaillierte Beschreibungen generieren, aber manchmal liefern sie falsche Breiten- und Längengrade. Um dieses Problem zu beheben, haben wir Google Maps Grounding verwendet, um die KI zu fundieren.

3. Eine Stimme, die dich führt: Gemini 2.5 TTS

Damit sich der Tourguide wirklich präsent anfühlt, haben wir dynamische Voice-Overs implementiert.

Mit dem gemini-2.5-flash-tts model können wir die Konfiguration für die Modellgenerierung so einstellen, dass anstelle von Text Audiodaten zurückgegeben werden. So kannst du ResponseModality.AUDIO anfordern:

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. Mit Jetpack XR in 3D zum Leben erwecken

Der letzte Schritt besteht darin, diese Daten im Sichtfeld des Nutzers zu rendern. Mit dem Jetpack XR SDK ist der Übergang von einer 2D-Android-UI zu Spatial Computing ganz einfach.

Wir haben Jetpack Compose for XR verwendet, um räumliche Komponenten zu erstellen. Um Sehenswürdigkeiten entlang der Tour darzustellen, haben wir eine zusammensetzbare Funktion namens InfoSphere erstellt, die ein GltfModel einer 3D-Kugel enthält, die im Raum schwebt und mit der interagiert werden kann, um Informationen zu erhalten.

Mit dem Jetpack XR SDK können wir 3D-Modelle neben der Compose-UI mit SpatialBox und SceneCoreEntity platzieren. Außerdem haben wir InteractableComponent verwendet, um auf Tippen des Nutzers zu reagieren.

Durch die Kombination von AnimatedSpatialVisibility für herkömmliche Compose-UI-Oberflächen mit SceneCoreEntity-3D-Elementen können wir Daten nahtlos in die reale Welt einblenden.

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

Möglichkeiten von Android XR entdecken

Die Entwicklung der XR Geospatial Tour-App hat uns gezeigt, dass die Einstiegshürde für räumliche Erlebnisse im Weltmaßstab für Android-Entwickler niedriger ist als je zuvor. Da die Geospatial API jetzt als Vorschau unter Android XR verfügbar ist, können deine Apps die reale Welt um sie herum nahtlos verstehen. Durch die Kombination der APIs von Compose for XR mit den hochpräzisen Standortdaten von VPS und den generativen Funktionen von Gemini können wir Erlebnisse schaffen, die sowohl den Standort des Nutzers als auch das, was er sieht, verstehen.

Damit du Android XR selbst ausprobieren kannst, freuen wir uns, die Bewerbungsphase für das Android XR Developer Catalyst Program zu eröffnen, das auch das XREAL Project Aura umfasst. Ab heute kannst du dich bewerben, um in den kommenden Monaten Zugriff auf ein XREAL Project Aura-Entwicklerkit oder unser Entwicklerkit für Datenbrillen zu erhalten.

*Haftungsausschluss: Verfügbar auf ausgewählten Geräten. Es ist eine Internetverbindung erforderlich. Funktioniert mit kompatiblen Apps und Oberflächen. Die Ergebnisse können variieren.