Az XREAL Aura fejlesztői környezet első beállítása

Az XREAL Aura fejlesztői környezet első beállítása

Vezetői összefoglaló

Használja a Unityt, ha üzleti alkalmazásához interaktív 3D-tartalomra van szükség, vagy az Android Studiót, ha natív Android-felületre. A beállítás akkor kész, ha a szükséges eszközök telepítve vannak, a projekt megfelel a konfigurációs ellenőrzéseknek, és a tesztelésre szánt eszköz vagy az emulátor elérhető.

Az útmutató a hivatalos Android XR-dokumentációt követi. Az Aura-specifikus fejlesztői portokat, firmware-menüket és engedélyeket a készülékhez mellékelt bevezető útmutató alapján kell ellenőrizni. Ez az útmutató nem állítja, hogy fizikai Aura-eszközön tesztelték volna.

Válassza ki a fejlesztési utat

Válassza a Unityt, ha projektje 3D-modelleket, interaktív képzést vagy szimulációt fog használni, illetve ha fejlesztői már a Unityvel és C#-pal dolgoznak. A Unity vizuális munkakörnyezetet kínál a tartalom elrendezéséhez és az XR-funkciók konfigurálásához. A környezet kódírás és prototípus készítése nélkül is beállítható.

Válassza az Android Studiót, ha egy Android üzleti alkalmazást bővít, vagy natív felületeket – például munkautasításokat, űrlapokat vagy feladatpaneleket – hoz létre. Ez Kotlint és a Google Jetpack XR könyvtárait használja. Később bármelyik út csatlakozhat üzleti rendszerekhez API-n – vagyis a szoftverek közötti információcsere meghatározott módján – keresztül; az utat az alkalmazás felülete és csapata készségei alapján válassza meg.

Fő fejlesztői szerkesztő:

  • Unity-út: Unity Editor, a Unity Hubon keresztül telepítve
  • Android Studio-út: Android Studio

Nyelv a későbbi fejlesztéshez:

  • Unity-út: C#
  • Android Studio-út: Kotlin

Android build-eszközök:

  • Unity-út: Android Build Support, beleértve az SDK-t, az NDK-t és az OpenJDK-t
  • Android Studio-út: Android SDK-eszközök, az SDK Manageren keresztül telepítve

Alapvető XR-támogatás:

  • Unity-út: OpenXR Plugin, a Unity Package Manageren keresztül telepítve
  • Android Studio-út: Jetpack XR SDK-könyvtárak, a Gradle-en keresztül letöltve

Platformspecifikus XR-támogatás:

  • Unity-út: Unity OpenXR: Android XR csomag
  • Android Studio-út: XR-projektsablon és a szükséges Jetpack XR-könyvtárak

Mit jelentenek az XR-eszközök:

  • Unity-út: Az OpenXR közös interfész az XR-alkalmazás és az eszköz futtatókörnyezete – az XR-funkciókat futtató rendszerszoftver – között
  • Android Studio-út: A Jetpack XR SDK a Google könyvtárgyűjteménye natív térbeli felületekhez és XR-funkciókhoz

Kapcsolat és diagnosztika:

  • Unity-út: ADB, azaz az Android Debug Bridge eszköz
  • Android Studio-út: ADB és az Android Studio Logcat, amely a diagnosztikai üzeneteket jeleníti meg

Készítse elő munkaállomását és a fejlesztői hozzáférést

Készítsen elő egy támogatott fejlesztői számítógépet, megbízható internetkapcsolatot a függőségek letöltéséhez, egy jóváhagyott vállalati projektmappát és egy USB-adatkábelt. Az emulátor követelményei eltérnek a szerkesztőétől; mielőtt virtuális eszközre hagyatkozna, nézze meg a Google XR-emulátor hardverkövetelményeit ismertető oldalát. A virtuális eszköz egy Android-eszköz szoftveres szimulációja. [4]

