Ihre erste Business-App für XREAL Aura mit Android Studio entwickeln

Ihre erste Business-App für XREAL Aura mit Android Studio entwickeln

Zusammenfassung

Dieser Leitfaden zeigt, wie Sie in Android Studio mit Kotlin und dem Jetpack XR SDK eine Business-App für XREAL Aura erstellen. Sie legen ein Projekt an, fügen die Bibliothek für räumliche Benutzeroberflächen hinzu, übernehmen ein kleines Beispiel für ein Aufgaben-Panel und führen es im XR-Glasses-Emulator aus, bevor Sie es auf Aura-Hardware testen.

Das Beispiel zeigt Arbeitsanweisungen an und lässt Nutzer jede Aufgabe bestätigen. Es ist ein Ausgangspunkt für eine Business-Anwendung – ohne dauerhafte Arbeitsprotokolle und ohne Prüfung, ob eine physische Aufgabe tatsächlich erledigt wurde. Der Code folgt der geprüften Dokumentation, wurde aber weder kompiliert noch auf Aura-Hardware getestet.

Einführung

Die Entwicklung einer Business-App für XREAL Aura beginnt in Android Studio, wo Sie Kotlin-Code schreiben und mit dem Jetpack XR SDK eine räumliche Benutzeroberfläche hinzufügen. Dieser Leitfaden führt Sie vom Anlegen eines Projekts über die Ausführung im Emulator bis zum Test auf Aura. Als einfaches Beispiel erstellen Sie ein Panel, das Arbeitsanweisungen anzeigt und Nutzer jede Aufgabe bestätigen lässt.

XREAL Aura kombiniert eine kabelgebundene Brille mit einem Android-XR-Computing-Puck. Folgen Sie dem Android-XR-Workflow für kabelgebundene XR-Brillen und nicht dem separaten Workflow für Audio- und Display-Brillen mit Projektion vom Smartphone. Hintergrundinformationen zur Hardware finden Sie in der VRX-Übersicht zu XREAL Aura und auf der offiziellen Aura-Seite von XREAL. [1]

Bevor Sie beginnen

· Verwenden Sie für die ersten Downloads einen vom Unternehmen freigegebenen Computer mit Internetzugang

· Prüfen Sie Googles Systemanforderungen für den XR-Emulator, die derzeit unterstützte Windows- und macOS-Konfigurationen abdecken [2]

· Besorgen Sie für physische Tests die Aura-Brille, den zugehörigen Compute-Puck und die Anleitung des Kits für die Entwicklerverbindung

Verfügbarkeit: Klären Sie die regionale Lieferbarkeit mit VR Expert. Die aktuelle Seite von XREAL priorisiert die USA, Kanada, Japan und Südkorea; ältere Reservierungslisten sollten nicht als bestätigte Lieferung nach Europa gewertet werden. [1]

Schritt 1: Android Studio und die SDK-Tools installieren

Installieren Sie zunächst Android Studio und die SDK-Tools, mit denen Sie die App erstellen, ein simuliertes XR-Gerät ausführen und eine Verbindung zur Hardware herstellen.

Google empfiehlt für XR Android Studio Canary. Canary ist eine Vorschauversion mit neueren Tools und möglicherweise unfertigen Funktionen; Sie können sie parallel zu Ihrem bestehenden Android Studio installieren.

· Öffnen Sie Android Studio Preview, laden Sie das passende Installationsprogramm herunter und schließen Sie den Installationsassistenten ab.

· Wählen Sie auf dem Willkommensbildschirm von Android Studio More Actions > SDK Manager. Ist bereits ein Projekt geöffnet, verwenden Sie im oberen Menü Tools > SDK Manager.

· Im Einstellungsfenster des SDK Managers finden Sie oberhalb der Liste installierbarer Pakete die Registerkarten SDK Platforms und SDK Tools. Beide Registerkarten gehören zum selben SDK-Manager-Fenster.

· Wählen Sie SDK Tools. Aktivieren Sie Android SDK Build-Tools, Android Emulator und Android SDK Platform-Tools. Lassen Sie sie ausgewählt, falls sie bereits installiert sind, und spielen Sie verfügbare Updates ein. Build-Tools erstellt die Installationsdatei der App, Emulator führt simulierte Geräte aus, und Platform-Tools enthält das Geräteverbindungstool ADB.

