Samenvatting
Deze handleiding laat zien hoe u in Android Studio een zakelijke app voor XREAL Aura maakt met Kotlin en de Jetpack XR SDK. U maakt een project aan, voegt de bibliotheek voor de ruimtelijke interface toe, plakt een klein voorbeeld van een takenpaneel in en draait dit in de XR Glasses-emulator voordat u het op Aura-hardware test.
Het voorbeeld toont werkinstructies en laat gebruikers elke taak bevestigen. Het is een startpunt voor een zakelijke applicatie, zonder permanente werkregistratie en zonder controle of een fysieke taak daadwerkelijk is uitgevoerd. De code volgt de geraadpleegde documentatie, maar is niet gecompileerd of getest op Aura-hardware.
Inleiding
Een zakelijke app voor XREAL Aura bouwt u in Android Studio. Daar schrijft u Kotlin-code en gebruikt u de Jetpack XR SDK om een ruimtelijke interface toe te voegen. Deze handleiding begeleidt u van het aanmaken van een project tot het draaien in een emulator en het testen op Aura. Als eenvoudig voorbeeld bouwt u een paneel dat werkinstructies toont en waarmee een gebruiker elke taak kan bevestigen.
XREAL Aura combineert een bedrade bril met een Android XR-rekenunit (computing puck). Volg de Android XR-workflow voor bedrade XR-brillen, niet de aparte workflow voor audio- en displaybrillen met projectie vanaf de telefoon. Voor achtergrond over de hardware raadpleegt u het VRX-overzicht van XREAL Aura en de officiële Aura-pagina van XREAL. [1]
Voordat u begint
· Gebruik een door het bedrijf goedgekeurde computer met internettoegang voor de eerste downloads
· Controleer de systeemvereisten voor de XR-emulator van Google, die momenteel ondersteunde Windows- en macOS-configuraties beschrijven [2]
· Voor fysieke tests hebt u een Aura-bril nodig, de bijbehorende compute puck en de instructies van de kit voor de ontwikkelaarsverbinding
Beschikbaarheid: Controleer de regionale levering bij VR Expert. De huidige pagina van XREAL richt zich vooral op de VS, Canada, Japan en Zuid-Korea; oudere reserveringslijsten zijn geen bevestiging van levering in Europa. [1]
Stap 1 Installeer Android Studio en de SDK-tools
Installeer eerst Android Studio en de SDK-tools waarmee u de app bouwt, een gesimuleerd XR-apparaat draait en verbinding maakt met hardware.
Google raadt Android Studio Canary aan voor XR. Canary is een preview-editie met nieuwere tools en mogelijk onvoltooide functies; u kunt deze naast uw bestaande Android Studio installeren.
· Open Android Studio Preview, download het juiste installatieprogramma en doorloop de installatiewizard.
· Kies in het welkomstscherm van Android Studio More Actions > SDK Manager. Is er al een project geopend, gebruik dan Tools > SDK Manager in het hoofdmenu.
· In het instellingenvenster van de SDK Manager vindt u boven de lijst met installeerbare pakketten de tabbladen SDK Platforms en SDK Tools. Beide tabbladen maken deel uit van hetzelfde SDK Manager-venster.
· Selecteer SDK Tools. Vink Android SDK Build-Tools, Android Emulator en Android SDK Platform-Tools aan. Laat ze geselecteerd als ze al zijn geïnstalleerd en voer beschikbare updates uit. Build-Tools maakt het installatiebestand van de app, Emulator draait gesimuleerde apparaten en Platform-Tools bevat ADB, de tool om verbinding te maken met apparaten.
· Klik op Apply, controleer de geselecteerde downloads, accepteer de vereiste licenties en wacht tot de installatie klaar is. Klik op OK om het venster te sluiten.
Het tabblad SDK Platforms installeert het Android-platform waarmee de app wordt gecompileerd. De vereiste versie volgt uit de projectconfiguratie. Maak in stap 2 het project aan en kies vervolgens het platform dat overeenkomt met de compileSdk-instelling. Stap 6 behandelt de system image van de XR-emulator, die het besturingssysteem voor het gesimuleerde apparaat levert.
Controlepunt: De drie SDK-tools zijn geïnstalleerd. U kunt nu het project aanmaken. [3, 13]
Stap 2 Maak het project voor de zakelijke XREAL Aura-app aan
Het XR-projecttemplate maakt de startbestanden en de buildconfiguratie van de app aan. Volg de Android XR-projectinstructies van Google voor uw geïnstalleerde versie van Studio. [4]
· Ga in Android Studio terug naar het welkomstscherm en klik op New Project, of kies File > New > New Project.
· Selecteer XR in de lijst met templates en vervolgens het template voor XR-headsets en bedrade XR-brillen. De projectpagina van Google noemt geen templatenamen meer (er staat dat u het template kiest dat past bij het type XR-apparaat waarvoor u wilt bouwen) en namen kunnen per Canary-release veranderen. Neem de exacte naam voor de screenshot daarom over uit de IDE. Kies niet het template voor audio- of displaybrillen, dat een ervaring met projectie vanaf de telefoon aanmaakt.
· Klik op Next. Vul AuraTaskPanel in bij Name. Vul bij Package name voor deze tutorial com.example.aurataskpanel in. Selecteer Kotlin als er een taalkeuze verschijnt. De package name identificeert de code van de app; u kunt deze aanpassen voor uw organisatie. U voert deze in Android Studio in als een door punten gescheiden identifier, zonder https:// of webadrespad.
Behoud daarna de buildinstellingen van het gegenereerde template en klik op Finish. Wacht tot de eerste Gradle-sync is voltooid. Bij een sync leest Android Studio de buildconfiguratie in en lost het de dependencies op.
Open View > Tool Windows > Project en selecteer vervolgens Android in de weergavekiezer van het paneel. U gebruikt deze bestanden:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Dit bevat het startpunt en de interface van de app; in sommige versies heet de bronmap java
· AndroidManifest.xml: app > manifests. Dit declareert het startpunt, de machtigingen en de startinstellingen van de app
· build.gradle.kts (Module :app): Gradle Scripts. Dit configureert de build en de bibliotheken van de app
Installeer het platform dat uw project vraagt
De instelling compileSdk bepaalt welke Android API-set Android Studio gebruikt bij het bouwen van de app. Installeer het bijbehorende SDK-platform; kies er niet een alleen op basis van het merk van de bril.
· Open in het Project-paneel van Android Studio Gradle Scripts > build.gradle.kts (Module :app). Zoek in het android-blok naar compileSdk. Een waarde als compileSdk = 36 betekent dat het project Android API 36 nodig heeft. Dit getal is een voorbeeld, geen vereiste waarde voor elk Aura-project.
· Verwijst de waarde naar een catalogusitem, zoals libs.versions.compileSdk, open dan Gradle Scripts > libs.versions.toml en lees de waarde waarnaar wordt verwezen. Gebruikt het template een previewnaam of een geneste compileSdk-configuratie, behoud die instelling dan en gebruik het bijbehorende platform.
· Open Tools > SDK Manager > SDK Platforms. Selecteer de rij waarvan het API Level overeenkomt met de instelling van het project. Klik op Apply, rond de download af en klik daarna op OK.
· Ga terug naar het project en kies File > Sync Project with Gradle Files, of Sync Now als een banner dat aanbiedt. De Gradle-sync leest de buildinstellingen en downloadt de bibliotheken die het project nodig heeft.
Behoud de platforminstelling van het template. Meldt Android Studio een ontbrekend platform, installeer dat platform dan in plaats van compileSdk te verlagen om de download te vermijden. De XR-apparaatimage voor het testen selecteert u apart in stap 6. [13]
Controlepunt: Het vereiste SDK-platform is geïnstalleerd en het Build- of Sync-toolvenster bevat geen onopgeloste fouten.
Stap 3 Voeg de XR-bibliotheek toe en controleer de Kotlin-compatibiliteit
Voeg Jetpack Compose for XR toe om de app componenten voor ruimtelijke panelen te geven, en controleer de Kotlin-compatibiliteit zodat het project die bibliotheek zonder versiefouten kan bouwen. Dit voorbeeld gebruikt XR Compose 1.0.0-beta02 (21-10-2026, nog steeds de nieuwste release), waarvoor volgens de release notes van Google Kotlin 2.2 vereist is. Volgens dezelfde notes is beta02 afhankelijk van SceneCore 1.0.0-rc01, dat een bekend geheugenlek heeft. Voeg daarom implementation (“androidx.xr.scenecore:1.0.0”) of nieuwer toe aan de Compose-regel in stap 3.
Controleer eenmalig de Kotlin-versie
· Klap in Android Studio Gradle Scripts uit en open libs.versions.toml. Dit bestand is, als het aanwezig is, de centrale lijst van bibliotheek- en pluginversies van het project.
· Zoek onder [versions] naar het Kotlin-item, meestal kotlin = "2.2.0" of een andere 2.2.x-versie. Behoud de compatibele versie die het huidige template meelevert.
· Gebruikt het project de plugin org.jetbrains.kotlin.plugin.compose, dan moet de versie daarvan overeenkomen met Kotlin. Templates laten beide meestal naar hetzelfde Kotlin-versie-item verwijzen; laat die koppeling intact.
· Is er geen Kotlin-item of catalogus, controleer dan het top-level bestand build.gradle.kts op expliciet gedeclareerde Kotlin-plugins. Sommige nieuwere buildconfiguraties beheren Kotlin via de Android-buildtools. Behoud in dat geval de gegenereerde configuratie en controleer de Kotlin-compatibiliteit van de toolchain als er een buildfout optreedt; voeg geen tweede Kotlin-plugin toe alleen om een versie-item te maken.
Levert het template al compatibele Kotlin-tooling mee, verander dan niets. Meldt een build dat Kotlin te oud is voor de XR-bibliotheek, werk dan de Kotlin-tooling van het project en een eventuele bijbehorende Compose-compilerplugin samen bij, met de ondersteunde configuratie voor dat template. Pas geen ongerelateerde buildinstellingen aan.
Voeg de dependency voor de ruimtelijke interface toe
· Open Gradle Scripts > build.gradle.kts (Module :app).
· Zoek het bestaande blok dependencies { ... }.
· Zoek naar een XR Compose-dependency, direct geschreven of via een alias zoals implementation(libs.androidx.xr.compose). Bestaat er al een alias, zet de XR Compose-versie waarnaar die verwijst dan op 1.0.0-beta02 in libs.versions.toml. Voeg dezelfde bibliotheek niet twee keer toe.
· Ontbreekt XR Compose, voeg dan deze regel toe binnen het bestaande dependencies-blok:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Behoud de overige dependencies van het template. De onderstaande code gebruikt met name gewone Material 3, de bibliotheek die de knoppen, tekst en het thema levert, en Activity Compose, dat Compose-inhoud host in een Android Activity.
Synchroniseer en ga verder
Klik op Sync Now in de editorbanner, of kies File > Sync Project with Gradle Files. Wacht tot het downloaden en configureren is afgerond.
Controlepunt: De sync wordt voltooid zonder dependency- of Kotlin-compatibiliteitsfouten. Behoud de overige gegenereerde buildinstellingen als de sync slaagt en open daarna MainActivity.kt om de interface toe te voegen. Meldt de sync een dependency-fout, vergelijk het genoemde onderdeel dan met de Jetpack XR SDK-installatiepagina van Google. [6]
Stap 4 Bouw het takenpaneel in Kotlin
De interface toont de taaktekst met een knop Mark complete en een knop Restart demo. De voorbeeldinstructies kunt u later vervangen door een goedgekeurde werkprocedure.
Behoud in hetzelfde bestand MainActivity.kt in Android Studio de package-regel als uw package afwijkt, en vervang de rest van het bestand door de onderstaande code. Verwijder de oude voorbeeld- en previewfuncties van het template uit dit bestand, zodat er maar één MainActivity is. Een Activity is een Android-startpunt dat een interface host. Het onderstaande voorbeeld bevat de Activity en de bijbehorende 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)
}
}
}
}Wat de code doet
· steps bevat de instructietekst
· completed telt de bevestigingen en voorkomt dat u verder gaat dan de laatste taak
· rememberSaveable behoudt die kleine waarde wanneer Android het scherm opnieuw opbouwt en de status herstelt (voor zover ondersteund); het is geen permanente opslag
· LocalSpatialCapabilities controleert of een ruimtelijke UI beschikbaar is [7]
· Subspace maakt een gebied voor ruimtelijke inhoud aan, en SpatialPanel plaatst de interface daarin [8]
· De fallback-tak toont dezelfde inhoud in een normaal venster als ruimtelijke UI niet beschikbaar is
De eenheid dp schaalt lay-outafmetingen naar de schermdichtheid; sp schaalt tekst en houdt rekening met voorkeuren voor lettergrootte. Dankzij de scrollcontainer blijven langere instructies bereikbaar. Beschouw de paneelgrootte als uitgangspunt en controleer de leesbaarheid op Aura.
Controlepunt: Android Studio herkent de imports en toont geen Kotlin-syntaxfouten. Vereist uw geïnstalleerde bibliotheek een opt-in voor een experimentele API, gebruik dan exact de annotatie die de compilermelding noemt en raadpleeg de API-referentie van die release.
Stap 5 Controleer hoe de app start in Android XR
Configureer de startmodus zodat Android XR de app kan openen met de ruimtelijke lay-out uit dit voorbeeld.
Op de Aura-bril zijn Home Space en Full Space al ingebouwd in Android XR; ze bepalen hoe actieve apps worden weergegeven. De XR Glasses-emulator biedt deze modi voor ontwikkeling, dus een aparte installatie is niet nodig.
Open in het Project-paneel van Android Studio app > manifests > AndroidManifest.xml en bekijk het MainActivity-item. Behoud de intentfilter MAIN en LAUNCHER, de exported-instelling en het gegenereerde thema. Voor Full Space die door Compose wordt beheerd, ziet u hieronder de relevante property. Declareert het template al een startproperty op application- of Activity-niveau, pas dan de bestaande waarde aan in plaats van die te dupliceren. [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 betekent dat Android de ruimtelijke scène voor de Activity beheert. De waarde UNMANAGED is bedoeld voor apps die renderen via OpenXR, een platformonafhankelijke XR-interface; dit Compose-voorbeeld gebruikt die niet. Raadpleeg de referentie voor manifestconstanten wanneer u templates vergelijkt. [9]
Behoud of voeg in het bestaande application-element ook android:enableOnBackInvokedCallback="true" toe, zodat het ruimtelijke paneel back-events ontvangt, zoals de panelhandleiding van Google beschrijft. Het voorbeeld daarin zet dit op het activity-element, maar het is ook geldig op het application-element. Voeg voor deze statische checklist geen machtigingen voor camera, microfoon of scene understanding toe. De app leest de ruimte niet uit en herkent geen objecten. [8]
Stap 6 Maak een emulator voor XR-brillen aan en draai de app
Draai de app op een gesimuleerde XR-bril voordat u Aura aansluit. Een emulator simuleert een apparaat op uw computer; een AVD is de opgeslagen configuratie daarvan.
· Open in Android Studio Tools > Device Manager. Klik op de knop om een apparaat toe te voegen en kies Create Virtual Device.
· Kies onder Form Factor eerst XR en daarna XR Glasses. Klik op Next.
· Selecteer de Preview API-system image die vereist is voor het XR Glasses-profiel en download deze als daarom wordt gevraagd. Kies de ondersteunde image-architectuur die bij uw computer past. Rond de configuratie af.
· Start de AVD met de afspeelknop. Wacht tot de Android XR-omgeving volledig is geladen.
· Selecteer in de bovenste werkbalk van Android Studio de run-configuratie van de app en het actieve XR Glasses-apparaat. Klik op Run, de groene driehoek.
De emulator installeert en opent de app. Gebruik de invoerbediening van de emulator om Mark complete te activeren. Blijft het paneel in Home Space, controleer dan het manifest en de Full Space-bediening van de omgeving voordat u de Kotlin-lay-out aanpast. Zie de officiële AVD-instructies.
Voer deze acceptatiecontrole uit:
· Het eerste scherm toont nul van de drie bevestigde taken en de eerste instructie
· Elke activering van Mark complete gaat precies één instructie verder
· Na de derde activering verschijnt Checklist complete en is Mark complete uitgeschakeld
· Restart demo zet de eerste instructie en nul bevestigingen terug
· Langere tekst blijft bereikbaar door te scrollen
· De inhoud verschijnt nog steeds als ruimtelijke UI niet beschikbaar is
Een geslaagde emulatortest valideert een deel van de applicatielogica en de lay-out. De optiek van Aura, de betrouwbaarheid van de invoer en de geschiktheid voor de werkplek valideert deze test niet.
Stap 7 Installeer de app op geautoriseerde Aura-hardware
De onderstaande stappen volgen het standaard debugproces van Android. De menu's en verbindingsopties van Aura kunnen per softwareversie verschillen; volg dus de instructies van de kit waar die afwijken.
Sluit Aura aan en draai de app
· Start Aura met de bril aangesloten en open de Settings-app
· Schakel op Aura in de instellingeninterface Developer options en debugging in volgens de instructies van de kit; vraag de handleiding voor de ontwikkelaarsconfiguratie op als die opties niet beschikbaar zijn
· Sluit de computer met een USB-datakabel aan op de Charging Port (linkerkant) van de compute puck en laat de bril aangesloten op de Glasses Port (rechterkant). Werkt dat niet, sluit de kabel dan aan op de poort aan de rechterkant voor volledige ADB-ondersteuning.
· Accepteer op het apparaat de vraag om debugging te autoriseren; voor een beheerd apparaat kan goedkeuring van een beheerder nodig zijn
· Selecteer in de bovenste werkbalk van Android Studio Aura in de apparaatlijst en klik op Run
· Herhaal op Aura de controles van het takenpaneel uit stap 6, inclusief het doorlopen van taken en het herstarten van de checklist
Problemen met de apparaatverbinding oplossen
Verschijnt Aura niet in de apparaatkiezer van Android Studio, controleer de verbinding dan met ADB:
- Open View > Tool Windows > Terminal in Android Studio.
- Voer de volgende opdracht uit:
adb devices -lControleer de uitvoer:
· Staat uw apparaat in de lijst met device, dan is het verbonden en geautoriseerd.
· Staat er unauthorized, zet dan de bril op en accepteer de vraag voor USB-debugging op het scherm.
· Is de lijst leeg, controleer dan de USB-datakabel opnieuw, zorg dat de computing puck is ingeschakeld en controleer of USB-debugging nog is ingeschakeld in Settings.
Conclusie
Een eerste zakelijke app voor XREAL Aura bouwt u met Android Studio, Kotlin en de Jetpack XR SDK. U werkt van een eenvoudig paneel met werkinstructies naar tests in de emulator en installatie op geautoriseerde hardware. Zo kunnen bedrijven gericht beoordelen of ruimtelijke instructies een echt werkproces verbeteren, voordat ze investeren in integraties en een uitrol over hun hele apparatenvloot. Is het paneel leesbaar, bruikbaar en gevalideerd op Aura, dan is de volgende stap het koppelen van goedgekeurde procedures en betrouwbare werkregistraties aan de systemen van het bedrijf.
Neem contact op met VR Expert over de beschikbaarheid van Aura en de vereisten voor hardware, softwareontwikkeling en ondersteuning voor uw zakelijke pilot.

























