Vezetői összefoglaló
Ez az útmutató bemutatja, hogyan hozhat létre XREAL Aura üzleti alkalmazást az Android Studióban Kotlin és a Jetpack XR SDK segítségével. Létrehoz egy projektet, hozzáadja a térbeli felület könyvtárát, beilleszt egy kis feladatpanel-példát, majd az XR Glasses emulátorban futtatja, mielőtt Aura hardveren tesztelné.
A példa munkautasításokat jelenít meg, és lehetővé teszi, hogy a felhasználók egyenként nyugtázzák a feladatokat. Egy üzleti alkalmazás kiindulópontja, tartós munkanyilvántartás nélkül, és nem ellenőrzi, hogy egy fizikai feladatot ténylegesen elvégeztek-e. A kód az áttekintett dokumentációt követi, de nem fordították le, és nem tesztelték Aura hardveren.
Bevezetés
Az XREAL Aura üzleti alkalmazás fejlesztése az Android Studióban kezdődik: itt írja meg a Kotlin kódot, és itt ad hozzá térbeli felületet a Jetpack XR SDK-val. Ez az útmutató a projekt létrehozásától az emulátoros futtatáson át az Aurán végzett tesztelésig vezeti végig a folyamaton. Egyszerű példaként egy olyan panelt készít, amely munkautasításokat jelenít meg, és lehetővé teszi, hogy a felhasználó egyenként nyugtázza a feladatokat.
Az XREAL Aura vezetékes szemüveget kombinál egy Android XR számítási egységgel (puck). A vezetékes XR-szemüvegekre vonatkozó Android XR munkafolyamatot kövesse, ne a telefonról kivetített audio- és kijelzős szemüvegekhez tartozó, külön munkafolyamatot. A hardveres háttérhez lásd a VRX XREAL Aura áttekintését és az XREAL hivatalos Aura-oldalát. [1]
Mielőtt elkezdené
· A kezdeti letöltésekhez használjon a vállalat által jóváhagyott, internet-hozzáféréssel rendelkező számítógépet
· Nézze meg a Google XR-emulátorra vonatkozó rendszerkövetelményeit, amelyek jelenleg a támogatott Windows- és macOS-konfigurációkra terjednek ki [2]
· A fizikai teszteléshez szerezze be az Aura szemüveget, a hozzá tartozó számítási egységet és a készlet fejlesztői csatlakoztatási útmutatóját
Elérhetőség: A regionális elérhetőséget egyeztesse a VR Experttel. Az XREAL jelenlegi oldala az Egyesült Államokat, Kanadát, Japánt és Dél-Koreát helyezi előtérbe; a korábbi előjegyzési listák nem tekinthetők megerősített európai szállításnak. [1]
1. lépés: Az Android Studio és SDK-eszközeinek telepítése
Először telepítse az Android Studiót és azokat az SDK-eszközöket, amelyekkel lefordítja az alkalmazást, szimulált XR-eszközt futtat, és a hardverhez csatlakozik.
XR-fejlesztéshez a Google az Android Studio Canary kiadását ajánlja. A Canary egy előzetes kiadás újabb eszközökkel és esetleg még befejezetlen funkciókkal; a meglévő Android Studio mellé is telepíthető.
· Nyissa meg az Android Studio Preview oldalt, töltse le a megfelelő telepítőt, és végezze el a telepítővarázsló lépéseit.
· Az Android Studio kezdőképernyőjén válassza a More Actions > SDK Manager lehetőséget. Ha már meg van nyitva egy projekt, használja a felső menüben a Tools > SDK Manager menüpontot.
· Az SDK Manager beállításablakában keresse meg az SDK Platforms és az SDK Tools lapot a telepíthető csomagok listája felett. Mindkét lap ugyanannak az SDK Manager ablaknak a része.
· Válassza az SDK Tools lapot. Jelölje be az Android SDK Build-Tools, az Android Emulator és az Android SDK Platform-Tools elemet. Ha már telepítve vannak, hagyja őket bejelölve; telepítse az elérhető frissítéseket. A Build-Tools elkészíti az alkalmazás telepítőfájlját, az Emulator szimulált eszközöket futtat, a Platform-Tools pedig tartalmazza az ADB nevű eszközcsatlakoztatási eszközt.
· Kattintson az Apply gombra, tekintse át a kiválasztott letöltéseket, fogadja el a szükséges licenceket, és várja meg a telepítést. Kattintson az OK gombra az ablak bezárásához.
Az SDK Platforms lap telepíti az alkalmazás fordításához használt Android-platformot. A szükséges verzió a projektkonfigurációból derül ki. Hozza létre a projektet a 2. lépésben, majd annak compileSdk beállítása alapján válassza ki a megfelelő platformot. A 6. lépés az XR-emulátor rendszerképével foglalkozik, amely a szimulált eszköz operációs rendszerét biztosítja.
Ellenőrzőpont: A három SDK-eszköz telepítve van. Most már létrehozhatja a projektet. [3, 13]
2. lépés: Az XREAL Aura üzleti alkalmazás projektjének létrehozása
Az XR-projektsablon létrehozza az alkalmazás kiinduló fájljait és buildkonfigurációját. Kövesse a Google Android XR-projektekre vonatkozó útmutatóját a telepített Studio-verziónak megfelelően. [4]
· Az Android Studióban térjen vissza a kezdőképernyőre, és kattintson a New Project gombra, vagy válassza a File > New > New Project menüpontot.
· A sablonlistában válassza az XR elemet, majd az XR-headsetekhez és vezetékes XR-szemüvegekhez készült sablont. A Google projektoldala már nem nevezi meg a sablonokat (csak azt írja, hogy azt a sablont kell választani, amely annak az XR-eszköztípusnak felel meg, amelyre fejleszteni szeretne), a nevek pedig Canary-kiadásonként változhatnak, ezért a képernyőképhez a pontos nevet az IDE-ből vegye át. Ne az audio- vagy kijelzős szemüvegekhez készült sablont válassza, amely telefonról kivetített élményt hoz létre.
· Kattintson a Next gombra. Írja be az AuraTaskPanel nevet a Name mezőbe. A Package name mezőbe ehhez az oktatóanyaghoz a következőt írja be: com.example.aurataskpanel. Ha megjelenik nyelvválasztás, válassza a Kotlin lehetőséget. A csomagnév azonosítja az alkalmazás kódját, és a szervezetéhez igazítható. Az Android Studióban pontokkal tagolt azonosítóként kell megadni, https:// előtag és webcímútvonal nélkül.
Ezután hagyja meg a generált sablon buildbeállításait, és kattintson a Finish gombra. Várja meg, amíg az első Gradle-szinkronizálás befejeződik. A szinkronizálás során az Android Studio beolvassa a buildkonfigurációt, és feloldja a függőségeit.
Nyissa meg a View > Tool Windows > Project ablakot, majd a panel nézetválasztójában válassza az Android nézetet. A következő fájlokat fogja használni:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Ez tartalmazza az alkalmazás belépési pontját és felületét; egyes verziókban a forrásmappa neve java
· AndroidManifest.xml: app > manifests. Ez deklarálja az alkalmazás belépési pontját, engedélyeit és indítási beállításait
· build.gradle.kts (Module :app): Gradle Scripts. Ez konfigurálja az alkalmazás buildjét és könyvtárait
A projekt által igényelt platform telepítése
A compileSdk beállítás határozza meg az Android Studio számára, hogy melyik Android API-készletet használja az alkalmazás fordításakor. Telepítse a megfelelő SDK-platformot; ne pusztán a szemüveg márkája alapján válasszon.
· Az Android Studio Project paneljén nyissa meg a következőt: Gradle Scripts > build.gradle.kts (Module :app). Az android blokkban keresse meg a compileSdk beállítást. Egy olyan érték, mint a compileSdk = 36, azt jelenti, hogy a projekthez Android API 36 szükséges. Ez a szám csak példa, nem minden Aura-projekthez kötelező érték.
· Ha az érték egy katalógusbejegyzésre hivatkozik, például a libs.versions.compileSdk bejegyzésre, nyissa meg a Gradle Scripts > libs.versions.toml fájlt, és olvassa ki a hivatkozott értéket. Ha a sablon előzetes (preview) nevet vagy beágyazott compileSdk-konfigurációt használ, tartsa meg ezt a beállítást, és a hozzá tartozó platformot használja.
· Nyissa meg a Tools > SDK Manager > SDK Platforms lapot. Jelölje ki azt a sort, amelynek API Level értéke megegyezik a projekt beállításával. Kattintson az Apply gombra, várja meg a letöltés végét, majd kattintson az OK gombra.
· Térjen vissza a projekthez, és válassza a File > Sync Project with Gradle Files menüpontot, vagy a Sync Now lehetőséget, ha egy értesítősáv felkínálja. A Gradle-szinkronizálás beolvassa a buildbeállításokat, és letölti a projekthez szükséges könyvtárakat.
Tartsa meg a sablon platformbeállítását. Ha az Android Studio hiányzó platformot jelez, telepítse azt a platformot, ahelyett hogy a letöltés elkerülése érdekében csökkentené a compileSdk értékét. A teszteléshez használt XR-eszközképet külön, a 6. lépésben kell kiválasztani. [13]
Ellenőrzőpont: A szükséges SDK-platform telepítve van, és a Build vagy Sync eszközablakban nincs megoldatlan hiba.
3. lépés: Az XR-könyvtár hozzáadása és a Kotlin-kompatibilitás ellenőrzése
Adja hozzá a Jetpack Compose for XR könyvtárat, hogy az alkalmazás térbeli panelkomponenseket kapjon, és ellenőrizze a Kotlin-kompatibilitást, hogy a projekt verzióhibák nélkül le tudja fordítani ezt a könyvtárat. Ez a példa az XR Compose 1.0.0-beta02 (21-10-2026, továbbra is a legújabb kiadás) verziót használja, amelyhez a Google kiadási megjegyzései szerint Kotlin 2.2 szükséges. Ugyanezek a megjegyzések szerint a beta02 a SceneCore 1.0.0-rc01 verziójától függ, amelyben ismert memóriaszivárgás van, ezért a 3. lépésben a Compose-sor mellé adja hozzá az implementation (“androidx.xr.scenecore:1.0.0”) vagy újabb függőséget.
A Kotlin-verzió egyszeri ellenőrzése
· Az Android Studióban bontsa ki a Gradle Scripts elemet, majd kattintással nyissa meg a libs.versions.toml fájlt. Ez a fájl – ha létezik – a projekt könyvtár- és bővítményverzióinak központi listája.
· A [versions] szakaszban keresse meg a Kotlin-bejegyzést, amely általában kotlin = "2.2.0" vagy egy másik 2.2.x verzió. Tartsa meg az aktuális sablon által megadott kompatibilis verziót.
· Ha a projekt az org.jetbrains.kotlin.plugin.compose bővítményt használja, annak verziója meg kell, hogy egyezzen a Kotlinéval. A sablonok általában mindkettőt ugyanarra a Kotlin-verzióbejegyzésre hivatkoztatják; ezt a kapcsolatot őrizze meg.
· Ha nincs Kotlin-bejegyzés vagy katalógus, keresse meg a legfelső szintű build.gradle.kts fájlban az explicit módon deklarált Kotlin-bővítményeket. Egyes újabb buildkonfigurációk az Android buildeszközein keresztül kezelik a Kotlint. Ebben az esetben tartsa meg a generált konfigurációt, és ha buildhiba jelentkezik, ellenőrizze az eszközlánc Kotlin-kompatibilitását; ne adjon hozzá egy második Kotlin-bővítményt csak azért, hogy verzióbejegyzést hozzon létre.
Ha a sablon már kompatibilis Kotlin-eszközöket biztosít, ne módosítson semmit. Ha egy build azt jelzi, hogy a Kotlin túl régi az XR-könyvtárhoz, frissítse együtt a projekt Kotlin-eszközeit és a hozzájuk tartozó Compose-fordítóbővítményt, az adott sablonhoz támogatott konfiguráció szerint. Ne módosítson ezzel össze nem függő buildbeállításokat.
A térbeli felület függőségének hozzáadása
· Nyissa meg a Gradle Scripts > build.gradle.kts (Module :app) fájlt.
· Keresse meg a meglévő dependencies { ... } blokkot.
· Keressen XR Compose-függőséget, akár közvetlenül megadva, akár egy aliason keresztül, például: implementation(libs.androidx.xr.compose). Ha már létezik alias, a libs.versions.toml fájlban állítsa az általa hivatkozott XR Compose-verziót 1.0.0-beta02 értékre. Ne adja hozzá kétszer ugyanazt a könyvtárat.
· Ha az XR Compose hiányzik, adja hozzá ezt a sort a meglévő dependencies blokkon belül:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Tartsa meg a sablon többi függőségét. Az alábbi kód ugyanis a szokásos Material 3 könyvtárat használja, amely a gombokat, a szöveget és a témát biztosítja, valamint az Activity Compose könyvtárat, amely Compose-tartalmat jelenít meg egy Android Activityben.
Szinkronizálás és továbblépés
Kattintson a szerkesztő értesítősávjában a Sync Now gombra, vagy válassza a File > Sync Project with Gradle Files menüpontot. Várja meg, amíg a letöltési és konfigurálási folyamat befejeződik.
Ellenőrzőpont: A szinkronizálás függőségi vagy Kotlin-kompatibilitási hibák nélkül befejeződik. Sikeres szinkronizálás esetén tartsa meg a többi generált buildbeállítást, majd nyissa meg a MainActivity.kt fájlt a felület hozzáadásához. Ha a szinkronizálás függőségi hibát jelez, vesse össze a megnevezett komponenst a Google Jetpack XR SDK beállítási oldalával. [6]
4. lépés: A feladatpanel elkészítése Kotlinban
A felület a feladat szövegét egy Mark complete gombbal és egy Restart demo gombbal jeleníti meg. A mintautasítások később egy jóváhagyott munkahelyi eljárásra cserélhetők.
Ugyanebben a fájlban (Android Studio > MainActivity.kt) tartsa meg a package sort, ha az Ön csomagja eltér, majd cserélje le a fájl többi részét az alábbi kódra. Távolítsa el ebből a fájlból a sablon régi mintafüggvényeit és előnézeti függvényeit, hogy csak egy MainActivity legyen. Az Activity egy Android-belépési pont, amely egy felületet jelenít meg. Az alábbi példa tartalmazza az Activityt és annak importjait.
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)
}
}
}
}Mit csinál a kód?
· A steps tárolja az utasítások szövegét
· A completed számolja a nyugtázásokat, és megakadályozza, hogy az utolsó feladaton túl lehessen lépni
· A rememberSaveable megőrzi ezt a kis értéket a támogatott Android-képernyő-újralétrehozás és állapot-visszaállítás során; ez nem tartós tárolás
· A LocalSpatialCapabilities ellenőrzi, hogy elérhető-e térbeli felhasználói felület [7]
· A Subspace területet hoz létre a térbeli tartalom számára, a SpatialPanel pedig ezen belül helyezi el a felületet [8]
· A tartalék ág ugyanazt a tartalmat normál ablakban jeleníti meg, ha a térbeli felhasználói felület nem érhető el
A dp mértékegység a képernyősűrűséghez igazítja az elrendezés méreteit; az sp a szöveget skálázza, és figyelembe veszi a betűméret-beállításokat. A görgethető tároló révén a hosszabb utasítások is elérhetők maradnak. A panel méretét tekintse kiindulópontnak, és ellenőrizze az olvashatóságot az Aurán.
Ellenőrzőpont: Az Android Studio felismeri az importokat, és nem jelez Kotlin-szintaktikai hibát. Ha a telepített könyvtár egy kísérleti API-hoz kifejezett engedélyezést (opt-in) igényel, használja a fordító diagnosztikai üzenetében megnevezett pontos annotációt, és nézze meg az adott kiadás API-referenciáját.
5. lépés: Az alkalmazás indulásának ellenőrzése Android XR-ben
Konfigurálja az indítási módot úgy, hogy az Android XR az ebben a példában használt térbeli elrendezéssel nyithassa meg az alkalmazást.
Az Aura szemüvegen a Home Space és a Full Space már be van építve az Android XR-be, és ezek határozzák meg, hogyan jelennek meg a futó alkalmazások. Az XR Glasses emulátor fejlesztési célra biztosítja ezeket a módokat, így nincs szükség külön telepítésre.
Az Android Studio Project paneljén nyissa meg az app > manifests > AndroidManifest.xml fájlt, és vizsgálja meg a MainActivity bejegyzést. Tartsa meg a MAIN és LAUNCHER intent filtert, az exported beállítást és a generált témát. A Compose által kezelt Full Space-hez tartozó tulajdonság alább látható. Ha a sablon már deklarál indítási tulajdonságot alkalmazás- vagy Activity-szinten, a meglévő értéket szerkessze, ne duplikálja. [9]
<!-- A meglévő MainActivity elemen belül -->
<property
android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />A kezelt (managed) Full Space azt jelenti, hogy az Android kezeli az Activity térbeli jelenetét. Az UNMANAGED érték az OpenXR-en – egy platformfüggetlen XR-interfészen – keresztül renderelő alkalmazásoknak szól; ez a Compose-példa nem használja. Sablonok összehasonlításakor nézze meg a manifest-konstansok referenciáját. [9]
A meglévő application elemben szintén tartsa meg vagy adja hozzá az android:enableOnBackInvokedCallback="true" attribútumot, hogy a térbeli panel megkapja a vissza eseményeket, ahogyan azt a Google panelútmutatója dokumentálja; az ottani példa az activity elemen állítja be, de az application elemen is érvényes. Ehhez a statikus ellenőrzőlistához ne adjon hozzá kamera-, mikrofon- vagy térérzékelési (scene understanding) engedélyeket. Az alkalmazás nem olvassa be a helyiséget, és nem azonosít tárgyakat. [8]
6. lépés: XR-szemüveg-emulátor létrehozása és az alkalmazás futtatása
Mielőtt csatlakoztatná az Aurát, futtassa az alkalmazást egy szimulált XR-szemüvegen. Az emulátor egy eszközt szimulál a számítógépén; az AVD ennek mentett konfigurációja.
· Az Android Studióban nyissa meg a Tools > Device Manager menüpontot. Kattintson az eszköz hozzáadására szolgáló vezérlőre, és válassza a Create Virtual Device lehetőséget.
· A Form Factor alatt válassza az XR, majd az XR Glasses lehetőséget. Kattintson a Next gombra.
· Válassza ki az XR Glasses profilhoz szükséges Preview API rendszerképet, és ha a rendszer kéri, töltse le. A támogatott rendszerkép architektúrája feleljen meg a számítógépének. Fejezze be a konfigurálást.
· Indítsa el az AVD-t a lejátszás vezérlőjével. Várja meg, amíg az Android XR-környezet teljesen betöltődik.
· Az Android Studio felső eszköztárán válassza ki az alkalmazás futtatási konfigurációját és a futó XR Glasses eszközt. Kattintson a Run gombra (zöld háromszög).
Az emulátor telepíti és megnyitja az alkalmazást. Az emulátor beviteli vezérlőivel aktiválja a Mark complete gombot. Ha a panel Home Space-ben marad, a Kotlin-elrendezés módosítása előtt ellenőrizze a manifestet és a környezet Full Space-vezérlőit. Lásd a hivatalos AVD-útmutatót.
Végezze el a következő elfogadási ellenőrzést:
· Az első képernyőn az látható, hogy a három feladatból nulla van nyugtázva, valamint megjelenik az első utasítás
· A Mark complete minden aktiválása pontosan egy utasítással lépteti tovább a listát
· A harmadik aktiválás után megjelenik a Checklist complete felirat, és a Mark complete gomb letiltódik
· A Restart demo visszaállítja az első utasítást és a nulla nyugtázást
· A hosszabb szöveg görgetéssel elérhető marad
· A tartalom akkor is megjelenik, ha a térbeli felhasználói felület nem érhető el
A sikeres emulátoros teszt az alkalmazáslogika és az elrendezés egy részét igazolja. Nem igazolja az Aura optikáját, a bevitel megbízhatóságát vagy a munkahelyi alkalmasságot.
7. lépés: Telepítés engedélyezett Aura hardverre
Az alábbi lépések a szokásos Android-hibakeresési folyamatot követik. Az Aura menüi és csatlakozási lehetőségei szoftververziótól függően eltérhetnek, ezért ahol különbség van, a készlethez tartozó útmutatót kövesse.
Az Aura csatlakoztatása és az alkalmazás futtatása
· Indítsa el az Aurát csatlakoztatott szemüveggel, és nyissa meg a Settings alkalmazást
· Az Aura beállításfelületén engedélyezze a Developer options lehetőséget és a hibakeresést a készlet útmutatója szerint; ha ezek a vezérlők nem érhetők el, szerezze be a fejlesztői beállítási útmutatót
· Csatlakoztassa a számítógépet USB-adatkábellel a számítási egység töltőportjához (Charging Port, bal oldal), a szemüveget pedig hagyja a Glasses Porton (jobb oldal); ha ez nem működik, a teljes ADB-támogatás érdekében csatlakoztassa a kábelt a jobb oldali portba.
· Fogadja el az eszközön megjelenő hibakeresési engedélykérést; felügyelt eszköz esetén rendszergazdai jóváhagyásra lehet szükség
· Az Android Studio felső eszköztárán az eszközök legördülő listájában válassza az Aura elemet, majd kattintson a következőre: Run
· Az Aurán ismételje meg a 6. lépés feladatpanel-ellenőrzéseit, beleértve a feladatok léptetését és az ellenőrzőlista újraindítását
Eszközcsatlakozási hibák elhárítása
Ha az Aura nem jelenik meg az Android Studio célválasztójában, ellenőrizze a kapcsolatot ADB-vel:
- Nyissa meg a View > Tool Windows > Terminal ablakot az Android Studióban.
- Futtassa a következő parancsot:
adb devices -lEllenőrizze a kimenetet:
· Ha az eszköz device állapottal szerepel a listában, akkor csatlakoztatva és engedélyezve van.
· Ha unauthorized állapotot mutat, vegye fel a szemüveget, és fogadja el a képernyőn megjelenő USB-hibakeresési kérést.
· Ha a lista üres, ellenőrizze újra az USB-adatkábelt, győződjön meg arról, hogy a számítási egység be van kapcsolva, és ellenőrizze, hogy az USB-hibakeresés továbbra is engedélyezve van-e a Settings alkalmazásban.
Összegzés
Az első XREAL Aura üzleti alkalmazás fejlesztése az Android Studióval, a Kotlinnal és a Jetpack XR SDK-val kezdődik, majd egy egyszerű munkautasítás-paneltől jut el az emulátoros tesztelésig és az engedélyezett hardverre történő telepítésig. Ez a megközelítés célzott lehetőséget ad a vállalatoknak annak felmérésére, hogy a térbeli utasítások javítanak-e egy valós munkafolyamaton, mielőtt integrációkba és flottaszintű bevezetésbe fektetnének. Ha a panel olvashatónak és használhatónak bizonyult, és az Aurán is validálták, a következő lépés a jóváhagyott eljárások és a megbízható munkanyilvántartás összekapcsolása a vállalat rendszereivel.
Beszéljen a VR Expert csapatával az Aura elérhetőségéről, valamint üzleti pilotprojektje hardveres, szoftverfejlesztési és támogatási igényeiről.

