· Klicken Sie auf Apply, prüfen Sie die ausgewählten Downloads, akzeptieren Sie die erforderlichen Lizenzen und warten Sie, bis die Installation abgeschlossen ist. Klicken Sie auf OK, um das Fenster zu schließen.

Über die Registerkarte SDK Platforms wird die Android-Plattform installiert, mit der die App kompiliert wird. Die erforderliche Version ergibt sich aus der Projektkonfiguration. Legen Sie das Projekt in Schritt 2 an und wählen Sie dann anhand seiner compileSdk-Einstellung die passende Plattform aus. Schritt 6 behandelt das System-Image des XR-Emulators, das das Betriebssystem für das simulierte Gerät bereitstellt.

Kontrollpunkt: Die drei SDK-Tools sind installiert. Sie können jetzt das Projekt anlegen. [3, 13]

Schritt 2: Das Projekt für die XREAL-Aura-Business-App anlegen

Die XR-Projektvorlage erstellt die Ausgangsdateien und die Build-Konfiguration der App. Folgen Sie Googles Anleitung für Android-XR-Projekte für Ihre installierte Studio-Version. [4]

· Kehren Sie in Android Studio zum Willkommensbildschirm zurück und klicken Sie auf New Project, oder wählen Sie File > New > New Project.

· Wählen Sie in der Vorlagenliste XR und dann die Vorlage für XR-Headsets und kabelgebundene XR-Brillen. Googles Projektseite nennt keine Vorlagennamen mehr (dort heißt es, man solle die Vorlage wählen, die dem Typ des XR-Geräts entspricht, für das man entwickeln möchte), und die Namen können sich zwischen Canary-Releases ändern; übernehmen Sie den genauen Namen für den Screenshot daher aus der IDE. Wählen Sie nicht die Vorlage für Audio- oder Display-Brillen, die eine vom Smartphone projizierte Anwendung erstellt.

· Klicken Sie auf Next. Geben Sie AuraTaskPanel im Feld Name ein. Geben Sie im Feld Package name für dieses Tutorial com.example.aurataskpanel ein. Wählen Sie Kotlin, falls eine Sprachauswahl erscheint. Der Paketname identifiziert den Code der App und kann an Ihre Organisation angepasst werden. Er wird in Android Studio als durch Punkte getrennter Bezeichner eingegeben, ohne https:// oder einen Webadresspfad.

Übernehmen Sie anschließend die Build-Einstellungen der generierten Vorlage und klicken Sie auf Finish. Warten Sie, bis die erste Gradle-Synchronisierung abgeschlossen ist. Beim Sync liest Android Studio die Build-Konfiguration ein und löst deren Abhängigkeiten auf.

Öffnen Sie View > Tool Windows > Project und wählen Sie dann in der Ansichtsauswahl des Bereichs Android. Sie werden mit diesen Dateien arbeiten:

· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Enthält den Einstiegspunkt und die Benutzeroberfläche der App; in manchen Versionen heißt der Quellordner java

· AndroidManifest.xml: app > manifests. Deklariert den Einstiegspunkt, die Berechtigungen und die Starteinstellungen der App

· build.gradle.kts (Module :app): Gradle Scripts. Konfiguriert den Build und die Bibliotheken der App

Die vom Projekt angeforderte Plattform installieren

Die Einstellung compileSdk legt fest, welche Android-API-Version Android Studio beim Erstellen der App verwendet. Installieren Sie die passende SDK-Plattform; wählen Sie keine Plattform allein anhand der Brillenmarke aus.

· Öffnen Sie im Project-Bereich von Android Studio Gradle Scripts > build.gradle.kts (Module :app). Suchen Sie im android-Block nach compileSdk. Ein Wert wie compileSdk = 36 bedeutet, dass das Projekt Android API 36 benötigt. Diese Zahl ist ein Beispiel, kein für jedes Aura-Projekt vorgeschriebener Wert.