Használjon olyan Aura-egységet, amelyhez engedélyezett fejlesztői hozzáféréssel rendelkezik, a mellékelt szemüvegcsatlakozással és az XREAL által dokumentált fejlesztői kapcsolattal. Mielőtt workshopidőpontot rögzítene, győződjön meg a regionális elérhetőségről és a készlet bevezetéséről. Az XREAL aktuális oldalai és a regionális oldalak eltérő elérhetőséget mutathatnak; egy termékoldal önmagában nem határozza meg a szállítás időpontját. [1]

Üzleti célú munkához ellenőrizze, hogy szervezete jogosult-e a Unity-licencre, valamint a vonatkozó Industry-feltételeket, mielőtt a Unityt kereskedelmi célra használná. Használjon vállalati felügyelet alatt álló verziókezelést, jóváhagyott csomagforrásokat és tesztadatokat. Az Android Studio és a Unity professzionális alkalmazások fejlesztőeszközei; telepítésük önmagában nem igazolja, hogy az Aura támogatja a vállalati eszközfelügyeletet.

A) út: A Unity fejlesztői környezet beállítása

Ez az út telepíti a Unityt és annak Android-eszközeit, létrehoz egy üres projektet, és engedélyezi az Android XR-támogatást. Előkészíti a munkakörnyezetet a későbbi fejlesztéshez.

1. lépés | A Unity szerkesztő telepítése

A Unity Hub kezeli a szerkesztőtelepítéseket; a Unity Editor az a munkakörnyezet, ahol a projekteket konfigurálja, és később az alkalmazást fejleszti.

Telepítse a Unity Hubot a Unity hivatalos webhelyéről, és nyissa meg. Lépjen az Installs, majd az Install Editor menüpontra. Válasszon egy támogatott Unity 6.5-ös (vagy újabb) kiadást, amely kompatibilis a használni kívánt Android XR csomaggal, hogy teljes támogatást kapjon a puck érintőpadjának bemenetéhez és más funkciókhoz. A Google beállítási oldala jelenleg a 6000.0.58f2-es vagy újabb verziót írja elő; emellett az újabb csomagkövetelmények is érvényesek. [5]

2. lépés | Az Android build-eszközök hozzáadása

Ezek a modulok teszik lehetővé, hogy a Unity Android-alkalmazássá alakítsa a projektet.

Az XREAL Aura Android XR-t futtat, ezért olyan Android-alkalmazásra van szüksége, amelyet az operációs rendszere telepíteni és futtatni tud. A Unity-projekt szerkeszthető fejlesztési fájlokat tartalmaz; az Android build-eszközök ezeket a fájlokat telepíthető alkalmazássá csomagolják és fordítják le – eszközön való teszteléshez ez általában egy APK.

A telepítési modulok között jelölje be az Android Build Support elemet és alelemeit, majd kattintson a Continue gombra, és kövesse a telepítési utasításokat. A szükséges eszközök:

· Android SDK (Software Development Kit, szoftverfejlesztői készlet)

· Android NDK (Native Development Kit, natív fejlesztői készlet): az alacsonyabb szintű kódot olyan formára alakítja, amelyet az eszköz processzora futtatni tud.

· JDK (Java Development Kit, Java fejlesztői készlet)

Meglévő szerkesztő esetén térjen vissza a Unity Hub > Installs részhez, nyissa meg a szerkesztő menüjét, válassza az Add modules lehetőséget, jelölje be ugyanezeket az elemeket, majd kattintson az Installs gombra.

3. lépés | Projekt létrehozása

Egy üres projekt helyet ad az Android XR fejlesztői környezet konfigurálásához.

A Unity Hubban nyissa meg a Projects > New project menüt. Válassza ki a telepített szerkesztőt és a Universal 3D sablont. Adja a projektnek az AuraDevelopmentSetup nevet, válasszon mappát, és kattintson a Create project gombra. Az Universal 3D sablon az URP-t, vagyis a Universal Render Pipeline-t használja, amely az alkalmazás grafikáját rajzolja meg.

