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 verfügbar als Vorabversion in ARCore for Jetpack XR. Durch die Einbindung 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 an der physischen Welt verankert werden.* Um die Möglichkeiten der Geospatial API zu erkunden, hat unser Team eine Demo entwickelt: die XR Geospatial Tour.

Stell dir vor, du kommst in eine neue Stadt, setzt eine kabelgebundene XR-Brille auf (z. B. die kommende XREAL Project Aura) und hast sofort einen ortskundigen Tourguide, 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 von den historischen Sehenswürdigkeiten direkt vor dir. Wir haben die Geospatial APIs, Gemini API mit Firebase AI Logic, Fundierung mit Google Maps und das Jetpack XR SDK kombiniert, um eine immersive Walking-Tour zu erstellen, bei der du die Hände frei hast.

Haftungsausschluss: Das Video und die Tourguide-Anwendung dienen nur zu Demonstrationszwecken. Einige Sequenzen wurden gekürzt. Die gezeigte Hardware befindet sich möglicherweise noch in der Entwicklung. Die endgültigen Produktdetails können abweichen.

Wir gehen jetzt die Implementierungsdetails durch 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

Optimiere die Navigation in XR, indem du die Leistung von GPS mit der Präzision von VPS kombinierst. Dank der Genauigkeit und präzisen Ausrichtung von VPS können 3D-Wegpunkte an der physischen 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 raumbezogenen 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 Innenbereich oder in einem nicht erkannten Bereich befindet, fordern wir ihn auf, „zu einem öffentlichen Ort im Freien zu gehen und sich umzusehen“.

2. Reiseplan mit der Gemini API und der Fundierung mit Google Maps erstellen

Sobald wir einen Standort haben, verwenden wir die Gemini API mit Firebase AI Logic, um das Gemini-Modell als ortskundigen Tourguide zu nutzen. Wir übergeben die Koordinaten des Nutzers an das Modell und bitten es, eine strukturierte JSON-Antwort mit nahe gelegenen Walking-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.")

Large Language Models können zwar detaillierte Beschreibungen erstellen, aber manchmal liefern sie falsche Breiten- und Längengrade. Um dieses Problem zu beheben, haben wir die Fundierung mit Google Maps 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 Voiceovers 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 ist das Rendern dieser Daten im Sichtfeld des Nutzers. Mit dem Jetpack XR SDK ist der Übergang von einer 2D-Android-UI zu Spatial Computing ganz einfach.

Wir haben Jetpack Compose für XR verwendet, um räumliche Komponenten zu erstellen. Um POIs entlang der Tour darzustellen, haben wir eine komponierbare 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 physische 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 physische 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 starten, das auch XREAL Project Aura umfasst. Ab heute kannst du dich bewerben, um in den kommenden Monaten Zugriff auf ein XREAL Project Aura-Entwicklungskit oder unser Entwicklungskit für Datenbrillen zu erhalten.

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