· Verweist der Wert auf einen Katalogeintrag wie libs.versions.compileSdk, öffnen Sie Gradle Scripts > libs.versions.toml und lesen Sie den referenzierten Wert ab. Verwendet die Vorlage einen Vorschaunamen oder eine verschachtelte compileSdk-Konfiguration, behalten Sie diese Einstellung bei und verwenden Sie die dazu passende Plattform.

· Öffnen Sie Tools > SDK Manager > SDK Platforms. Wählen Sie die Zeile, deren API Level der Projekteinstellung entspricht. Klicken Sie auf Apply, schließen Sie den Download ab und klicken Sie dann auf OK.

· Kehren Sie zum Projekt zurück und wählen Sie File > Sync Project with Gradle Files oder Sync Now, falls ein Banner dies anbietet. Die Gradle-Synchronisierung liest die Build-Einstellungen ein und lädt die vom Projekt benötigten Bibliotheken herunter.

Behalten Sie die Plattformeinstellung der Vorlage bei. Meldet Android Studio eine fehlende Plattform, installieren Sie diese, statt compileSdk herabzusetzen, um den Download zu umgehen. Das XR-Geräte-Image für Tests wird separat in Schritt 6 ausgewählt. [13]

Kontrollpunkt: Die erforderliche SDK-Plattform ist installiert, und das Build- bzw. Sync-Toolfenster zeigt keine ungelösten Fehler.

Schritt 3: Die XR-Bibliothek hinzufügen und die Kotlin-Kompatibilität prüfen

Fügen Sie Jetpack Compose for XR hinzu, um der App Komponenten für räumliche Panels bereitzustellen, und prüfen Sie die Kotlin-Kompatibilität, damit das Projekt diese Bibliothek ohne Versionsfehler bauen kann. Dieses Beispiel verwendet XR Compose 1.0.0-beta02 (21.10.2026, weiterhin das neueste Release), das laut Googles Release Notes Kotlin 2.2 voraussetzt. Laut denselben Release Notes hängt beta02 von SceneCore 1.0.0-rc01 ab, das ein bekanntes Speicherleck aufweist; fügen Sie daher in Schritt 3 ergänzend zur Compose-Zeile implementation (“androidx.xr.scenecore:1.0.0”) oder neuer hinzu.

Die Kotlin-Version einmalig prüfen

· Erweitern Sie in Android Studio Gradle Scripts und öffnen Sie per Klick libs.versions.toml. Diese Datei ist, sofern vorhanden, die zentrale Liste der Bibliotheks- und Plugin-Versionen des Projekts.

· Suchen Sie unter [versions] nach dem Kotlin-Eintrag, häufig kotlin = "2.2.0" oder eine andere 2.2.x-Version. Behalten Sie die kompatible Version bei, die die aktuelle Vorlage mitbringt.

· Verwendet das Projekt das Plugin org.jetbrains.kotlin.plugin.compose, muss dessen Version zur Kotlin-Version passen. Vorlagen lassen häufig beide auf denselben Kotlin-Versionseintrag verweisen; behalten Sie diese Verknüpfung bei.

· Gibt es weder einen Kotlin-Eintrag noch einen Katalog, prüfen Sie die übergeordnete Datei build.gradle.kts auf explizit deklarierte Kotlin-Plugins. Einige neuere Build-Konfigurationen verwalten Kotlin über die Android-Build-Tools. Behalten Sie in diesem Fall die generierte Konfiguration bei und prüfen Sie die Kotlin-Kompatibilität der Toolchain, falls ein Build-Fehler auftritt; fügen Sie kein zweites Kotlin-Plugin hinzu, nur um einen Versionseintrag zu erzeugen.

Bringt die Vorlage bereits kompatible Kotlin-Tools mit, ändern Sie nichts. Meldet ein Build, dass Kotlin für die XR-Bibliothek zu alt ist, aktualisieren Sie die Kotlin-Tools des Projekts und ein gegebenenfalls zugehöriges Compose-Compiler-Plugin gemeinsam – mit der für diese Vorlage unterstützten Konfiguration. Ändern Sie keine Build-Einstellungen, die damit nichts zu tun haben.

Die Abhängigkeit für die räumliche Benutzeroberfläche hinzufügen

· Öffnen Sie Gradle Scripts > build.gradle.kts (Module :app).

· Suchen Sie den vorhandenen Block dependencies { ... }.