4. lépés | Az eszközök elérési útjainak ellenőrzése

A Unitynek tudnia kell, hová vannak telepítve a kompatibilis Android build-eszközei.

A Unity Editorban nyissa meg az Edit > Preferences > External Tools menüt (macOS-en: Unity > Settings vagy Preferences). Hagyja kiválasztva a Unity által biztosított SDK-t (Android platformeszközök), NDK-t (natív kódfordító eszközök) és JDK-t (Java build-eszközök). Ezek a verziók a Unity szerkesztőhöz vannak igazítva, ami segít elkerülni a build-hibákat. Ne cserélje le őket nem kapcsolódó Android Studio-eszközverziókra csak azért, mert mindkettő telepítve van.

Az XREAL Aura fejlesztői környezet konfigurálása a Unityben

Az OpenXR nyílt szabvány, amely segíti az XR-alkalmazások kommunikációját a kompatibilis eszköz-futtatókörnyezetekkel. A Unityben telepítse az alapkapcsolathoz az OpenXR Plugin csomagot, az Android XR-támogatáshoz pedig a Unity OpenXR: Android XR csomagot a Package Manager segítségével. Az AR Foundation a Unity közös interfésze a támogatott AR-funkciókhoz, például a környezetértelmezéshez.

1. lépés | Az Android XR build-cél kiválasztása

A build-cél megmondja a Unitynek, hogy az alkalmazásnak melyik platformon kell futnia.

Nyissa meg a File > Build Profiles menüt. Unity 6.1-es vagy újabb verzióban adja hozzá vagy válassza ki az Android XR platformprofilt, és váltson rá. A Unity dokumentációja szerint ez automatikusan telepítheti a kompatibilis Android XR csomagot. Ha az Ön támogatott szerkesztője ehelyett az Android platformot használja, válassza az Androidot, és konfigurálja manuálisan az OpenXR-t. [7]

2. lépés | Az OpenXR-csomagok telepítése

A csomagok adják hozzá azokat a szoftverkomponenseket, amelyek a Unity-jelenetet az Android XR-hez kapcsolják.

Nyissa meg a Window > Package Management > Package Manager menüt, illetve a régebbi menüelrendezésű szerkesztőkben a Window > Package Manager menüt. Ellenőrizze, hogy az OpenXR Plugin és a Unity OpenXR: Android XR telepítve van-e. Ha az Android XR csomag hiányzik, használja a plusz menü > Add package by name lehetőséget, és adja meg a com.unity.xr.androidxr-openxr azonosítót. Az alap OpenXR-csomag azonosítója com.unity.xr.openxr. Hagyja, hogy a Package Manager feloldja a kompatibilis függőségeket. [6]

3. lépés | Az XR-szolgáltató engedélyezése

A csomag telepítése elérhetővé teszi azt; a szolgáltató engedélyezése pedig lehetővé teszi, hogy az alkalmazás használja.

Nyissa meg az Edit > Project Settings > XR Plug-in Management menüt. Az Android lapon engedélyezze az OpenXR-t. Nyissa meg az alatta lévő OpenXR szakaszt, és engedélyezze az Android XR funkciócsoportot. AR Foundation-funkciók használatakor engedélyezze az Android XR: Session lehetőséget. Az 1.0-s verzióhoz az Android XR: AR Session lehetőséget engedélyezze. Ehhez a buildhez ne engedélyezzen nem kapcsolódó szolgáltatókat. [8]

4. lépés | A projekt validálása

A validálás azonosítja azokat a beállításokat, amelyek megakadályoznák a támogatott XR-buildet.

Nyissa meg az XR Plug-in Management > Project Validation részt, és válassza az Androidot. Tekintse át és oldja meg a kötelező problémákat, majd ellenőrizzen újra. A csomagspecifikus validálási követelmények elsőbbséget élveznek a régebbi oktatóanyagokból átmásolt beállításokkal szemben.

5. lépés | Tartsa egyszerűen a bemeneti követelményeket

