Je eerste zakelijke app voor XREAL Aura bouwen met Android Studio

Je eerste zakelijke app voor XREAL Aura bouwen met Android Studio

Samenvatting

Deze gids toont hoe je in Android Studio een zakelijke app voor XREAL Aura maakt met Kotlin en de Jetpack XR SDK. Je maakt een project aan, voegt de bibliotheek voor de ruimtelijke interface toe, plakt een klein voorbeeld van een takenpaneel in en voert dat uit in de XR Glasses-emulator, voordat je het op Aura-hardware test.

Het voorbeeld toont werkinstructies en laat gebruikers elke taak bevestigen. Het is een vertrekpunt voor een zakelijke toepassing, zonder permanente werkregistratie of verificatie dat een fysieke taak effectief werd uitgevoerd. De code volgt de geraadpleegde documentatie, maar werd niet gecompileerd of getest op Aura-hardware.

Inleiding

Een zakelijke app voor XREAL Aura bouwen begint in Android Studio, waar je Kotlin-code schrijft en de Jetpack XR SDK gebruikt om een ruimtelijke interface toe te voegen. Deze gids neemt je mee van het aanmaken van een project tot het uitvoeren ervan in een emulator en het testen op Aura. Als eenvoudig voorbeeld bouw je een paneel dat werkinstructies toont en een gebruiker elke taak laat bevestigen.

XREAL Aura combineert een bedrade bril met een Android XR-rekenpuck. Volg de Android XR-workflow voor bedrade XR-brillen, en niet de aparte workflow voor audio- en displaybrillen die via een telefoon worden geprojecteerd. Voor achtergrond over de hardware kun je terecht in het VRX-overzicht van XREAL Aura en op de officiële Aura-pagina van XREAL. [1]

Voor je 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 omvatten [2]

· Zorg voor fysieke tests voor een Aura-bril, de bijbehorende rekenpuck en de instructies van de kit om als ontwikkelaar verbinding te maken

Beschikbaarheid: Ga bij VR Expert na of levering in jouw regio mogelijk is. De huidige pagina van XREAL geeft voorrang aan de VS, Canada, Japan en Zuid-Korea; oudere reservatielijsten mogen niet worden beschouwd als bevestigde levering in Europa. [1]

Stap 1 Installeer Android Studio en de SDK-tools

Begin met het installeren van Android Studio en de SDK-tools waarmee je de app bouwt, een gesimuleerd XR-toestel uitvoert en verbinding maakt met hardware.

Google raadt Android Studio Canary aan voor XR. Canary is een previewversie met nieuwere tools en mogelijk onafgewerkte functies; je kunt ze naast je bestaande Android Studio installeren.

· Open Android Studio Preview, download het juiste installatieprogramma en doorloop de installatiewizard.

· Kies op het welkomstscherm van Android Studio More Actions > SDK Manager. Als er al een project open is, gebruik je Tools > SDK Manager in het bovenste menu.

· In het instellingenvenster van de SDK Manager vind je boven de lijst met installeerbare pakketten de tabbladen SDK Platforms en SDK Tools. Beide tabbladen maken deel uit van hetzelfde SDK Manager-venster.

· Kies SDK Tools. Vink Android SDK Build-Tools, Android Emulator en Android SDK Platform-Tools aan. Laat ze aangevinkt als ze al geïnstalleerd zijn en installeer beschikbare updates. Build-Tools maakt het installatiebestand van de app klaar, Emulator voert gesimuleerde toestellen uit en Platform-Tools bevat ADB, de tool om verbinding te maken met toestellen.

· Klik op Apply, controleer de geselecteerde downloads, aanvaard 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 het project aan in stap 2 en gebruik daarna de instelling compileSdk om het overeenkomstige platform te kiezen. Stap 6 behandelt de systeemimage van de XR-emulator, die het besturingssysteem levert voor het gesimuleerde toestel.

Controlepunt: De drie SDK-tools zijn geïnstalleerd. Je kunt nu het project aanmaken. [3, 13]

Stap 2 Maak het project aan voor de zakelijke app voor XREAL Aura

Het XR-projectsjabloon maakt de startbestanden en de buildconfiguratie van de app aan. Volg de Android XR-projectinstructies van Google voor de versie van Studio die je geïnstalleerd hebt. [4]

· Ga in Android Studio terug naar het welkomstscherm en klik op New Project, of kies File > New > New Project.

· Kies XR in de lijst met sjablonen en daarna het sjabloon voor XR-headsets en bedrade XR-brillen. De projectpagina van Google noemt de sjablonen niet langer bij naam (er staat dat je het sjabloon moet kiezen dat overeenkomt met het type XR-toestel waarvoor je wilt bouwen) en namen kunnen veranderen tussen Canary-releases, dus neem de exacte naam voor de screenshot over uit de IDE. Kies niet het sjabloon voor audio- of displaybrillen, dat een via de telefoon geprojecteerde ervaring aanmaakt.

