Crearea primei aplicații de business pentru XREAL Aura cu Android Studio

Crearea primei aplicații de business pentru XREAL Aura cu Android Studio

Rezumat

Acest ghid arată cum să creați o aplicație de business pentru XREAL Aura în Android Studio, folosind Kotlin și Jetpack XR SDK. Veți crea un proiect, veți adăuga biblioteca pentru interfața spațială, veți insera un mic exemplu de panou de sarcini și îl veți rula în emulatorul XR Glasses înainte de a-l testa pe hardware-ul Aura.

Exemplul afișează instrucțiuni de lucru și le permite utilizatorilor să confirme fiecare sarcină. Este un punct de plecare pentru o aplicație de business, fără înregistrări permanente ale activității și fără verificarea faptului că o sarcină fizică a fost efectuată. Codul urmează documentația analizată, dar nu a fost compilat sau testat pe hardware-ul Aura.

Introducere

Crearea unei aplicații de business pentru XREAL Aura începe în Android Studio, unde scrieți cod Kotlin și folosiți Jetpack XR SDK pentru a adăuga o interfață spațială. Acest ghid vă conduce de la crearea unui proiect până la rularea lui într-un emulator și testarea pe Aura. Ca exemplu simplu, veți construi un panou care afișează instrucțiuni de lucru și permite utilizatorului să confirme fiecare sarcină.

XREAL Aura combină ochelari conectați prin cablu cu o unitate de calcul Android XR de tip puck. Urmați fluxul de lucru Android XR pentru ochelari XR cu cablu, nu fluxul separat destinat ochelarilor audio și cu afișaj care proiectează conținut de pe telefon. Pentru context privind hardware-ul, consultați prezentarea XREAL Aura de la VRX și pagina oficială Aura a XREAL. [1]

Înainte de a începe

· Folosiți un computer aprobat de companie, cu acces la internet pentru descărcările inițiale

· Verificați cerințele de sistem ale emulatorului XR publicate de Google, care acoperă în prezent configurațiile Windows și macOS acceptate [2]

· Pentru testarea fizică, procurați ochelarii Aura, unitatea lor de calcul (puck) și instrucțiunile de conectare pentru dezvoltatori incluse în kit

Disponibilitate: Confirmați disponibilitatea regională cu VR Expert. Pagina actuală a XREAL acordă prioritate SUA, Canadei, Japoniei și Coreei de Sud; listele de rezervare mai vechi nu trebuie considerate drept livrare confirmată în Europa. [1]

Pasul 1 Instalați Android Studio și instrumentele SDK

Începeți prin a instala Android Studio și instrumentele SDK folosite pentru a construi aplicația, a rula un dispozitiv XR simulat și a vă conecta la hardware.

Google recomandă Android Studio Canary pentru XR. Canary este o ediție preview, cu instrumente mai noi și funcții posibil nefinalizate; o puteți instala alături de versiunea Android Studio existentă.

· Deschideți Android Studio Preview, descărcați programul de instalare potrivit și parcurgeți expertul de instalare.

· Pe ecranul de întâmpinare Android Studio, selectați More Actions > SDK Manager. Dacă un proiect este deja deschis, folosiți Tools > SDK Manager din meniul de sus.

· În fereastra de setări SDK Manager, găsiți filele SDK Platforms și SDK Tools, deasupra listei de pachete instalabile. Ambele file fac parte din aceeași fereastră SDK Manager.

· Selectați SDK Tools. Bifați Android SDK Build-Tools, Android Emulator și Android SDK Platform-Tools. Lăsați-le selectate dacă sunt deja instalate; aplicați actualizările disponibile. Build-Tools pregătește fișierul de instalare al aplicației, Emulator rulează dispozitive simulate, iar Platform-Tools include ADB, instrumentul de conectare la dispozitive.

· Faceți clic pe Apply, verificați descărcările selectate, acceptați licențele necesare și așteptați finalizarea instalării. Faceți clic pe OK pentru a închide fereastra.

Fila SDK Platforms instalează platforma Android folosită pentru compilarea aplicației. Versiunea necesară este dată de configurația proiectului. Creați proiectul în Pasul 2, apoi folosiți setarea compileSdk a acestuia pentru a selecta platforma corespunzătoare. Pasul 6 tratează imaginea de sistem a emulatorului XR, care furnizează sistemul de operare pentru dispozitivul simulat.

Punct de control: Cele trei instrumente SDK sunt instalate. Acum puteți crea proiectul. [3, 13]