Csak azokat a funkciókat engedélyezze, amelyekre a tervezett alkalmazásnak szüksége van, és amelyeket a céleszköz támogat.

Az opcionális bemeneti funkciókat hagyja az alkalmazásfejlesztési szakaszra, hacsak a projekt vagy a sablon nem igényli őket. Egy szemkövetési (eye gaze) vagy kontrollerprofil engedélyezése nem ad ilyen hardvert az Aurához. Folytatás előtt tekintse át a szükséges interakciós beállításokat a Project Validation részben.

A Google Android XR Extensions for Unity egy további csomag extra funkciókkal. Ez nem azonos a Unity OpenXR: Android XR csomaggal. Nem kell csak azért hozzáadnia, mert a nevek hasonlóan hangzanak; akkor adja hozzá, ha alkalmazásának szüksége van valamelyik általa biztosított funkcióra. [9]

A renderelési és Android build-beállítások ellenőrzése

A Vulkan az a grafikus interfész, amelyen keresztül a renderelési feladatok a GPU-hoz kerülnek. Az Edit > Project Settings > Player menüben válassza az Android > Other Settings lehetőséget. Ha az Auto Graphics API be van kapcsolva, kapcsolja ki, és helyezze a Vulkant az első helyre. Egyszerű URP-alapbeállításhoz kapcsolja ki a HDR-t az URP assetben, az utófeldolgozást pedig a hozzá tartozó renderer assetben. A Google ezeket a beállításokat javasolja Android XR-hez. [5]

Ugyanezekben a Player-beállításokban adjon meg egyedi csomagazonosítót, például com.yourcompany.aurapilot. A Configuration alatt válassza az IL2CPP és az ARM64 lehetőséget a fizikai eszközre szánt buildhez. Az IL2CPP a C#-kódot natív kóddá alakítja; az ARM64 az a processzorarchitektúra, amelyet a build céloz. Az esetleges további korlátozásokért ellenőrizze a telepített csomagok validálását és az eszközkövetelményeket.

A Google az API 24-et az OpenXR loader minimumaként adja meg, nem pedig az Aura operációsrendszer-verziójaként. Olyan minimális API-szintet használjon, amely minden telepített csomag követelményének is megfelel, és olyan telepített cél-SDK-t, amelyet a szerkesztő és a terjesztési követelmények támogatnak. Állítsa be a GameActivity elemet alkalmazás-belépési pontként, törölje az Activity jelölését, és engedélyezze a Resizable Activity beállítást a Resolution and Presentation alatt, a Google útmutatása szerint. [5]

B) út: Az Android Studio fejlesztői környezet beállítása

Ez az út telepíti az Android Studiót, letölti az Android fejlesztőeszközöket, és létrehoz egy XR-projektet a Google sablonjából. Előkészíti a natív Android munkakörnyezetet a későbbi alkalmazásfejlesztéshez. Emulátort is létrehozhat annak ellenőrzésére, hogy a projekt lefordul és elindul.

A beállítás áttekintése: az Android Studio telepítése → az Android-eszközök letöltése → XR-projekt létrehozása → a függőségek ellenőrzése → tesztcél előkészítése.

Az Android Studio a Google fejlesztői környezete Android-alkalmazásokhoz. Itt a Kotlin a használt programozási nyelv. A Jetpack XR SDK natív térbeli felhasználóifelület- és XR-könyvtárakat biztosít, a Jetpack Compose pedig Kotlin-kódban írja le a felületeket.

1. lépés | Az XR-kompatibilis szerkesztő telepítése

Az ajánlott Android Studio-verzió tartalmazza az ebben az útban használt XR-eszközöket és -sablonokat.

Töltse le a Google XR-beállítási oldalán ajánlott Android Studio-buildet. A jelenlegi útmutatás a legújabb Canary buildet javasolja; szükség esetén telepítse a szokásos stabil verzió mellé. A Canary korai fejlesztői kiadást jelent, ezért rögzítse a csapata által használt pontos verziót. [10]