· Klik op Next. Vul AuraTaskPanel in bij Name. Vul bij Package name voor deze tutorial com.example.aurataskpanel in. Kies Kotlin als er een taalkeuze verschijnt. De pakketnaam identificeert de code van de app en kan worden aangepast aan je organisatie. Je voert die in Android Studio in als een identificatie met punten als scheidingsteken, zonder https:// of een webadrespad.

Behoud daarna de buildinstellingen van het gegenereerde sjabloon en klik op Finish. Wacht tot de eerste Gradle-synchronisatie voltooid is. Bij de synchronisatie leest Android Studio de buildconfiguratie in en lost het de afhankelijkheden op.

Open View > Tool Windows > Project en kies daarna Android in de weergavekiezer van het deelvenster. Je 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 opstartinstellingen van de app

· build.gradle.kts (Module :app): Gradle Scripts. Dit configureert de build en de bibliotheken van de app

Installeer het platform dat je project vraagt

De instelling compileSdk vertelt Android Studio welke set Android-API's het moet gebruiken bij het bouwen van de app. Installeer het overeenkomstige SDK-platform; kies er geen louter op basis van het merk van de bril.

· Open in het Project-deelvenster van Android Studio Gradle Scripts > build.gradle.kts (Module :app). Zoek in het android-blok naar compileSdk. Een waarde zoals compileSdk = 36 betekent dat het project Android API 36 nodig heeft. Dit getal is een voorbeeld, geen vereiste waarde voor elk Aura-project.

· Als de waarde naar een catalogusitem verwijst, zoals libs.versions.compileSdk, open dan Gradle Scripts > libs.versions.toml en lees de waarde waarnaar verwezen wordt. Als het sjabloon een previewnaam of een geneste compileSdk-configuratie gebruikt, behoud die instelling dan en gebruik het overeenkomstige 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-synchronisatie leest de buildinstellingen en downloadt de bibliotheken die het project nodig heeft.

Behoud de platforminstelling van het sjabloon. Als Android Studio een ontbrekend platform meldt, installeer dat platform dan in plaats van compileSdk te verlagen om de download te vermijden. De XR-toestelimage voor het testen wordt apart gekozen in stap 6. [13]

Controlepunt: Het vereiste SDK-platform is geïnstalleerd en het toolvenster Build of Sync bevat geen onopgeloste fouten.

Stap 3 Voeg de XR-bibliotheek toe en controleer de compatibiliteit met Kotlin

Voeg Jetpack Compose for XR toe om de app ruimtelijke paneelcomponenten te geven, en controleer de compatibiliteit met Kotlin zodat het project die bibliotheek zonder versiefouten kan bouwen. Dit voorbeeld gebruikt XR Compose 1.0.0-beta02 (21-10-2026, nog altijd de nieuwste release), waarvoor volgens de releasenotes van Google Kotlin 2.2 vereist is. Volgens diezelfde releasenotes is beta02 afhankelijk van SceneCore 1.0.0-rc01, dat een bekend geheugenlek heeft; voeg dus 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 open en klik daarna op libs.versions.toml om het te openen. 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 sjabloon levert.

· Als het project de plugin org.jetbrains.kotlin.plugin.compose gebruikt, moet de versie ervan overeenkomen met Kotlin. Sjablonen laten beide meestal naar hetzelfde Kotlin-versie-item verwijzen; behoud die koppeling.

· Als er geen Kotlin-item of catalogus is, kijk dan in het build.gradle.kts op het hoogste niveau naar 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 louter om een versie-item aan te maken.

Als het sjabloon al compatibele Kotlin-tools levert, verander je niets. Als een build meldt dat Kotlin te oud is voor de XR-bibliotheek, werk dan de Kotlin-tools van het project en een eventuele bijbehorende Compose-compilerplugin samen bij, met de ondersteunde configuratie voor dat sjabloon. Wijzig geen buildinstellingen die er niets mee te maken hebben.

Voeg de afhankelijkheid voor de ruimtelijke interface toe

· Open Gradle Scripts > build.gradle.kts (Module :app).

· Zoek het bestaande blok dependencies { ... }.

· Zoek naar een XR Compose-afhankelijkheid, rechtstreeks geschreven of via een alias zoals implementation(libs.androidx.xr.compose). Als er al een alias bestaat, stel de XR Compose-versie waarnaar die verwijst dan in libs.versions.toml in op 1.0.0-beta02. Voeg dezelfde bibliotheek niet twee keer toe.

· Als XR Compose ontbreekt, voeg dan deze regel toe binnen het bestaande dependencies-blok:

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

