Sammendrag
Denne veiledningen viser hvordan du lager en XREAL Aura-bedriftsapp i Android Studio med Kotlin og Jetpack XR SDK. Du oppretter et prosjekt, legger til biblioteket for romlige grensesnitt, limer inn et lite eksempel på et oppgavepanel og kjører det i XR Glasses-emulatoren før du tester på Aura-maskinvare.
Eksempelet viser arbeidsinstruksjoner og lar brukerne kvittere for hver oppgave. Det er et utgangspunkt for en bedriftsapplikasjon, uten permanente arbeidslogger eller verifisering av at en fysisk oppgave faktisk er utført. Koden følger den gjennomgåtte dokumentasjonen, men er ikke kompilert eller testet på Aura-maskinvare.
Innledning
Å bygge en XREAL Aura-bedriftsapp starter i Android Studio, der du skriver Kotlin-kode og bruker Jetpack XR SDK til å legge til et romlig grensesnitt. Denne veiledningen tar deg fra opprettelse av et prosjekt til kjøring i en emulator og testing på Aura. Som et enkelt eksempel bygger du et panel som viser arbeidsinstruksjoner og lar en bruker kvittere for hver oppgave.
XREAL Aura kombinerer kablede briller med en Android XR-databoks (compute puck). Følg Android XR-arbeidsflyten for kablede XR-briller, ikke den separate arbeidsflyten for lyd- og skjermbriller som projiseres fra telefonen. For bakgrunn om maskinvaren, se VRX' oversikt over XREAL Aura og XREALs offisielle Aura-side. [1]
Før du starter
· Bruk en datamaskin som er godkjent av bedriften, med internettilgang for de første nedlastingene
· Sjekk Googles systemkrav for XR-emulatoren, som for øyeblikket dekker støttede Windows- og macOS-konfigurasjoner [2]
· For fysisk testing trenger du Aura-briller, tilhørende compute puck og settets instruksjoner for utviklertilkobling
Tilgjengelighet: Bekreft regional tilgjengelighet med VR Expert. XREALs nåværende side prioriterer USA, Canada, Japan og Sør-Korea; eldre reservasjonslister bør ikke tolkes som bekreftet levering i Europa. [1]
Trinn 1 Installer Android Studio og SDK-verktøyene
Start med å installere Android Studio og SDK-verktøyene som brukes til å bygge appen, kjøre en simulert XR-enhet og koble til maskinvare.
Google anbefaler Android Studio Canary for XR. Canary er en forhåndsversjon med nyere verktøy og potensielt uferdige funksjoner; du kan installere den ved siden av din eksisterende Android Studio.
· Åpne Android Studio Preview, last ned riktig installasjonsprogram og fullfør installasjonsveiviseren.
· På velkomstskjermen i Android Studio velger du More Actions > SDK Manager. Hvis et prosjekt allerede er åpent, bruker du Tools > SDK Manager i toppmenyen.
· I innstillingsvinduet SDK Manager finner du fanene SDK Platforms og SDK Tools, over listen over pakker som kan installeres. Begge fanene er en del av det samme SDK Manager-vinduet.
· Velg SDK Tools. Huk av for Android SDK Build-Tools, Android Emulator og Android SDK Platform-Tools. La dem være valgt hvis de allerede er installert, og installer tilgjengelige oppdateringer. Build-Tools klargjør appens installasjonsfil, Emulator kjører simulerte enheter, og Platform-Tools inneholder enhetstilkoblingsverktøyet ADB.
· Klikk Apply, gå gjennom de valgte nedlastingene, godta de nødvendige lisensene og vent til installasjonen er ferdig. Klikk OK for å lukke vinduet.
Fanen SDK Platforms installerer Android-plattformen som brukes til å kompilere appen. Hvilken versjon som kreves, bestemmes av prosjektkonfigurasjonen. Opprett prosjektet i trinn 2, og bruk deretter compileSdk-innstillingen til å velge tilsvarende plattform. Trinn 6 tar for seg systembildet til XR-emulatoren, som leverer operativsystemet til den simulerte enheten.
Sjekkpunkt: De tre SDK-verktøyene er installert. Nå kan du opprette prosjektet. [3, 13]
Trinn 2 Opprett prosjektet for XREAL Aura-bedriftsappen
XR-prosjektmalen oppretter appens startfiler og byggekonfigurasjon. Følg Googles instruksjoner for Android XR-prosjekter for Studio-versjonen du har installert. [4]
· I Android Studio går du tilbake til velkomstskjermen og klikker New Project, eller velger File > New > New Project.
· Velg XR i mallisten, og deretter malen for XR-headset og kablede XR-briller. Googles prosjektside navngir ikke lenger malene (den sier at du skal velge malen som tilsvarer typen XR-enhet du vil utvikle for), og navnene kan endre seg mellom Canary-utgivelser, så hent det nøyaktige navnet fra IDE-en til skjermbildet. Ikke velg malen for lyd- eller skjermbriller, som lager en opplevelse projisert fra telefonen.
· Klikk Next. Skriv inn AuraTaskPanel i Name. I Package name skriver du inn com.example.aurataskpanel for denne veiledningen. Velg Kotlin hvis det dukker opp et valg av språk. Pakkenavnet identifiserer appens kode og kan tilpasses organisasjonen din. Det skrives inn i Android Studio som en punktumseparert identifikator, uten https:// eller en sti fra en nettadresse.
Behold deretter byggeinnstillingene fra den genererte malen og klikk Finish. Vent til den første Gradle-synkroniseringen er fullført. Synkroniseringen får Android Studio til å lese byggekonfigurasjonen og løse avhengighetene.
Åpne View > Tool Windows > Project, og velg deretter Android i visningsvelgeren i panelet. Du skal bruke disse filene:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Denne inneholder appens inngangspunkt og grensesnitt; i enkelte versjoner heter kildemappen java
· AndroidManifest.xml: app > manifests. Denne deklarerer appens inngangspunkt, tillatelser og oppstartsinnstillinger
· build.gradle.kts (Module :app): Gradle Scripts. Denne konfigurerer appens bygg og biblioteker
Installer plattformen prosjektet ber om
Innstillingen compileSdk forteller Android Studio hvilket sett med Android-API-er som skal brukes når appen bygges. Installer den tilsvarende SDK-plattformen; ikke velg en ut fra brillemerket alene.
· I Project-panelet i Android Studio åpner du Gradle Scripts > build.gradle.kts (Module :app). I android-blokken finner du compileSdk. En verdi som compileSdk = 36 betyr at prosjektet trenger Android API 36. Dette tallet er et eksempel, ikke en påkrevd verdi for alle Aura-prosjekter.
· Hvis verdien peker til en katalogoppføring, for eksempel libs.versions.compileSdk, åpner du Gradle Scripts > libs.versions.toml og leser den refererte verdien. Hvis malen bruker et forhåndsversjonsnavn eller en nestet compileSdk-konfigurasjon, beholder du den innstillingen og bruker tilsvarende plattform.
· Åpne Tools > SDK Manager > SDK Platforms. Velg raden der API Level samsvarer med prosjektets innstilling. Klikk Apply, fullfør nedlastingen og klikk deretter OK.
· Gå tilbake til prosjektet og velg File > Sync Project with Gradle Files, eller Sync Now hvis et banner tilbyr det. Gradle-synkroniseringen leser byggeinnstillingene og laster ned bibliotekene prosjektet trenger.
Behold plattforminnstillingen fra malen. Hvis Android Studio melder om en manglende plattform, installerer du den plattformen i stedet for å senke compileSdk for å slippe nedlastingen. XR-enhetsbildet som brukes til testing, velges separat i trinn 6. [13]
Sjekkpunkt: Den nødvendige SDK-plattformen er installert, og verktøyvinduet Build eller Sync inneholder ingen uløste feil.
Trinn 3 Legg til XR-biblioteket og sjekk Kotlin-kompatibiliteten
Legg til Jetpack Compose for XR for å gi appen komponenter for romlige paneler, og sjekk Kotlin-kompatibiliteten slik at prosjektet kan bygge biblioteket uten versjonsfeil. Dette eksempelet bruker XR Compose 1.0.0-beta02 (21-10-2026, fortsatt den nyeste utgivelsen), som krever Kotlin 2.2 ifølge Googles utgivelsesnotater. De samme notatene sier at beta02 er avhengig av SceneCore 1.0.0-rc01, som har en kjent minnelekkasje, så legg til implementation (“androidx.xr.scenecore:1.0.0”) eller nyere ved Compose-linjen i trinn 3.
Sjekk Kotlin-versjonen én gang
· Utvid Gradle Scripts i Android Studio, og klikk deretter for å åpne libs.versions.toml. Når denne filen finnes, er den prosjektets sentrale liste over biblioteks- og plugin-versjoner.
· Under [versions] ser du etter Kotlin-oppføringen, vanligvis kotlin = "2.2.0" eller en annen 2.2.x-versjon. Behold den kompatible versjonen som følger med den gjeldende malen.
· Hvis prosjektet bruker pluginen org.jetbrains.kotlin.plugin.compose, må versjonen samsvare med Kotlin. Maler lar vanligvis begge referere til den samme Kotlin-versjonsoppføringen; bevar den koblingen.
· Hvis det ikke finnes noen Kotlin-oppføring eller katalog, sjekker du toppnivåfilen build.gradle.kts for eksplisitt deklarerte Kotlin-plugins. Enkelte nyere byggekonfigurasjoner håndterer Kotlin via Androids byggeverktøy. I så fall beholder du den genererte konfigurasjonen og sjekker verktøykjedens Kotlin-kompatibilitet hvis det oppstår en byggefeil; ikke legg til en ekstra Kotlin-plugin bare for å få en versjonsoppføring.
Hvis malen allerede har kompatible Kotlin-verktøy, endrer du ingenting. Hvis et bygg melder at Kotlin er for gammel for XR-biblioteket, oppdaterer du prosjektets Kotlin-verktøy og eventuell tilhørende Compose-kompilatorplugin samtidig, med den støttede konfigurasjonen for den aktuelle malen. Unngå å endre byggeinnstillinger som ikke har med dette å gjøre.
Legg til avhengigheten for romlig grensesnitt
· Åpne Gradle Scripts > build.gradle.kts (Module :app).
· Finn den eksisterende blokken dependencies { ... }.
· Se etter en XR Compose-avhengighet, enten skrevet direkte eller via et alias som implementation(libs.androidx.xr.compose). Hvis det allerede finnes et alias, setter du den refererte XR Compose-versjonen til 1.0.0-beta02 i libs.versions.toml. Ikke legg til det samme biblioteket to ganger.
· Hvis XR Compose mangler, legger du til denne linjen i den eksisterende dependencies-blokken:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Behold malens øvrige avhengigheter. Koden nedenfor bruker blant annet vanlig Material 3, biblioteket som leverer knappene, teksten og temaet, og Activity Compose, som er vert for Compose-innhold i en Android-Activity.
Synkroniser og fortsett
Klikk Sync Now i banneret i editoren, eller File > Sync Project with Gradle Files. Vent til nedlastingen og konfigurasjonen er ferdig.
Sjekkpunkt: Synkroniseringen fullføres uten feil knyttet til avhengigheter eller Kotlin-kompatibilitet. Behold de øvrige genererte byggeinnstillingene når synkroniseringen lykkes, og åpne deretter MainActivity.kt for å legge til grensesnittet. Hvis synkroniseringen melder om en avhengighetsfeil, sammenligner du den navngitte komponenten med Googles oppsettside for Jetpack XR SDK. [6]
Trinn 4 Bygg oppgavepanelet i Kotlin
Grensesnittet viser oppgavetekst med en Mark complete-knapp og en Restart demo-knapp. Eksempelinstruksjonene kan senere erstattes med en godkjent arbeidsprosedyre.
I den samme MainActivity.kt i Android Studio beholder du package-linjen hvis pakken din er en annen, og erstatter resten av filen med koden nedenfor. Fjern malens gamle eksempelfunksjoner og forhåndsvisningsfunksjoner fra denne filen, slik at det bare finnes én MainActivity. En Activity er et inngangspunkt i Android som er vert for et grensesnitt. Eksempelet nedenfor inneholder Activity-en og tilhørende importer.
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)
}
}
}
}Hva koden gjør
· steps inneholder instruksjonsteksten
· completed teller kvitteringer og hindrer at man går videre forbi den siste oppgaven
· rememberSaveable beholder denne lille verdien når Android gjenoppretter skjermen og tilstanden på støttede måter; det er ikke permanent lagring
· LocalSpatialCapabilities sjekker om romlig UI er tilgjengelig [7]
· Subspace oppretter et område for romlig innhold, og SpatialPanel plasserer grensesnittet i det [8]
· Reservegrenen viser det samme innholdet i et vanlig vindu når romlig UI ikke er tilgjengelig
Enheten dp skalerer layoutmål etter skjermtetthet; sp skalerer tekst og tar hensyn til innstillinger for skriftstørrelse. Rullebeholderen sørger for at lengre instruksjoner forblir tilgjengelige. Betrakt panelstørrelsen som et utgangspunkt, og sjekk lesbarheten på Aura.
Sjekkpunkt: Android Studio gjenkjenner importene og viser ingen syntaksfeil i Kotlin. Hvis biblioteksversjonen du har installert, krever opt-in for et eksperimentelt API, bruker du nøyaktig den annotasjonen som kompilatordiagnostikken oppgir, og sjekker API-referansen for den aktuelle utgivelsen.
Trinn 5 Sjekk hvordan appen starter i Android XR
Konfigurer oppstartsmodusen slik at Android XR kan åpne appen med den romlige layouten som brukes i dette eksempelet.
På Aura-brillene er Home Space og Full Space allerede innebygd i Android XR, og de styrer hvordan apper som kjører, vises. XR Glasses-emulatoren tilbyr disse modusene for utvikling, så det trengs ingen separat installasjon.
I Project-panelet i Android Studio åpner du app > manifests > AndroidManifest.xml og ser på MainActivity-oppføringen. Behold intent-filteret MAIN og LAUNCHER, exported-innstillingen og det genererte temaet. For Compose-styrt Full Space er den relevante egenskapen vist nedenfor. Hvis malen allerede deklarerer en oppstartsegenskap på applikasjons- eller Activity-nivå, redigerer du den eksisterende verdien i stedet for å duplisere den. [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 betyr at Android styrer den romlige scenen for Activity-en. Verdien UNMANAGED er ment for apper som rendrer via OpenXR, et plattformuavhengig XR-grensesnitt; dette Compose-eksempelet bruker den ikke. Sjekk referansen for manifestkonstanter når du sammenligner maler. [9]
I det eksisterende application-elementet beholder eller legger du også til android:enableOnBackInvokedCallback="true", slik at det romlige panelet mottar tilbake-hendelser, slik Googles panelveiledning dokumenterer; eksempelet der setter attributtet på activity-elementet, og det er også gyldig på application-elementet. Ikke legg til tillatelser for kamera, mikrofon eller sceneforståelse for denne statiske sjekklisten. Den leser ikke rommet og identifiserer ikke objekter. [8]
Trinn 6 Opprett en emulator for XR-briller og kjør appen
Kjør appen på en simulert XR-brilleenhet før du kobler til Aura. En emulator simulerer en enhet på datamaskinen din; en AVD er den lagrede konfigurasjonen for den.
· I Android Studio åpner du Tools > Device Manager. Klikk på kontrollen for å legge til en enhet, og velg Create Virtual Device.
· Under Form Factor velger du XR og deretter XR Glasses. Klikk Next.
· Velg systembildet med Preview API som kreves for XR Glasses-profilen, og last det ned hvis du blir bedt om det. Velg en støttet bildearkitektur som passer til datamaskinen din. Fullfør konfigurasjonen.
· Start AVD-en med avspillingsknappen. Vent til Android XR-miljøet er ferdig lastet.
· I den øverste verktøylinjen i Android Studio velger du kjørekonfigurasjonen for appen og XR Glasses-enheten som kjører. Klikk Run, den grønne trekanten.
Emulatoren installerer og åpner appen. Bruk inndatakontrollene til å aktivere Mark complete. Hvis panelet blir værende i Home Space, sjekker du manifestet og miljøets Full Space-kontroller før du endrer Kotlin-layouten. Se de offisielle AVD-instruksjonene.
Kjør denne akseptansetesten:
· Det første skjermbildet viser null av tre oppgaver kvittert og den første instruksjonen
· Hver aktivering av Mark complete går nøyaktig én instruksjon videre
· Den tredje aktiveringen viser Checklist complete og deaktiverer Mark complete
· Restart demo gjenoppretter den første instruksjonen og null kvitteringer
· Lengre tekst kan fortsatt nås ved å rulle
· Innholdet vises fortsatt når romlig UI ikke er tilgjengelig
En vellykket emulatortest validerer deler av applikasjonslogikken og layouten. Den validerer ikke Auras optikk, påliteligheten til inndata eller egnetheten på arbeidsplassen.
Trinn 7 Distribuer til autorisert Aura-maskinvare
Trinnene nedenfor følger den vanlige feilsøkingsprosessen for Android. Auras menyer og tilkoblingsalternativer kan variere med programvareversjonen, så følg de settspesifikke instruksjonene der de avviker.
Koble til Aura og kjør appen
· Start Aura med brillene tilkoblet og åpne Settings-appen
· På Aura går du til innstillingsgrensesnittet og aktiverer Developer options og feilsøking ved hjelp av settets instruksjoner; skaff veiledningen for utvikleroppsett hvis disse kontrollene ikke er tilgjengelige
· Koble datamaskinen til ladeporten (Charging Port, venstre side) på compute puck-en med en USB-datakabel, og la brillene være tilkoblet Glasses Port (høyre side). Hvis det ikke fungerer, kobler du den til porten på høyre side for full ADB-støtte.
· Godta forespørselen om feilsøkingsautorisasjon på enheten; en administrert enhet kan kreve godkjenning fra en administrator
· I den øverste verktøylinjen i Android Studio velger du Aura i enhetsmenyen og klikker Run
· På Aura gjentar du kontrollene av oppgavepanelet fra trinn 6, inkludert å gå videre gjennom oppgavene og starte sjekklisten på nytt
Feilsøk enhetstilkoblingen
Hvis Aura ikke vises i målvelgeren i Android Studio, kontrollerer du tilkoblingen med ADB:
- Åpne View > Tool Windows > Terminal i Android Studio.
- Kjør følgende kommando:
adb devices -lSjekk utdataene:
· Hvis enheten din står oppført med device, er den tilkoblet og autorisert.
· Hvis den viser unauthorized, tar du på deg brillene og godtar forespørselen om USB-feilsøking på skjermen.
· Hvis listen er tom, sjekker du USB-datakabelen på nytt, sørger for at compute puck-en er slått på, og bekrefter at USB-feilsøking fortsatt er aktivert i Settings.
Konklusjon
Å bygge en første XREAL Aura-bedriftsapp starter med Android Studio, Kotlin og Jetpack XR SDK, og går deretter videre fra et enkelt panel for arbeidsinstruksjoner til testing i emulator og distribusjon på autorisert maskinvare. Denne tilnærmingen gir bedrifter en målrettet måte å vurdere om romlige instruksjoner forbedrer en reell arbeidsflyt, før de investerer i integrasjoner og utrulling på hele enhetsparken. Når panelet er lesbart, brukbart og validert på Aura, er neste steg å koble godkjente prosedyrer og pålitelige arbeidslogger til bedriftens systemer.
Snakk med VR Expert om tilgjengeligheten av Aura og om kravene til maskinvare, programvareutvikling og support for pilotprosjektet i bedriften din.

