2. lépés | Az Android fejlesztőeszközök letöltése

Az SDK Manager telepíti az alkalmazás buildeléséhez, futtatásához és vizsgálatához szükséges komponenseket.

Az üdvözlőképernyőn nyissa meg a More Actions > SDK Manager menüpontot. Az SDK Tools alatt telepítse vagy frissítse az Android SDK Build-Tools, az Android Emulator és az Android SDK Platform-Tools összetevőt, valamint a Google aktuális utasításaiban megadott Layout Inspector-verziót. Kattintson az Apply gombra, és fogadja el a licenceket. [10]

3. lépés | Az XR-projekt létrehozása

Az XR-sablon olyan kiinduló alkalmazást biztosít, amelyben a térbeli struktúra már adott.

Nyissa meg a New Project menüt. A sablonlistában válassza az XR-t, majd az XR-headsetekhez vagy vezetékes XR-szemüvegekhez készült immerzív sablont. Ne válasszon audioszemüveg- vagy kijelzős szemüveg-sablont. Kattintson a Next gombra, adja a projektnek az AuraBusinessPanel nevet, ha a rendszer felkínálja, adjon meg vállalati csomagnevet, válasszon mentési mappát, és kattintson a Finish gombra. [11]

4. lépés | Hagyja, hogy a projekt letöltse a függőségeket

A Gradle sync előkészíti a könyvtárakat és a build-konfigurációt, mielőtt szerkeszteni kezdené az alkalmazást.

Várja meg, amíg a Gradle sync befejeződik. A Gradle az a buildrendszer, amely letölti a függőségeket és lefordítja az alkalmazást. Nyissa meg a Project panelt, és keresse meg az app/build.gradle.kts fájlt vagy az app modul Gradle-fájlját. Tartsa meg a sablon egymással kompatibilis verzióit; ne frissítsen találomra egy-egy XR-könyvtárat.

5. lépés | Az Android API-követelmények ellenőrzése

Az API-beállításoknak meg kell felelniük a sablon és minden használt könyvtár követelményeinek.

Vesse össze a Jetpack XR SDK beállítási oldalát a sablonjával. A közzétett alapérték minSdk 24 és compileSdk 34 vagy magasabb; használjon magasabb értékeket, ha a választott könyvtárak vagy a sablon ezt igénylik. A compileSdk a fordításkor használt Android API, a minSdk pedig a legrégebbi támogatott Android API-t határozza meg. [12]

Az SDK beállítási oldala a Runtime, SceneCore, Compose for XR, Material Design for XR és ARCore for Jetpack XR függőségeket sorolja fel. Csak azt adja hozzá, amit az alkalmazás használ. A SceneCore a térbeli tartalmat kezeli; az ARCore for Jetpack XR támogatott érzékelési képességeket biztosít. Az előzetes (preview) verziók változhatnak, ezért egy régi függőségblokk bemásolása helyett a sablont és a kiadási megjegyzéseket együtt használja.

Ha a sablon nem tartalmazza automatikusan az alap XR-könyvtárakat, gondoskodjon arról, hogy az app/build.gradle.kts tartalmazza a következő alapfüggőségeket:

android {

compileSdk = 34 // vagy a sablon által beállított magasabb érték

defaultConfig {

minSdk = 24

}

}

dependencies {

// Jetpack XR SDK alapfüggőségek

implementation("androidx.xr.runtime:runtime:1.1.0-alpha02")

implementation("androidx.xr.scenecore:scenecore:1.1.0-alpha01")

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

implementation("androidx.xr.compose.material3:material3:1.0.0-alpha17")

}

A kutatás időpontjában a Compose for XR 1.0.0-beta02 (2026. 10. 21.) Kotlin 2.2-t igényel, és a kiadási megjegyzései szerint a SceneCore 1.0.0-rc01-től függ, amelyben ismert memóriaszivárgás van; a megkerülő megoldás az, hogy saját maga deklarálja a SceneCore 1.0.0-s vagy újabb verzióját, amit a fenti függőségblokk már meg is tesz. Ez az egyik oka annak, hogy érdemes a teljes függőségkészletet rögzíteni ahelyett, hogy bármely legújabb telepítést éles használatra késznek nevezne. [13]