Pasul 2 Creați proiectul aplicației de business pentru XREAL Aura

Șablonul de proiect XR creează fișierele de pornire ale aplicației și configurația de build. Urmați instrucțiunile Google pentru proiecte Android XR corespunzătoare versiunii de Studio instalate. [4]

· În Android Studio > reveniți la ecranul de întâmpinare și faceți clic pe New Project sau alegeți File > New > New Project.

· Selectați XR în lista de șabloane, apoi șablonul pentru căști XR și ochelari XR cu cablu. Pagina de proiect a Google nu mai numește șabloanele (indică alegerea șablonului care corespunde tipului de dispozitiv XR pentru care doriți să dezvoltați), iar denumirile se pot schimba între versiunile Canary, așa că preluați numele exact din IDE pentru captura de ecran. Nu alegeți șablonul pentru ochelari audio sau cu afișaj, care creează o experiență proiectată de pe telefon.

· Faceți clic pe Next. Introduceți AuraTaskPanel în câmpul Name. În Package name, introduceți com.example.aurataskpanel pentru acest tutorial. Selectați Kotlin dacă apare o opțiune de limbaj. Numele de pachet, package name, identifică codul aplicației și poate fi personalizat pentru organizația dumneavoastră. Se introduce în Android Studio ca identificator separat prin puncte, fără https:// sau o cale de adresă web.

Apoi păstrați setările de build ale șablonului generat și faceți clic pe Finish. Așteptați finalizarea primei sincronizări Gradle. Sincronizarea face ca Android Studio să citească configurația de build și să rezolve dependențele acesteia.

Deschideți View > Tool Windows > Project, apoi selectați Android în selectorul de vizualizare al panoului. Veți folosi aceste fișiere:

· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Conține punctul de intrare și interfața aplicației; în unele versiuni, folderul sursă se numește java

· AndroidManifest.xml: app > manifests. Declară punctul de intrare, permisiunile și setările de lansare ale aplicației

· build.gradle.kts (Module :app): Gradle Scripts. Configurează build-ul și bibliotecile aplicației

Instalați platforma solicitată de proiect

Setarea compileSdk îi indică lui Android Studio ce set de API-uri Android să folosească la construirea aplicației. Instalați platforma SDK corespunzătoare; nu alegeți una doar pe baza mărcii ochelarilor.

· În panoul Project din Android Studio, deschideți Gradle Scripts > build.gradle.kts (Module :app). În blocul android, găsiți compileSdk. O valoare precum compileSdk = 36 înseamnă că proiectul are nevoie de Android API 36. Acest număr este un exemplu, nu o valoare obligatorie pentru orice proiect Aura.

· Dacă valoarea face trimitere la o intrare din catalog, de exemplu libs.versions.compileSdk, deschideți Gradle Scripts > libs.versions.toml și citiți valoarea referită. Dacă șablonul folosește un nume de versiune preview sau o configurație compileSdk imbricată, păstrați acea setare și folosiți platforma corespunzătoare.

· Deschideți Tools > SDK Manager > SDK Platforms. Selectați rândul al cărui API Level corespunde setării proiectului. Faceți clic pe Apply, finalizați descărcarea, apoi faceți clic pe OK.

· Reveniți la proiect și selectați File > Sync Project with Gradle Files sau Sync Now dacă un banner vă oferă această opțiune. Sincronizarea Gradle citește setările de build și descarcă bibliotecile necesare proiectului.

Păstrați setarea de platformă a șablonului. Dacă Android Studio raportează o platformă lipsă, instalați platforma respectivă în loc să micșorați compileSdk pentru a evita descărcarea. Imaginea dispozitivului XR folosită pentru testare se selectează separat, în Pasul 6. [13]

Punct de control: Platforma SDK necesară este instalată, iar fereastra Build sau Sync nu conține erori nerezolvate.

Pasul 3 Adăugați biblioteca XR și verificați compatibilitatea Kotlin

Adăugați Jetpack Compose for XR pentru a oferi aplicației componente de panou spațial și verificați compatibilitatea Kotlin, astfel încât proiectul să poată construi biblioteca fără erori de versiune. Acest exemplu folosește XR Compose 1.0.0-beta02 (21-10-2026, încă cea mai recentă versiune), care necesită Kotlin 2.2, conform notelor de lansare Google. Aceleași note precizează că beta02 depinde de SceneCore 1.0.0-rc01, care are o scurgere de memorie cunoscută, așa că adăugați implementation („androidx.xr.scenecore:1.0.0”) sau o versiune mai nouă la linia Compose din Pasul 3.