· Suchen Sie nach einer XR-Compose-Abhängigkeit, die entweder direkt eingetragen ist oder über einen Alias wie implementation(libs.androidx.xr.compose) eingebunden wird. Ist bereits ein Alias vorhanden, setzen Sie die referenzierte XR-Compose-Version in libs.versions.toml auf 1.0.0-beta02. Fügen Sie dieselbe Bibliothek nicht doppelt hinzu.

· Fehlt XR Compose, fügen Sie diese Zeile in den vorhandenen dependencies-Block ein:

implementation("androidx.xr.compose:compose:1.0.0-beta02")

Behalten Sie die übrigen Abhängigkeiten der Vorlage bei. Insbesondere verwendet der folgende Code das reguläre Material 3 – die Bibliothek, die Schaltflächen, Text und Theme bereitstellt – sowie Activity Compose, das Compose-Inhalte in einer Android-Activity hostet.

Synchronisieren und fortfahren

Klicken Sie im Editor-Banner auf Sync Now oder wählen Sie File > Sync Project with Gradle Files. Warten Sie, bis der Download- und Konfigurationsvorgang abgeschlossen ist.

Kontrollpunkt: Die Synchronisierung wird ohne Abhängigkeits- oder Kotlin-Kompatibilitätsfehler abgeschlossen. Behalten Sie nach erfolgreichem Sync die übrigen generierten Build-Einstellungen bei und öffnen Sie dann MainActivity.kt, um die Benutzeroberfläche hinzuzufügen. Meldet der Sync einen Abhängigkeitsfehler, vergleichen Sie die genannte Komponente mit Googles Einrichtungsseite für das Jetpack XR SDK. [6]

Schritt 4: Das Aufgaben-Panel in Kotlin erstellen

Die Oberfläche zeigt den Aufgabentext mit einer Schaltfläche Mark complete und einer Schaltfläche Restart demo an. Die Beispielanweisungen können später durch ein freigegebenes betriebliches Verfahren ersetzt werden.

Behalten Sie in derselben Datei MainActivity.kt in Android Studio die package-Zeile bei, falls Ihr Paket abweicht, und ersetzen Sie den Rest der Datei durch den folgenden Code. Entfernen Sie die alten Beispiel- und Vorschaufunktionen der Vorlage aus dieser Datei, sodass es nur eine MainActivity gibt. Eine Activity ist ein Android-Einstiegspunkt, der eine Benutzeroberfläche hostet. Das folgende Beispiel enthält die Activity und ihre Imports.

package com.example.aurataskpanel
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.xr.compose.platform.LocalSpatialCapabilities
import androidx.xr.compose.spatial.Subspace
import androidx.xr.compose.subspace.SpatialPanel
import androidx.xr.compose.subspace.layout.SubspaceModifier
import androidx.xr.compose.subspace.layout.height
import androidx.xr.compose.subspace.layout.width
class MainActivity : ComponentActivity() {
	override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    	setContent {
            MaterialTheme(colorScheme = darkColorScheme()) {
                TaskApp()
        	}
    	}
	}
}
@Composable
private fun TaskApp() {
	val steps = listOf(
    	"Check that the training area is clear.",
        "Confirm the training device is charged.",
    	"Open the approved training application."
	)
	var completed by rememberSaveable { mutableIntStateOf(0) }
	val content: @Composable () -> Unit = {
    	TaskPanel(
        	steps = steps,
            completed = completed,
            onComplete = {
            	if (completed < steps.size) completed++
        	},
            onRestart = { completed = 0 }
    	)
	}
	if (LocalSpatialCapabilities.current.isSpatialUiEnabled) {
    	Subspace {
            SpatialPanel(
                modifier = SubspaceModifier
                    .width(640.dp)
                    .height(540.dp)
        	) {
                content()
        	}
    	}
	} else {
    	content()
	}
}
@Composable
private fun TaskPanel(
	steps: List<String>,
	completed: Int,
	onComplete: () -> Unit,
	onRestart: () -> Unit
) {
	val finished = completed >= steps.size
    Surface(modifier = Modifier.fillMaxSize()) {
    	Column(
            modifier = Modifier
                .fillMaxSize()
                .verticalScroll(rememberScrollState())
                .padding(24.dp),
            verticalArrangement = Arrangement.spacedBy(16.dp)
    	) {
            Text("Training station preparation", fontSize = 28.sp)
            Text("Demo procedure v1.0", fontSize = 18.sp)
        	Text(
                "$completed of ${steps.size} tasks acknowledged",
                fontSize = 20.sp
        	)
        	Text(
            	if (finished) "Checklist complete"
                else "Task ${completed + 1}: ${steps[completed]}",
                fontSize = 26.sp
        	)
        	Text(
                "Your confirmation does not verify physical work.",
                fontSize = 18.sp
        	)
        	Button(
                onClick = onComplete,
                enabled = !finished,
                modifier = Modifier
                    .fillMaxWidth()
                    .heightIn(min = 64.dp)
        	) {
                Text("Mark complete", fontSize = 22.sp)
        	}
            OutlinedButton(
                onClick = onRestart,
                modifier = Modifier
                    .fillMaxWidth()
                    .heightIn(min = 64.dp)
        	) {
                Text("Restart demo", fontSize = 22.sp)
        	}
    	}
	}
}