Futtatás XR-emulátoron, mielőtt a hardver elérhető lenne

1. lépés | Virtuális XR-eszköz létrehozása

Az emulátorral már azelőtt ellenőrizheti a szoftvert, hogy fizikai Aura-egység rendelkezésre állna.

Nyissa meg a Tools > Device Manager menüt, majd válassza az Add a new device > Create Virtual Device lehetőséget. Formatényezőként válassza az XR-t, a vezetékes szemüveges munkafolyamathoz pedig az XR Glasses lehetőséget. [4]

2. lépés | A szükséges rendszerkép telepítése

A rendszerkép biztosítja a virtuális eszköz Android XR operációs környezetét.

Válassza ki a Google útmutatója szerint az XR Glasses eszközhöz szükséges előzetes rendszerképet, töltse le, ha a rendszer kéri, és fejezze be a virtuális eszköz létrehozását. Indítsa el a Device Manager felületről.

3. lépés | Az alkalmazás futtatása

Az Android Studio lefordítja a projektet, és telepíti a kiválasztott virtuális eszközre.

Az Android Studio felső eszköztárán válassza ki az app futtatási konfigurációt és a futó virtuális XR-eszközt. Kattintson a Run gombra. Hagyja, hogy az Android Studio lefordítsa és telepítse a módosítatlan sablont. Ehhez a környezetellenőrzéshez nem kell testre szabnia a sablon felületét.

4. lépés | Az eredmény ellenőrzése

A sikeres build és indítás megerősíti, hogy a telepített eszközök képesek feldolgozni a sablont.

Ellenőrizze, hogy a sablon build- vagy indítási hiba nélkül megnyílik-e. Ez az alapvető szoftverbeállítást igazolja, nem az Aura optikáját, a fizikai követést, a teljesítményt vagy az éles használatra való alkalmasságot.

Az XREAL Aura csatlakoztatása a fejlesztői számítógéphez

Az ADB (Android Debug Bridge) segítségével a fejlesztői számítógép alkalmazásokat telepíthet egy Android-eszközre, és diagnosztikai naplókat olvashat ki róla. A Unity és az Android Studio egyaránt használhatja.

Az XREAL Aura GYIK-je szerint a compute puck mindkét USB-C portja támogatja a szabványos ADB-hibakeresést az Android Studióval, a specifikációs táblázat azonban csak a Glasses Port esetében tünteti fel a teljes ADB-támogatást, ezért lehetőség szerint ezt a portot használja. A szemüveget az utasításoknak megfelelően tartsa csatlakoztatva. A DisplayPort-tükrözés és az engedélyezett ADB-kapcsolat különböző funkciók, így ha a laptop képernyője látható a szemüvegben, az még nem bizonyítja, hogy a fejlesztői kapcsolat működik.

1. lépés | Az engedélyezett hibakeresés bekapcsolása

A hibakeresés lehetővé teszi, hogy a fejlesztői számítógép tesztalkalmazásokat telepítsen és vizsgáljon.

Az Android XR rendszeren nyissa meg a Settings menüt, és a firmware-hez tartozó utasítások szerint engedélyezze a Developer options és a USB debugging lehetőséget. A szabványos Android a Developer options menüt általában a Build number többszöri kiválasztásával teszi elérhetővé, de a pontos Aura-menüútvonalat az áttekintett nyilvános források alapján nem sikerült megállapítani. Ha eltér, a mellékelt bevezető útmutatóban leírt útvonalat kövesse. [14]

2. lépés | A számítógép csatlakoztatása és engedélyezése

Ehhez a vezetékes hibakeresési munkafolyamathoz USB-adatkapcsolat és az eszközön adott jóváhagyás szükséges.