Behoud de andere afhankelijkheden van het sjabloon. De code hieronder 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 banner van de editor, of kies File > Sync Project with Gradle Files. Wacht tot het download- en configuratieproces klaar is.

Controlepunt: De synchronisatie verloopt zonder afhankelijkheidsfouten of fouten rond Kotlin-compatibiliteit. Behoud de overige gegenereerde buildinstellingen als de synchronisatie slaagt en open dan MainActivity.kt om de interface toe te voegen. Meldt de synchronisatie een afhankelijkheidsfout, vergelijk dan de genoemde component met de installatiepagina van de Jetpack XR SDK 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 kunnen later worden vervangen door een goedgekeurde werkprocedure.

Behoud in hetzelfde bestand MainActivity.kt in Android Studio de package-regel als je pakket verschilt, en vervang de rest van het bestand door de onderstaande code. Verwijder de oude voorbeeldfuncties en previewfuncties van het sjabloon uit dit bestand, zodat er maar één MainActivity is. Een Activity is een Android-startpunt dat een interface host. Het voorbeeld hieronder 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 je verder gaat dan de laatste taak

· rememberSaveable bewaart die kleine waarde bij het ondersteunde heropbouwen van het Android-scherm en bij het herstellen van de status; het is geen permanente opslag

· LocalSpatialCapabilities controleert of ruimtelijke UI beschikbaar is [7]

· Subspace maakt een zone voor ruimtelijke inhoud aan, en SpatialPanel plaatst de interface daarin [8]

· De fallback-tak toont dezelfde inhoud in een gewoon venster als ruimtelijke UI niet beschikbaar is

De eenheid dp schaalt lay-outafmetingen volgens de schermdichtheid; sp schaalt tekst en respecteert voorkeuren voor de lettergrootte. Dankzij de scrollcontainer blijven langere instructies bereikbaar. Beschouw de paneelgrootte als vertrekpunt en controleer de leesbaarheid op Aura.

Controlepunt: Android Studio herkent de imports en toont geen syntaxfouten in Kotlin. Als je geïnstalleerde bibliotheek een opt-in voor een experimentele API vereist, gebruik dan exact de annotatie die de compilerdiagnose noemt en raadpleeg de API-referentie van die release.

Stap 5 Controleer hoe de app opstart in Android XR

Configureer de opstartmodus 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 en bepalen ze hoe actieve apps verschijnen. De XR Glasses-emulator biedt deze modi aan voor ontwikkeling, dus een aparte installatie is niet nodig.

Open in het Project-deelvenster van Android Studio app > manifests > AndroidManifest.xml en bekijk het item MainActivity. Behoud de intentfilter MAIN en LAUNCHER, de instelling exported en het gegenereerde thema. Voor door Compose beheerde Full Space zie je hieronder de relevante property. Als het sjabloon al een opstartproperty declareert op het niveau van de application of de Activity, pas dan de relevante bestaande waarde aan in plaats van ze te dupliceren. [9]

<!-- Binnen het bestaande 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 van de manifestconstanten wanneer je sjablonen vergelijkt. [9]

Behoud in het bestaande application-element ook android:enableOnBackInvokedCallback="true" of voeg het toe, zodat het ruimtelijke paneel back-events ontvangt, zoals beschreven in de paneelgids van Google; het voorbeeld daar stelt het in op het activity-element, maar het is ook geldig op het application-element. Voeg voor deze statische checklist geen machtigingen voor camera, microfoon of scènebegrip toe. De app leest de ruimte niet en identificeert geen objecten. [8]

Stap 6 Maak een emulator voor een XR-bril aan en voer de app uit

Voer de app uit op een gesimuleerde XR-bril voordat je Aura aansluit. Een emulator simuleert een toestel op je computer; een AVD is de opgeslagen configuratie ervan.

· Open in Android Studio Tools > Device Manager. Klik op de knop om een toestel toe te voegen en kies Create Virtual Device.

· Kies onder Form Factor XR en daarna XR Glasses. Klik op Next.

· Selecteer de Preview API-systeemimage die vereist is voor het XR Glasses-profiel en download die als daarom gevraagd wordt. Kies de ondersteunde image-architectuur die bij je computer past. Rond de configuratie af.

· Start de AVD met de afspeelknop. Wacht tot de Android XR-omgeving volledig geladen is.

· Kies in de bovenste werkbalk van Android Studio de runconfiguratie van de app en het actieve XR Glasses-toestel. Klik op Run, de groene driehoek.

De emulator installeert en opent de app. Gebruik de invoerbedieningen van de emulator om Mark complete te activeren. Blijft het paneel in Home Space, controleer dan het manifest en de Full Space-bedieningen van de omgeving voordat je de Kotlin-lay-out wijzigt. Zie de officiële AVD-instructies.