Was der Code macht

· steps enthält die Anweisungstexte

· completed zählt die Bestätigungen und verhindert, dass über die letzte Aufgabe hinaus weitergeschaltet wird

· rememberSaveable bewahrt diesen kleinen Wert bei unterstützten Neuerstellungen des Android-Bildschirms und bei der Zustandswiederherstellung; es handelt sich nicht um dauerhaften Speicher

· LocalSpatialCapabilities prüft, ob eine räumliche Benutzeroberfläche verfügbar ist [7]

· Subspace erstellt einen Bereich für räumliche Inhalte, und SpatialPanel platziert die Benutzeroberfläche darin [8]

· Der Fallback-Zweig zeigt denselben Inhalt in einem normalen Fenster an, wenn keine räumliche Benutzeroberfläche verfügbar ist

Die Einheit dp skaliert Layoutmaße entsprechend der Bildschirmdichte; sp skaliert Text und berücksichtigt Einstellungen zur Schriftgröße. Der Scroll-Container hält auch längere Anweisungen erreichbar. Betrachten Sie die Panelgröße als Ausgangspunkt und prüfen Sie die Lesbarkeit auf Aura.

Kontrollpunkt: Android Studio erkennt die Imports und zeigt keine Kotlin-Syntaxfehler an. Erfordert Ihre installierte Bibliothek ein Opt-in für eine experimentelle API, verwenden Sie genau die Annotation, die in der Compiler-Diagnose genannt wird, und prüfen Sie die API-Referenz des betreffenden Releases.

Schritt 5: Prüfen, wie die App in Android XR startet

Konfigurieren Sie den Startmodus so, dass Android XR die App mit dem in diesem Beispiel verwendeten räumlichen Layout öffnen kann.

Auf der Aura-Brille sind Home Space und Full Space bereits in Android XR integriert und steuern, wie laufende Apps angezeigt werden. Der XR-Glasses-Emulator stellt diese Modi für die Entwicklung bereit, eine separate Installation ist also nicht nötig.

Öffnen Sie im Project-Bereich von Android Studio app > manifests > AndroidManifest.xml und sehen Sie sich den MainActivity-Eintrag an. Behalten Sie dessen MAIN- und LAUNCHER-Intent-Filter, die exported-Einstellung und das generierte Theme bei. Für ein von Compose verwaltetes Full Space ist die unten gezeigte Property maßgeblich. Deklariert die Vorlage bereits eine Start-Property auf Application- oder Activity-Ebene, bearbeiten Sie den vorhandenen Wert, statt ihn zu duplizieren. [9]

<!-- Inside the existing MainActivity element -->
<property
    android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
    android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />

Managed Full Space bedeutet, dass Android die räumliche Szene für die Activity verwaltet. Der Wert UNMANAGED ist für Apps gedacht, die über OpenXR rendern, eine plattformübergreifende XR-Schnittstelle; dieses Compose-Beispiel verwendet ihn nicht. Ziehen Sie beim Vergleich von Vorlagen die Referenz der Manifest-Konstanten heran. [9]