Csatlakoztassa a gazdagépet USB-adatkábellel a dokumentált fejlesztői porthoz. Hagyja jóvá az eszközön a számítógép hibakeresési engedélykérését. Windows rendszeren telepítse a gyártó ADB-illesztőprogramját, ha a rendszer igényli. [14]

3. lépés | Ellenőrizze, hogy az ADB látja-e az eszközt

Az eszközlista megerősíti, hogy a kapcsolat kész, mielőtt buildelést és futtatást kísérelne meg.

Az Android Studióban nyissa meg az SDK Manager felületet, és jegyezze fel az Android SDK Location értékét. A terminálban nyissa meg az SDK platform-tools mappáját, és futtassa az alábbiak közül a megfelelő parancsot.

# Windows PowerShell, a platform-tools mappában

.\adb.exe devices -l

# macOS vagy Linux, a platform-tools mappában

./adb devices -l

Várt eredmény: az eszköz sorozatszámát a device szó követi. Ha unauthorized jelenik meg, hagyja jóvá a kérést. Ha a lista üres, ellenőrizze a kábelt, a gazdagép portját, a hibakeresési beállítást és az illesztőprogramot. Ha egynél több eszköz vagy emulátor csatlakozik, kifejezetten adja meg a kívánt célt.

Ellenőrizze, hogy a fejlesztői környezet készen áll-e

Unity – készenléti ellenőrzések

1. lépés | A build-profil ellenőrzése

Az alkalmazásfejlesztés megkezdése előtt ellenőrizze a beállítást.

Nyissa meg a File > Build Profiles menüt, és győződjön meg arról, hogy az Android XR vagy az XR-re konfigurált Android profil aktív. Győződjön meg arról is, hogy a szükséges Android build-modulok elérhetők ehhez a szerkesztőhöz.

2. lépés | A csomagok és a validálás ellenőrzése

A projektben telepítve és engedélyezve kell lenniük a szükséges XR-csomagoknak.

A Package Manager felületen ellenőrizze az OpenXR Plugin és a Unity OpenXR: Android XR csomagot. A Project Settings > XR Plug-in Management részben ellenőrizze az Android OpenXR-szolgáltatót és az Android XR funkciócsoportot. Oldja meg a kötelező problémákat a Project Validation részben.

3. lépés | A céleszköz ellenőrzése

A felismert eszköz lezárja a beállítás kapcsolódási részét.

A Build Profiles ablakban frissítse a Run Device listát, és ellenőrizze, hogy megjelenik-e az engedélyezett Aura-egység. Ha nem, ellenőrizze az ADB-kapcsolatot és a Unity External Tools elérési útjait. A projektet a hardver megérkezése előtt is konfigurálhatja, de a fizikai telepítés validálásához meg kell várni az eszközt.

Android Studio – készenléti ellenőrzések

Győződjön meg arról, hogy a Gradle sync hiba nélkül befejeződik, az SDK Manager felületen telepítve vannak a szükséges eszközök, és az XR-emulátor vagy az engedélyezett Aura-eszköz megjelenik a célválasztóban. Ha rendelkezésre áll tesztcél, futtassa a módosítatlan XR-sablont. Az indítási hibák vizsgálatához nyissa meg a View > Tool Windows > Logcat ablakot. A Logcat az Android diagnosztikai üzeneteit jeleníti meg.

Hogyan működik együtt a Unity és az Android Studio

A Unity saját támogatott eszközeivel is tud Android-alkalmazásokat buildelni, így egy Unity-projekt konfigurálásához nincs szükség az Android Studióra. Az Android Studio ennek ellenére hasznos lehet az emulátorok kezelésében és az Android-diagnosztikában, például a Logcattel. Érdemes kiemelni, hogy az Android XR emulátor nem támogatja a Unityvel, Godot-val, Unreal Engine-nel vagy OpenXR-rel készült alkalmazások szimulációját, ezért a Unity-buildekhez fizikai Aura szükséges. Natív Kotlin-alkalmazás esetén az Android Studio a fő munkakörnyezet, és a Unityre nincs szükség.