Voer deze acceptatiecontrole uit:

· Het eerste scherm toont nul van de drie taken bevestigd en de eerste instructie

· Elke activering van Mark complete gaat precies één instructie verder

· De derde activering toont Checklist complete en schakelt Mark complete uit

· Restart demo zet de eerste instructie en nul bevestigingen terug

· Langere tekst blijft bereikbaar door te scrollen

· De inhoud verschijnt nog altijd als ruimtelijke UI niet beschikbaar is

Een geslaagde test in de emulator valideert een deel van de applicatielogica en de lay-out. Hij valideert niet de optiek van Aura, de betrouwbaarheid van de invoer of de geschiktheid voor de werkplek.

Stap 7 Implementeer op geautoriseerde Aura-hardware

De onderstaande stappen volgen het standaardproces voor debuggen op Android. De menu's en verbindingsopties van Aura kunnen verschillen per softwareversie, dus volg de kitspecifieke instructies waar die afwijken.

Verbind Aura en voer de app uit

· 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 installatiegids voor ontwikkelaars op als die opties niet beschikbaar zijn

· Verbind de computer met een USB-datakabel met de Charging Port (linkerkant) van de rekenpuck 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.

· Aanvaard de vraag om debugging te autoriseren op het toestel; voor een beheerd toestel kan goedkeuring van een beheerder nodig zijn

· Kies in de bovenste werkbalk van Android Studio Aura in de toestelkeuzelijst 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 toestelverbinding oplossen

Als Aura niet verschijnt in de doelkiezer van Android Studio, controleer de verbinding dan met ADB:

  1. Open View > Tool Windows > Terminal in Android Studio.
  1. Voer de volgende opdracht uit:
adb devices -l

Controleer de uitvoer:

· Als je toestel vermeld staat met device, is het verbonden en geautoriseerd.

· Als het unauthorized toont, zet dan de bril op en aanvaard de vraag voor USB-debugging op het scherm.

· Als de lijst leeg is, controleer dan opnieuw de USB-datakabel, zorg dat de rekenpuck aanstaat en ga na of USB-debugging nog altijd ingeschakeld is in Settings.

Conclusie

Een eerste zakelijke app voor XREAL Aura bouwen begint met Android Studio, Kotlin en de Jetpack XR SDK, en gaat daarna van een eenvoudig paneel met werkinstructies naar tests in de emulator en implementatie op geautoriseerde hardware. Met deze aanpak kunnen bedrijven gericht nagaan of ruimtelijke instructies een echte workflow verbeteren, voordat ze investeren in integraties en een uitrol over hun hele toestellenpark. Zodra het paneel leesbaar, bruikbaar en gevalideerd is op Aura, is de volgende stap om goedgekeurde procedures en betrouwbare werkregistraties te koppelen aan de systemen van het bedrijf.

Praat met VR Expert over de beschikbaarheid van Aura en over de vereisten op het vlak van hardware, softwareontwikkeling en ondersteuning voor je bedrijfspilot.

João Noronha

Geschreven door

João Noronha

XR- en Immersive Content Specialist bij VR Expert

João Noronha is XR- en Immersive Content Specialist bij VR Expert, met een sterke interesse in opkomende technologieën en hun praktische toepassingen. Hij richt zich op het vertalen van complexe ontwikkelingen op het gebied van VR, AR, AI-brillen en immersieve technologie naar heldere, praktische content voor bedrijven en professionals die de XR-sector verkennen.

Veelgestelde vragen

Dit artikel

Ja. Begin met de Android XR Glasses-emulator om de interface en de takenflow te ontwikkelen. Fysieke tests op Aura blijven nodig vóór een pilot op de werkvloer.

Nee. Android Studio, Kotlin en Jetpack Compose for XR zijn geschikt voor dit voorbeeld, dat op de interface gericht is. Unity is een aparte ontwikkelengine die geschikt kan zijn voor projecten met uitgebreide interactieve 3D-inhoud.

Nee. De SDK biedt XR-functionaliteit. Je team moet nog altijd de vereisten rond beveiliging, gegevensopslag, identiteit, distributie, ondersteuning en integratie implementeren en valideren.

Nee. Ze toont lokaal opgeslagen tekst en registreert bevestigingen in de UI-status. Herkenning van apparatuur, scènebegrip en geverifieerde werkregistraties vereisen bijkomend ontwerp- en implementatiewerk.

Dit voorbeeld implementeert geen persistent fysiek anker. Een anker is een ruimtelijk referentiepunt om inhoud te positioneren ten opzichte van een locatie; plaatsing bij een specifieke machine vereist een bijkomende, ondersteunde workflow voor verankering en validatie op het toestel.