Resumé
Denne vejledning viser, hvordan du opretter en XREAL Aura-forretningsapp i Android Studio med Kotlin og Jetpack XR SDK. Du opretter et projekt, tilføjer biblioteket til den rumlige brugerflade, indsætter et lille eksempel på et opgavepanel og kører det i XR Glasses-emulatoren, før du tester på Aura-hardware.
Eksemplet viser arbejdsinstruktioner og lader brugerne kvittere for hver opgave. Det er et udgangspunkt for en forretningsapplikation, uden permanente arbejdsregistreringer eller verifikation af, at en fysisk opgave er udført. Koden følger den gennemgåede dokumentation, men er ikke blevet kompileret eller testet på Aura-hardware.
Introduktion
Udviklingen af en XREAL Aura-forretningsapp begynder i Android Studio, hvor du skriver Kotlin-kode og bruger Jetpack XR SDK til at tilføje en rumlig brugerflade. Denne vejledning fører dig fra oprettelsen af et projekt til at køre det i en emulator og teste det på Aura. Som et enkelt eksempel bygger du et panel, der viser arbejdsinstruktioner og lader en bruger kvittere for hver opgave.
XREAL Aura kombinerer kablede briller med en Android XR-computerpuck. Følg Android XR-arbejdsgangen for kablede XR-briller frem for den separate arbejdsgang for lyd- og skærmbriller, der projiceres fra en telefon. Se VRX' oversigt over XREAL Aura og XREALs officielle Aura-side for baggrund om hardwaren. [1]
Før du går i gang
· Brug en computer, som virksomheden har godkendt, med internetadgang til de første downloads
· Tjek Googles systemkrav til XR-emulatoren, som i øjeblikket dækker understøttede Windows- og macOS-konfigurationer [2]
· Til fysisk test skal du skaffe Aura-briller, den tilhørende computerpuck og kittets instruktioner til udviklerforbindelse
Tilgængelighed: Bekræft den regionale levering med VR Expert. XREALs nuværende side prioriterer USA, Canada, Japan og Sydkorea; ældre reservationslister bør ikke betragtes som bekræftet levering i Europa. [1]
Trin 1 Installer Android Studio og dets SDK-værktøjer
Start med at installere Android Studio og de SDK-værktøjer, der bruges til at bygge appen, køre en simuleret XR-enhed og oprette forbindelse til hardware.
Google anbefaler Android Studio Canary til XR. Canary er en preview-udgave med nyere værktøjer og muligvis ufærdige funktioner; du kan installere den side om side med din eksisterende Android Studio-installation.
· Åbn Android Studio Preview, download det relevante installationsprogram, og gennemfør installationsguiden.
· Vælg More Actions > SDK Manager på velkomstskærmen i Android Studio. Hvis et projekt allerede er åbent, skal du bruge Tools > SDK Manager i topmenuen.
· Find fanerne SDK Platforms og SDK Tools i SDK Manager-indstillingsvinduet over listen over pakker, der kan installeres. Begge faner er en del af det samme SDK Manager-vindue.
· Vælg SDK Tools. Sæt flueben ved Android SDK Build-Tools, Android Emulator og Android SDK Platform-Tools. Lad dem forblive valgt, hvis de allerede er installeret, og installer tilgængelige opdateringer. Build-Tools forbereder appens installationsfil, Emulator kører simulerede enheder, og Platform-Tools indeholder enhedsforbindelsesværktøjet ADB.
· Klik på Apply, gennemgå de valgte downloads, accepter de nødvendige licenser, og vent på installationen. Klik på OK for at lukke vinduet.
Fanen SDK Platforms installerer den Android-platform, der bruges til at kompilere appen. Den krævede version kommer fra projektkonfigurationen. Opret projektet i trin 2, og brug derefter dets compileSdk-indstilling til at vælge den tilsvarende platform. Trin 6 dækker XR-emulatorens systemimage, som leverer operativsystemet til den simulerede enhed.
Kontrolpunkt: De tre SDK-værktøjer er installeret. Du kan nu oprette projektet. [3, 13]
Trin 2 Opret projektet til XREAL Aura-forretningsappen
XR-projektskabelonen opretter appens startfiler og build-konfiguration. Følg Googles vejledning til Android XR-projekter for din installerede version af Studio. [4]
· I Android Studio > gå tilbage til velkomstskærmen, og klik på New Project, eller vælg File > New > New Project.
· Vælg XR på skabelonlisten og derefter skabelonen til XR-headsets og kablede XR-briller. Googles projektside nævner ikke længere skabelonerne ved navn (den siger, at man skal vælge den skabelon, der svarer til den type XR-enhed, man vil udvikle til), og navnene kan ændre sig mellem Canary-udgivelser, så tag det nøjagtige navn fra IDE'en til skærmbilledet. Vælg ikke skabelonen til lyd- eller skærmbriller, som opretter en oplevelse, der projiceres fra en telefon.
· Klik på Next. Indtast AuraTaskPanel i Name. I Package name skal du indtaste com.example.aurataskpanel i denne vejledning. Vælg Kotlin, hvis der vises et sprogvalg. Pakkenavnet identificerer appens kode og kan tilpasses din organisation. Det indtastes i Android Studio som en punktumsepareret identifikator uden https:// eller en webadressesti.
Behold derefter build-indstillingerne fra den genererede skabelon, og klik på Finish. Vent, til den første Gradle-synkronisering er fuldført. Synkroniseringen får Android Studio til at læse build-konfigurationen og løse dens afhængigheder.
Åbn View > Tool Windows > Project, og vælg derefter Android i panelets visningsvælger. Du skal bruge disse filer:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Den indeholder appens indgangspunkt og brugerflade; i nogle versioner hedder kildemappen java
· AndroidManifest.xml: app > manifests. Den erklærer appens indgangspunkt, tilladelser og startindstillinger
· build.gradle.kts (Module :app): Gradle Scripts. Den konfigurerer appens build og biblioteker
Installer den platform, dit projekt kræver
Indstillingen compileSdk fortæller Android Studio, hvilket sæt Android-API'er der skal bruges, når appen bygges. Installer den tilsvarende SDK-platform; vælg ikke en platform alene ud fra brillernes mærke.
· Åbn Gradle Scripts > build.gradle.kts (Module :app) i Project-panelet i Android Studio. Find compileSdk i android-blokken. En værdi som compileSdk = 36 betyder, at projektet kræver Android API 36. Dette tal er et eksempel, ikke en påkrævet værdi for alle Aura-projekter.
· Hvis værdien henviser til en katalogpost, f.eks. libs.versions.compileSdk, skal du åbne Gradle Scripts > libs.versions.toml og læse den refererede værdi. Hvis skabelonen bruger et preview-navn eller en indlejret compileSdk-konfiguration, skal du beholde den indstilling og bruge den tilsvarende platform.
· Åbn Tools > SDK Manager > SDK Platforms. Vælg den række, hvis API Level svarer til projektets indstilling. Klik på Apply, fuldfør downloadet, og klik derefter på OK.
· Gå tilbage til projektet, og vælg File > Sync Project with Gradle Files, eller Sync Now, hvis et banner tilbyder det. Gradle-synkroniseringen læser build-indstillingerne og downloader de biblioteker, projektet kræver.
Behold skabelonens platformindstilling. Hvis Android Studio melder om en manglende platform, skal du installere den platform i stedet for at sænke compileSdk for at undgå downloadet. XR-enhedsimaget, der bruges til test, vælges separat i trin 6. [13]
Kontrolpunkt: Den nødvendige SDK-platform er installeret, og værktøjsvinduet Build eller Sync indeholder ingen uløste fejl.
Trin 3 Tilføj XR-biblioteket, og kontrollér Kotlin-kompatibiliteten
Tilføj Jetpack Compose for XR for at give appen komponenter til rumlige paneler, og kontrollér Kotlin-kompatibiliteten, så projektet kan bygge biblioteket uden versionsfejl. Dette eksempel bruger XR Compose 1.0.0-beta02 (21-10-2026, stadig den nyeste udgivelse), som ifølge Googles udgivelsesnoter kræver Kotlin 2.2. De samme noter oplyser, at beta02 afhænger af SceneCore 1.0.0-rc01, som har en kendt hukommelseslækage, så tilføj implementation (“androidx.xr.scenecore:1.0.0”) eller nyere til Compose-linjen i trin 3.
Kontrollér Kotlin-versionen én gang
· Udvid Gradle Scripts i Android Studio, og klik derefter for at åbne libs.versions.toml. Denne fil er, når den findes, projektets centrale liste over biblioteks- og pluginversioner.
· Under [versions] skal du finde Kotlin-posten, typisk kotlin = "2.2.0" eller en anden 2.2.x-version. Behold den kompatible version, som den aktuelle skabelon leverer.
· Hvis projektet bruger pluginet org.jetbrains.kotlin.plugin.compose, skal dets version matche Kotlin. Skabeloner lader typisk begge henvise til den samme Kotlin-versionspost; bevar den kobling.
· Hvis der ikke er nogen Kotlin-post eller noget katalog, skal du undersøge build.gradle.kts på øverste niveau for eksplicit erklærede Kotlin-plugins. Nogle nyere build-konfigurationer styrer Kotlin via Androids build-værktøjer. I så fald skal du beholde den genererede konfiguration og kontrollere værktøjskædens Kotlin-kompatibilitet, hvis der opstår en build-fejl; tilføj ikke et ekstra Kotlin-plugin blot for at oprette en versionspost.
Hvis skabelonen allerede leverer kompatible Kotlin-værktøjer, skal du ikke ændre noget. Hvis et build melder, at Kotlin er for gammel til XR-biblioteket, skal du opdatere projektets Kotlin-værktøjer og et eventuelt tilhørende Compose-compilerplugin samtidig og bruge den understøttede konfiguration for den pågældende skabelon. Undgå at ændre build-indstillinger, der ikke har med dette at gøre.
Tilføj afhængigheden til den rumlige brugerflade
· Åbn Gradle Scripts > build.gradle.kts (Module :app).
· Find den eksisterende dependencies { ... }-blok.
· Se efter en XR Compose-afhængighed, enten skrevet direkte eller via et alias som implementation(libs.androidx.xr.compose). Hvis der allerede findes et alias, skal du sætte den refererede XR Compose-version til 1.0.0-beta02 i libs.versions.toml. Tilføj ikke det samme bibliotek to gange.
· Hvis XR Compose mangler, skal du tilføje denne linje i den eksisterende dependencies-blok:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Behold skabelonens øvrige afhængigheder. Koden nedenfor bruger især almindelig Material 3, biblioteket, der leverer dens knapper, tekst og tema, samt Activity Compose, som hoster Compose-indhold i en Android-Activity.
Synkroniser, og fortsæt
Klik på Sync Now i editorens banner, eller vælg File > Sync Project with Gradle Files. Vent, til download- og konfigurationsprocessen er færdig.
Kontrolpunkt: Synkroniseringen gennemføres uden fejl i afhængigheder eller Kotlin-kompatibilitet. Behold de øvrige genererede build-indstillinger, når synkroniseringen lykkes, og åbn derefter MainActivity.kt for at tilføje brugerfladen. Hvis synkroniseringen melder om en afhængighedsfejl, skal du sammenligne den nævnte komponent med Googles opsætningsside for Jetpack XR SDK. [6]
Trin 4 Byg opgavepanelet i Kotlin
Brugerfladen viser opgavetekst med knappen Mark complete og knappen Restart demo. Eksempelinstruktionerne kan senere erstattes med en godkendt arbejdsprocedure.
I den samme fil MainActivity.kt i Android Studio skal du beholde package-linjen, hvis din pakke er en anden, og derefter erstatte resten af filen med koden nedenfor. Fjern skabelonens gamle eksempelfunktioner og preview-funktioner fra filen, så der kun er én MainActivity. En Activity er et Android-indgangspunkt, der hoster en brugerflade. Eksemplet nedenfor indeholder Activity'en og dens 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)
}
}
}
}Hvad koden gør
· steps indeholder instruktionsteksten
· completed tæller kvitteringer og forhindrer, at man går videre end den sidste opgave
· rememberSaveable bevarer denne lille værdi ved understøttet genskabelse af Android-skærmbilleder og gendannelse af tilstand; det er ikke permanent lagring
· LocalSpatialCapabilities kontrollerer, om rumlig UI er tilgængelig [7]
· Subspace opretter et område til rumligt indhold, og SpatialPanel placerer brugerfladen inde i det [8]
· Fallback-grenen viser det samme indhold i et almindeligt vindue, når rumlig UI ikke er tilgængelig
Enheden dp skalerer layoutdimensioner efter skærmtæthed; sp skalerer tekst og respekterer præferencer for skriftstørrelse. Scroll-containeren sørger for, at længere instruktioner forbliver tilgængelige. Betragt panelstørrelsen som et udgangspunkt, og kontrollér læsbarheden på Aura.
Kontrolpunkt: Android Studio genkender importerne og viser ingen Kotlin-syntaksfejl. Hvis dit installerede bibliotek kræver et opt-in til en eksperimentel API, skal du bruge den nøjagtige annotation, som compilerens diagnosticering angiver, og tjekke API-referencen for den pågældende udgivelse.
Trin 5 Kontrollér, hvordan appen starter i Android XR
Konfigurer starttilstanden, så Android XR kan åbne appen med det rumlige layout, der bruges i dette eksempel.
På Aura-briller er Home Space og Full Space allerede indbygget i Android XR, og de styrer, hvordan kørende apps vises. XR Glasses-emulatoren stiller disse tilstande til rådighed under udviklingen, så der er ikke behov for en separat installation.
I Android Studios Project-panel > åbn app > manifests > AndroidManifest.xml, og gennemgå MainActivity-posten. Behold dens MAIN- og LAUNCHER-intentfilter, exported-indstillingen og det genererede tema. Til Compose-styret Full Space er den relevante egenskab vist nedenfor. Hvis skabelonen allerede erklærer en startegenskab på application- eller Activity-niveau, skal du redigere den relevante eksisterende værdi i stedet for at oprette en dublet. [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 betyder, at Android styrer den rumlige scene for Activity'en. Værdien UNMANAGED er beregnet til apps, der renderer via OpenXR, en platformsuafhængig XR-grænseflade; dette Compose-eksempel bruger den ikke. Tjek referencen over manifestkonstanter, når du sammenligner skabeloner. [9]
I det eksisterende application-element skal du også beholde eller tilføje android:enableOnBackInvokedCallback="true", så det rumlige panel modtager tilbage-hændelser, som det er dokumenteret i Googles panelvejledning; dens eksempel angiver attributten på activity-elementet, men den er også gyldig på application-elementet. Tilføj ikke tilladelser til kamera, mikrofon eller sceneforståelse til denne statiske tjekliste. Den aflæser ikke rummet og identificerer ikke objekter. [8]
Trin 6 Opret en emulator til XR-briller, og kør appen
Kør appen på en simuleret enhed med XR-briller, før du tilslutter Aura. En emulator simulerer en enhed på din computer; en AVD er dens gemte konfiguration.
· I Android Studio > åbn Tools > Device Manager. Klik på knappen til at tilføje en enhed, og vælg Create Virtual Device.
· Under Form Factor skal du vælge XR og derefter XR Glasses. Klik på Next.
· Vælg det Preview API-systemimage, som XR Glasses-profilen kræver, og download det, hvis du bliver bedt om det. Vælg en understøttet image-arkitektur, der passer til din computer. Afslut konfigurationen.
· Start AVD'en med dens afspilningsknap. Vent, til Android XR-miljøet er færdigt med at indlæse.
· Vælg appens kørselskonfiguration og den kørende XR Glasses-enhed på den øverste værktøjslinje i Android Studio. Klik på Run, den grønne trekant.
Emulatoren installerer og åbner appen. Brug dens inputkontroller til at aktivere Mark complete. Hvis panelet bliver i Home Space, skal du kontrollere manifestet og miljøets Full Space-kontroller, før du ændrer Kotlin-layoutet. Se den officielle AVD-vejledning.
Udfør denne accepttest:
· Det første skærmbillede viser nul ud af tre kvitterede opgaver og den første instruktion
· Hver aktivering af Mark complete går præcis én instruktion frem
· Den tredje aktivering viser Checklist complete og deaktiverer Mark complete
· Restart demo gendanner den første instruktion og nul kvitteringer
· Længere tekst kan stadig nås ved at scrolle
· Indholdet vises stadig, når rumlig UI ikke er tilgængelig
En vellykket emulatortest validerer en del af applikationens logik og layout. Den validerer ikke Auras optik, inputpålidelighed eller egnethed til arbejdspladsen.
Trin 7 Udrul til autoriseret Aura-hardware
Trinene nedenfor følger den almindelige debuggingproces for Android. Auras menuer og forbindelsesmuligheder kan variere afhængigt af softwareversionen, så følg de kitspecifikke instruktioner, hvor de afviger.
Tilslut Aura, og kør appen
· Start Aura med brillerne tilsluttet, og åbn dens Settings-app
· På Aura > i indstillingsgrænsefladen > aktivér Developer options og debugging ved hjælp af kittets instruktioner; skaf udviklervejledningen til opsætning, hvis disse indstillinger ikke er tilgængelige
· Forbind computeren til computerpuckens Charging Port (venstre side) med et USB-datakabel, og lad brillerne sidde i Glasses Port (højre side); hvis det ikke virker, så sæt kablet i porten i højre side for fuld ADB-understøttelse.
· Accepter enhedens anmodning om debugginggodkendelse; en administreret enhed kan kræve godkendelse fra en administrator
· Vælg Aura i enhedsrullemenuen på den øverste værktøjslinje i Android Studio, og klik på Run
· Gentag kontrollerne af opgavepanelet fra trin 6 på Aura, herunder at gå videre gennem opgaverne og genstarte tjeklisten
Fejlfinding af enhedsforbindelsen
Hvis Aura ikke vises i målvælgeren i Android Studio, skal du kontrollere forbindelsen med ADB:
- Åbn View > Tool Windows > Terminal i Android Studio.
- Kør følgende kommando:
adb devices -lKontrollér outputtet:
· Hvis din enhed vises med device, er den tilsluttet og godkendt.
· Hvis den viser unauthorized, skal du tage brillerne på og acceptere anmodningen om USB-debugging på skærmen.
· Hvis listen er tom, skal du kontrollere USB-datakablet igen, sikre dig, at computerpucken er tændt, og bekræfte, at USB-debugging stadig er aktiveret under Settings.
Konklusion
Udviklingen af en første XREAL Aura-forretningsapp begynder med Android Studio, Kotlin og Jetpack XR SDK og bevæger sig derefter fra et enkelt panel med arbejdsinstruktioner til emulatortest og udrulning på autoriseret hardware. Denne tilgang giver virksomheder en fokuseret måde at vurdere, om rumlige instruktioner forbedrer en reel arbejdsgang, før de investerer i integrationer og udrulning på hele enhedsflåden. Når panelet er læsbart, brugbart og valideret på Aura, er næste skridt at forbinde godkendte procedurer og pålidelige arbejdsregistreringer med virksomhedens systemer.
Tal med VR Expert om tilgængeligheden af Aura og om kravene til hardware, softwareudvikling og support i jeres pilotprojekt i virksomheden.

