Az Android-build későbbi testreszabásához a Unity Gradle-projektet tud exportálni az Android Studio számára. Ez a lépés a kezdeti beállításhoz nem szükséges. Hagyja kiválasztva a Unity saját támogatott build-eszközeit, hacsak az integráció kifejezetten nem igényel exportálási munkafolyamatot.

Hibaelhárítás az első beállításnál

  • Az Android build-cél nem érhető el: Adja hozzá az Android Build Support modult pontosan ahhoz a Unity szerkesztőtelepítéshez
  • Hiányzik az Android XR csoport: Ellenőrizze a csomagazonosítót, a kompatibilitást és az Android céllapot
  • A Gradle sync sikertelen: Olvassa el az első build-hibát; ellenőrizze az SDK telepítését és az egymáshoz illő függőségverziókat
  • Hiányoznak szükséges csomagok vagy funkciók: Ellenőrizze a Package Managert, az aktív Android-célt és az Android XR funkciócsoportot
  • A Project Validation hibákat jelez: Tekintse át az összes kötelező problémát, és alkalmazza a telepített csomagverziójához tartozó javítást
  • Az eszköz nincs engedélyezve (unauthorized): Hagyja jóvá a hibakeresési kérést az eszközön
  • A telepítés sikertelen az emulátoron: Vesse össze az APK architektúráját az emulátor rendszerképével

Összegzés

Az XREAL Aura fejlesztői környezet beállítása a kompatibilis eszközök telepítését, egy Android XR-projekt előkészítését, a megfelelő platformtámogatás engedélyezését és az eszközkapcsolat ellenőrzését jelenti. A Unity az interaktív 3D-tartalmat használó projektekhez, az Android Studio pedig a natív Android-felületekhez illik. Egy átlátható, megismételhető beállítás segít a vállalatoknak csökkenteni a konfigurációs problémákat, és megbízható alapot ad a fejlesztőknek az alkalmazások fejlesztéséhez és teszteléséhez.

XREAL Aura-fejlesztést tervez? Beszélje meg a hardverhozzáférést, a szoftverkövetelményeket és a bevezetési támogatást a VR Experttel.

Fedezze fel az üzleti XR-hardvereket és -támogatást itt: https://ai.vr-expert.com/

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

Nem. A 3D-s úthoz a Unityt, a natív úthoz az Android Studiót használja. Az Android Studio akkor is hasznos marad a diagnosztikához és az emulátorok kezeléséhez, ha a Unity az elsődleges szerkesztője.

A dokumentált kiindulópont az Android XR a Unity Android XR csomagjaival vagy a Jetpack XR-rel. Gyártóspecifikus komponenst csak akkor adjon hozzá, ha az aktuális Aura-dokumentáció ezt előírja. Ne feltételezze, hogy egy régebbi XREAL SDK felcserélhető az Android XR szoftververemmel.

Igen. Az Android Studio XR Glasses emulátorával validálható a támogatott szoftverek működése. A Google szerint az emulátor nem támogatja a Unityvel, Godot-val, Unreal Engine-nel vagy OpenXR-rel készült alkalmazásokat, így ezekhez az utakhoz fizikai Aura szükséges. Az eszköz teljesítményének, követésének és használhatóságának jóváhagyásához mindenképp fizikai hardverre van szükség.

Nem. Az OpenXR közös interfészeket biztosít, de az egyes bővítmények, érzékelők, beviteli módok és engedélyek továbbra is eszközfüggők. Speciális funkciók engedélyezése előtt ellenőrizze a futtatókörnyezet támogatását.

Az eszközök telepítéséhez, az Android XR konfigurálásához és az eszközkapcsolat ellenőrzéséhez nincs szükség egyedi kódra. Az Android Studio beállítás-ellenőrzésként lefordíthat egy módosítatlan XR-sablont. Alkalmazáskódot akkor adjon hozzá, amikor megkezdi az üzleti funkciók megvalósítását.