Verificați o singură dată versiunea Kotlin

· În Android Studio, extindeți Gradle Scripts, apoi deschideți libs.versions.toml. Acest fișier, atunci când există, este lista centrală a versiunilor de biblioteci și pluginuri ale proiectului.

· Sub [versions], căutați intrarea Kotlin, de obicei kotlin = "2.2.0" sau o altă versiune 2.2.x. Păstrați versiunea compatibilă furnizată de șablonul actual.

· Dacă proiectul folosește pluginul org.jetbrains.kotlin.plugin.compose, versiunea acestuia trebuie să corespundă celei Kotlin. De regulă, șabloanele fac ca ambele să trimită la aceeași intrare de versiune Kotlin; păstrați această legătură.

· Dacă nu există o intrare Kotlin sau un catalog, inspectați fișierul build.gradle.kts de nivel superior pentru a găsi pluginuri Kotlin declarate explicit. Unele configurații de build mai noi gestionează Kotlin prin instrumentele de build Android. În acest caz, păstrați configurația generată și verificați compatibilitatea Kotlin a toolchain-ului dacă apare o eroare de build; nu adăugați un al doilea plugin Kotlin doar pentru a crea o intrare de versiune.

Dacă șablonul oferă deja instrumente Kotlin compatibile, nu modificați nimic. Dacă un build raportează că versiunea Kotlin este prea veche pentru biblioteca XR, actualizați împreună instrumentele Kotlin ale proiectului și eventualul plugin de compilator Compose corespunzător, folosind configurația acceptată pentru acel șablon. Evitați modificarea setărilor de build fără legătură cu aceasta.

Adăugați dependența pentru interfața spațială

· Deschideți Gradle Scripts > build.gradle.kts (Module :app).

· Găsiți blocul existent dependencies { ... }.

· Căutați o dependență XR Compose, scrisă direct sau printr-un alias precum implementation(libs.androidx.xr.compose). Dacă există deja un alias, setați versiunea XR Compose la care face referire la 1.0.0-beta02 în libs.versions.toml. Nu adăugați aceeași bibliotecă de două ori.

· Dacă XR Compose lipsește, adăugați această linie în blocul dependencies existent:

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

Păstrați celelalte dependențe ale șablonului. În special, codul de mai jos folosește Material 3 obișnuit, biblioteca ce furnizează butoanele, textul și tema acestuia, și Activity Compose, care găzduiește conținut Compose într-o Activity Android.

Sincronizați și continuați

Faceți clic pe Sync Now în bannerul editorului sau pe File > Sync Project with Gradle Files. Așteptați încheierea procesului de descărcare și configurare.

Punct de control: Sincronizarea se finalizează fără erori de dependență sau de compatibilitate Kotlin. Păstrați restul setărilor de build generate când sincronizarea reușește, apoi deschideți MainActivity.kt pentru a adăuga interfața. Dacă sincronizarea raportează o eroare de dependență, comparați componenta indicată cu pagina de configurare Jetpack XR SDK a Google. [6]

Pasul 4 Construiți panoul de sarcini în Kotlin

Interfața afișează textul sarcinii, împreună cu un buton Mark complete și un buton Restart demo. Instrucțiunile de exemplu pot fi înlocuite ulterior cu o procedură de lucru aprobată.

Tot în Android Studio > MainActivity.kt, păstrați linia package dacă pachetul dumneavoastră diferă, apoi înlocuiți restul fișierului cu codul de mai jos. Eliminați din acest fișier vechile funcții de exemplu și funcțiile de previzualizare ale șablonului, astfel încât să existe o singură MainActivity. O Activity este un punct de intrare Android care găzduiește o interfață. Exemplul de mai jos include Activity și importurile acesteia.

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)
        	}
    	}
	}
}

Ce face codul

· steps conține textul instrucțiunilor

· completed numără confirmările și împiedică avansarea dincolo de ultima sarcină

· rememberSaveable păstrează această valoare mică la recrearea ecranului și la restaurarea stării acceptate de Android; nu este o stocare permanentă

· LocalSpatialCapabilities verifică dacă interfața spațială este disponibilă [7]

· Subspace creează o zonă pentru conținut spațial, iar SpatialPanel plasează interfața în interiorul acesteia [8]

· Ramura de rezervă afișează același conținut într-o fereastră normală atunci când interfața spațială nu este disponibilă