Behalten Sie im vorhandenen application-Element außerdem android:enableOnBackInvokedCallback="true" bei oder fügen Sie es hinzu, damit das räumliche Panel Zurück-Ereignisse empfängt, wie in Googles Panel-Leitfaden dokumentiert; das dortige Beispiel setzt das Attribut am activity-Element, es ist aber auch am application-Element gültig. Fügen Sie für diese statische Checkliste keine Berechtigungen für Kamera, Mikrofon oder Szenenverständnis hinzu. Sie erfasst weder den Raum noch erkennt sie Objekte. [8]

Schritt 6: Einen Emulator für XR-Brillen erstellen und die App ausführen

Führen Sie die App auf einem simulierten XR-Brillengerät aus, bevor Sie Aura anschließen. Ein Emulator simuliert ein Gerät auf Ihrem Computer; ein AVD ist dessen gespeicherte Konfiguration.

· Öffnen Sie in Android Studio Tools > Device Manager. Klicken Sie auf das Steuerelement zum Hinzufügen eines Geräts und wählen Sie Create Virtual Device.

· Wählen Sie unter Form Factor die Option XR und dann XR Glasses. Klicken Sie auf Next.

· Wählen Sie das für das XR-Glasses-Profil erforderliche Preview-API-System-Image aus und laden Sie es herunter, falls Sie dazu aufgefordert werden. Wählen Sie eine unterstützte Image-Architektur, die zu Ihrem Computer passt. Schließen Sie die Konfiguration ab.

· Starten Sie das AVD über die zugehörige Play-Schaltfläche. Warten Sie, bis die Android-XR-Umgebung vollständig geladen ist.

· Wählen Sie in der oberen Symbolleiste von Android Studio die Ausführungskonfiguration der App und das laufende XR-Glasses-Gerät aus. Klicken Sie auf Run, das grüne Dreieck.

Der Emulator installiert und öffnet die App. Lösen Sie Mark complete über die Eingabesteuerung des Emulators aus. Bleibt das Panel im Home Space, prüfen Sie das Manifest und die Full-Space-Steuerung der Umgebung, bevor Sie das Kotlin-Layout ändern. Siehe die offizielle AVD-Anleitung.

Führen Sie diese Abnahmeprüfung durch:

· Der erste Bildschirm zeigt null von drei bestätigten Aufgaben und die erste Anweisung

· Jedes Auslösen von Mark complete schaltet genau eine Anweisung weiter

· Beim dritten Auslösen erscheint Checklist complete, und Mark complete wird deaktiviert

· Restart demo stellt die erste Anweisung und null Bestätigungen wieder her

· Längerer Text bleibt durch Scrollen erreichbar

· Der Inhalt wird auch dann angezeigt, wenn keine räumliche Benutzeroberfläche verfügbar ist

Ein erfolgreicher Emulatortest validiert einen Teil der Anwendungslogik und des Layouts. Er validiert weder die Optik von Aura noch die Zuverlässigkeit der Eingabe oder die Eignung für den Arbeitsplatz.

Schritt 7: Auf autorisierter Aura-Hardware bereitstellen

Die folgenden Schritte entsprechen dem Standardverfahren für das Debugging unter Android. Menüs und Verbindungsoptionen von Aura können je nach Softwareversion variieren; folgen Sie daher der kitspezifischen Anleitung, wo diese abweicht.

Aura verbinden und die App ausführen

· Starten Sie Aura mit angeschlossener Brille und öffnen Sie die Settings-App

· Aktivieren Sie auf Aura in den Einstellungen Developer options und das Debugging gemäß der Anleitung des Kits; besorgen Sie sich die Anleitung zur Entwicklereinrichtung, falls diese Optionen nicht verfügbar sind

· Verbinden Sie den Computer über ein USB-Datenkabel mit dem Charging Port (linke Seite) des Compute-Pucks und lassen Sie die Brille am Glasses Port (rechte Seite) angeschlossen. Falls das nicht funktioniert, schließen Sie das Kabel für vollständige ADB-Unterstützung am rechten Anschluss an.

· Bestätigen Sie die Debugging-Autorisierungsanfrage des Geräts; bei einem verwalteten Gerät kann eine Freigabe durch den Administrator erforderlich sein

