Az első XREAL Aura üzleti alkalmazás elkészítése Android Studióval

Az első XREAL Aura üzleti alkalmazás elkészítése Android Studióval

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:

  1. Nyissa meg a View > Tool Windows > Terminal ablakot az Android Studióban.
  1. Futtassa a következő parancsot:
adb devices -l

Ellenő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.

João Noronha

Írta

João Noronha

XR és immerzív tartalom specialista a VR Expertnél

João Noronha XR és immerzív tartalom specialista a VR Expertnél, akit erősen érdekelnek az új technológiák és azok valós alkalmazásai. Arra összpontosít, hogy a VR, AR, AI szemüvegek és immerzív technológiák összetett fejlesztéseit érthető, gyakorlatias tartalommá alakítsa a vállalatok és az XR iparág iránt érdeklődő szakemberek számára.

Gyakori kérdések

Ez a cikk

Igen. A felület és a feladatfolyamat fejlesztését kezdje az Android XR Glasses emulátorral. Munkahelyi pilotprojekt előtt azonban továbbra is szükség van fizikai Aura-tesztelésre.

Nem. Ehhez a felületközpontú példához az Android Studio, a Kotlin és a Jetpack Compose for XR megfelelő. A Unity egy különálló fejlesztőmotor, amely kiterjedt interaktív 3D-tartalommal rendelkező projektekhez lehet megfelelő.

Nem. Az SDK XR-képességeket biztosít. A csapatának továbbra is meg kell valósítania és validálnia kell a biztonsági, adattárolási, identitáskezelési, terjesztési, támogatási és integrációs követelményeket.

Nem. Helyileg tárolt szöveget jelenít meg, a nyugtázásokat pedig a felhasználói felület állapotában rögzíti. A berendezésfelismerés, a térérzékelés és az ellenőrzött munkanyilvántartás további tervezést és megvalósítást igényel.

Ez a példa nem valósít meg tartós fizikai horgonyt. A horgony olyan térbeli referencia, amellyel a tartalom egy helyhez képest pozicionálható; a gépspecifikus elhelyezéshez egy további, támogatott horgonyzási munkafolyamatra és eszközön végzett validálásra van szükség.