Unitatea dp scalează dimensiunile layoutului în funcție de densitatea ecranului; sp scalează textul și respectă preferințele privind dimensiunea fontului. Containerul de derulare păstrează accesibile instrucțiunile mai lungi. Considerați dimensiunea panoului un punct de plecare și verificați lizibilitatea pe Aura.

Punct de control: Android Studio recunoaște importurile și nu afișează erori de sintaxă Kotlin. Dacă biblioteca instalată necesită un opt-in pentru un API experimental, folosiți adnotarea exactă indicată de diagnosticul compilatorului și consultați referința API pentru versiunea respectivă.

Pasul 5 Verificați cum pornește aplicația în Android XR

Configurați modul de lansare astfel încât Android XR să poată deschide aplicația cu layoutul spațial folosit în acest exemplu.

Pe ochelarii Aura, Home Space și Full Space sunt deja integrate în Android XR și controlează modul în care apar aplicațiile care rulează. Emulatorul XR Glasses oferă aceste moduri pentru dezvoltare, deci nu este necesară o instalare separată.

În panoul Project din Android Studio > deschideți app > manifests > AndroidManifest.xml și inspectați intrarea MainActivity. Păstrați filtrul de intenții MAIN și LAUNCHER, setarea exported și tema generată. Pentru Full Space gestionat de Compose, proprietatea relevantă este prezentată mai jos. Dacă șablonul declară deja o proprietate de lansare la nivel de aplicație sau de Activity, editați valoarea existentă relevantă în loc să o duplicați. [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 înseamnă că Android gestionează scena spațială pentru Activity. Valoarea UNMANAGED este destinată aplicațiilor care randează prin OpenXR, o interfață XR multiplatformă; acest exemplu Compose nu o folosește. Consultați referința constantelor de manifest când comparați șabloane. [9]

În elementul application existent, păstrați sau adăugați și android:enableOnBackInvokedCallback="true", astfel încât panoul spațial să primească evenimentele de revenire (back), așa cum documentează ghidul Google pentru panouri; exemplul din ghid îl setează pe elementul activity, dar este valid și pe elementul application. Nu adăugați permisiuni pentru cameră, microfon sau înțelegerea scenei pentru această listă de verificare statică. Aceasta nu citește încăperea și nu identifică obiecte. [8]

Pasul 6 Creați un emulator de ochelari XR și rulați aplicația

Rulați aplicația pe un dispozitiv simulat de tip ochelari XR înainte de a conecta Aura. Un emulator simulează un dispozitiv pe computerul dumneavoastră; un AVD este configurația salvată a acestuia.

· În Android Studio > deschideți Tools > Device Manager. Faceți clic pe controlul de adăugare a dispozitivului și alegeți Create Virtual Device.

· La Form Factor, alegeți XR, apoi XR Glasses. Faceți clic pe Next.

· Selectați imaginea de sistem Preview API necesară pentru profilul XR Glasses și descărcați-o dacă vi se solicită. Alegeți arhitectura de imagine acceptată care corespunde computerului dumneavoastră. Finalizați configurarea.

· Porniți AVD-ul folosind butonul de redare. Așteptați încărcarea completă a mediului Android XR.

· În bara de instrumente de sus din Android Studio, selectați configurația de rulare a aplicației și dispozitivul XR Glasses care rulează. Faceți clic pe Run, triunghiul verde.

Emulatorul instalează și deschide aplicația. Folosiți controalele sale de intrare pentru a activa Mark complete. Dacă panoul rămâne în Home Space, verificați manifestul și comenzile Full Space ale mediului înainte de a modifica layoutul Kotlin. Consultați instrucțiunile oficiale pentru AVD.

Efectuați această verificare de acceptanță:

· Primul ecran afișează zero din trei sarcini confirmate și prima instrucțiune

· Fiecare activare a Mark complete avansează exact o instrucțiune

· A treia activare afișează Checklist complete și dezactivează Mark complete

· Restart demo readuce prima instrucțiune și zero confirmări

· Textul mai lung rămâne accesibil prin derulare

· Conținutul apare în continuare atunci când interfața spațială nu este disponibilă

Un test reușit în emulator validează o parte din logica și layoutul aplicației. Nu validează optica Aura, fiabilitatea metodelor de input sau adecvarea pentru locul de muncă.

Pasul 7 Implementați aplicația pe hardware Aura autorizat

Pașii de mai jos urmează procesul standard de depanare Android. Meniurile și opțiunile de conectare ale Aura pot varia în funcție de versiunea software, așa că urmați instrucțiunile specifice kitului acolo unde diferă.

Conectați Aura și rulați aplicația

· Porniți Aura cu ochelarii conectați și deschideți aplicația Settings a acesteia

· Pe Aura > în interfața de setări > activați Developer options și depanarea conform instrucțiunilor kitului; procurați ghidul de configurare pentru dezvoltatori dacă aceste comenzi nu sunt disponibile

· Conectați computerul la Charging Port (partea stângă) al unității de calcul cu un cablu USB de date și lăsați ochelarii conectați la Glasses Port (partea dreaptă); dacă nu funcționează, conectați cablul la portul din partea dreaptă pentru suport ADB complet.

· Acceptați solicitarea de autorizare a depanării de pe dispozitiv; un dispozitiv gestionat poate necesita aprobarea administratorului

· În bara de instrumente de sus din Android Studio, selectați Aura în lista derulantă de dispozitive și faceți clic pe Run

· Pe Aura, repetați verificările panoului de sarcini din Pasul 6, inclusiv avansarea sarcinilor și repornirea listei de verificare

Depanarea conexiunii cu dispozitivul

Dacă Aura nu apare în selectorul de dispozitive țintă din Android Studio, verificați conexiunea folosind ADB:

  1. Deschideți View > Tool Windows > Terminal în Android Studio.
  1. Rulați următoarea comandă:
adb devices -l

Verificați rezultatul:

· Dacă dispozitivul apare cu starea device, este conectat și autorizat.

· Dacă apare unauthorized, puneți-vă ochelarii și acceptați solicitarea de depanare USB de pe ecran.

· Dacă lista este goală, verificați din nou cablul USB de date, asigurați-vă că unitatea de calcul este pornită și confirmați că depanarea USB este în continuare activată în Settings.

Concluzie

Crearea primei aplicații de business pentru XREAL Aura începe cu Android Studio, Kotlin și Jetpack XR SDK, apoi progresează de la un panou simplu de instrucțiuni de lucru la testarea în emulator și implementarea pe hardware autorizat. Această abordare oferă companiilor o modalitate concentrată de a evalua dacă instrucțiunile spațiale îmbunătățesc un flux de lucru real, înainte de a investi în integrări și în implementarea la nivelul întregii flote de dispozitive. Odată ce panoul este lizibil, utilizabil și validat pe Aura, următorul pas este conectarea procedurilor aprobate și a unor înregistrări fiabile ale activității la sistemele companiei.

Discutați cu VR Expert despre disponibilitatea Aura și despre cerințele de hardware, dezvoltare software și suport pentru proiectul-pilot al companiei dumneavoastră.

João Noronha

Scris de

João Noronha

Specialist XR și Conținut Imersiv la VR Expert

João Noronha este Specialist XR și Conținut Imersiv la VR Expert, cu un interes puternic pentru tehnologiile emergente și aplicațiile lor practice în lumea reală. Se concentrează pe transformarea evoluțiilor complexe din domeniul VR, AR, ochelarilor AI și al tehnologiei imersive în conținut clar și practic pentru companii și profesioniști care explorează industria XR.

Întrebări frecvente

Acest articol

Da. Începeți cu emulatorul Android XR Glasses pentru a dezvolta interfața și fluxul sarcinilor. Testarea pe hardware-ul Aura fizic rămâne necesară înainte de un proiect-pilot la locul de muncă.

Nu. Android Studio, Kotlin și Jetpack Compose for XR sunt potrivite pentru acest exemplu axat pe interfață. Unity este un motor de dezvoltare separat, care poate fi potrivit pentru proiecte cu mult conținut 3D interactiv.

Nu. Oferă capabilități XR. Echipa dumneavoastră trebuie în continuare să implementeze și să valideze cerințele de securitate, stocare a datelor, identitate, distribuție, suport și integrare.

Nu. Afișează text stocat local și înregistrează confirmările în starea interfeței (UI state). Recunoașterea echipamentelor, înțelegerea scenei și înregistrările verificate ale activității necesită proiectare și implementare suplimentare.

Acest exemplu nu implementează o ancoră fizică persistentă. O ancoră este o referință spațială folosită pentru a poziționa conținutul în raport cu o locație; plasarea specifică unei mașini necesită un flux de lucru suplimentar de ancorare acceptat și validare pe dispozitiv.