· Wählen Sie in der oberen Symbolleiste von Android Studio im Geräte-Dropdown Aura aus und klicken Sie auf Run

· Wiederholen Sie auf Aura die Prüfungen des Aufgaben-Panels aus Schritt 6, einschließlich des Weiterschaltens von Aufgaben und des Neustarts der Checkliste

Fehlerbehebung bei der Geräteverbindung

Wird Aura in der Zielauswahl von Android Studio nicht angezeigt, prüfen Sie die Verbindung mit ADB:

  1. Öffnen Sie in Android Studio View > Tool Windows > Terminal.
  1. Führen Sie den folgenden Befehl aus:
adb devices -l

Prüfen Sie die Ausgabe:

· Wird Ihr Gerät mit device aufgeführt, ist es verbunden und autorisiert.

· Wird unauthorized angezeigt, setzen Sie die Brille auf und bestätigen Sie die USB-Debugging-Anfrage auf dem Display.

· Ist die Liste leer, prüfen Sie das USB-Datenkabel erneut, stellen Sie sicher, dass der Computing-Puck eingeschaltet ist, und vergewissern Sie sich, dass USB-Debugging in den Einstellungen weiterhin aktiviert ist.

Fazit

Die Entwicklung einer ersten Business-App für XREAL Aura beginnt mit Android Studio, Kotlin und dem Jetpack XR SDK und führt dann von einem einfachen Panel für Arbeitsanweisungen über Emulatortests bis zur Bereitstellung auf autorisierter Hardware. Dieser Ansatz bietet Unternehmen eine gezielte Möglichkeit zu prüfen, ob räumliche Anweisungen einen realen Arbeitsablauf verbessern, bevor sie in Integrationen und einen flottenweiten Rollout investieren. Sobald das Panel auf Aura lesbar, bedienbar und validiert ist, besteht der nächste Schritt darin, freigegebene Verfahren und zuverlässige Arbeitsprotokolle mit den Systemen des Unternehmens zu verbinden.

Sprechen Sie mit VR Expert über die Verfügbarkeit von Aura sowie über die Anforderungen an Hardware, Softwareentwicklung und Support für Ihr Pilotprojekt im Unternehmen.

João Noronha

Geschrieben von

João Noronha

XR- und Immersive-Content-Spezialist bei VR Expert

João Noronha ist XR- und Immersive-Content-Spezialist bei VR Expert und interessiert sich besonders für neue Technologien und deren praktische Anwendungen. Er konzentriert sich darauf, komplexe Entwicklungen in den Bereichen VR, AR, KI-Brillen und immersive Technologie in klare, praxisnahe Inhalte für Unternehmen und Fachleute zu übersetzen, die sich mit der XR-Branche befassen.

Häufig gestellte Fragen

Dieser Artikel

Ja. Beginnen Sie mit dem Android-XR-Glasses-Emulator, um die Benutzeroberfläche und den Aufgabenablauf zu entwickeln. Vor einem Pilotprojekt am Arbeitsplatz bleiben Tests auf physischer Aura-Hardware jedoch notwendig.

Nein. Android Studio, Kotlin und Jetpack Compose for XR eignen sich für dieses auf die Benutzeroberfläche ausgerichtete Beispiel. Unity ist eine eigenständige Entwicklungs-Engine, die sich für Projekte mit umfangreichen interaktiven 3D-Inhalten eignen kann.

Nein. Es stellt XR-Funktionen bereit. Ihr Team muss weiterhin die Anforderungen an Sicherheit, Datenspeicherung, Identität, Verteilung, Support und Integration umsetzen und validieren.

Nein. Sie zeigt lokal gespeicherten Text an und erfasst Bestätigungen im UI-Zustand. Geräteerkennung, Szenenverständnis und verifizierte Arbeitsprotokolle erfordern zusätzliche Konzeption und Implementierung.

Dieses Beispiel implementiert keinen dauerhaften physischen Anker. Ein Anker ist ein räumlicher Bezugspunkt, mit dem Inhalte relativ zu einem Ort positioniert werden; eine maschinenspezifische Platzierung erfordert einen zusätzlichen, unterstützten Verankerungs-Workflow und eine Validierung auf dem Gerät.