Sammanfattning
Använd Unity när din affärsapplikation behöver interaktivt 3D-innehåll, eller Android Studio när den behöver ett inbyggt Android-gränssnitt. Konfigurationen är klar när de nödvändiga verktygen är installerade, projektet klarar konfigurationskontrollerna och din testenhet eller emulator är tillgänglig.
Instruktionerna följer den officiella dokumentationen för Android XR. Aura-specifika utvecklingsportar, firmwaremenyer och behörigheter måste kontrolleras mot de introduktionsanvisningar som medföljer din enhet. Den här guiden gör inte anspråk på att bygga på fysiska tester med Aura.
Välj utvecklingsväg
Välj Unity om ditt projekt ska använda 3D-modeller, interaktiv utbildning eller simulering, eller om dina utvecklare redan arbetar med Unity och C#. Unity ger dig en visuell arbetsyta för att arrangera innehåll och konfigurera XR-funktioner. Du kan konfigurera miljön utan att skriva kod eller bygga en prototyp.
Välj Android Studio om du bygger ut en Android-affärsapplikation eller skapar inbyggda gränssnitt som arbetsinstruktioner, formulär eller uppgiftspaneler. Det använder Kotlin och Googles Jetpack XR-bibliotek. Båda vägarna kan senare anslutas till affärssystem via ett API, ett definierat sätt för programvara att utbyta information; välj väg utifrån applikationens gränssnitt och teamets kompetens.
Primär utvecklingsredigerare:
- Unity-vägen: Unity Editor, installerad via Unity Hub
- Android Studio-vägen: Android Studio
Språk för senare utveckling:
- Unity-vägen: C#
- Android Studio-vägen: Kotlin
Android-byggverktyg:
- Unity-vägen: Android Build Support, inklusive SDK, NDK och OpenJDK
- Android Studio-vägen: Android SDK-verktyg, installerade via SDK Manager
Grundläggande XR-stöd:
- Unity-vägen: OpenXR Plugin, installerat via Unity Package Manager
- Android Studio-vägen: Jetpack XR SDK-bibliotek, hämtade via Gradle
Plattformsspecifikt XR-stöd:
- Unity-vägen: Paketet Unity OpenXR: Android XR
- Android Studio-vägen: XR-projektmall och nödvändiga Jetpack XR-bibliotek
Vad XR-verktygen innebär:
- Unity-vägen: OpenXR är ett gemensamt gränssnitt mellan en XR-app och enhetens runtime, den systemprogramvara som kör XR-funktionerna
- Android Studio-vägen: Jetpack XR SDK är Googles samling bibliotek för inbyggda rumsliga gränssnitt och XR-funktioner
Anslutning och diagnostik:
- Unity-vägen: ADB, verktyget Android Debug Bridge
- Android Studio-vägen: ADB och Android Studio Logcat, som visar diagnostikmeddelanden
Förbered din arbetsstation och utvecklingsåtkomst
Förbered en utvecklingsdator som stöds, en stabil internetanslutning för beroenden, en godkänd projektmapp hos företaget och en USB-datakabel. Kraven för emulatorn skiljer sig från kraven för redigeraren; kontrollera Googles sida om maskinvarukrav för XR-emulatorn innan du förlitar dig på en virtuell enhet. En virtuell enhet är en programvarusimulering av en Android-enhet. [4]
Använd en Aura-enhet med behörig utvecklaråtkomst, dess medföljande glasögonanslutning och den utvecklingsanslutning som XREAL har dokumenterat. Bekräfta regional tillgång och introduktion av utrustningen innan du bestämmer ett datum för en workshop. XREAL:s aktuella sidor och regionala sidor kan ge olika uppgifter om tillgänglighet; en produktlistning i sig fastställer inte leveranstiden. [1]
För affärsbruk: bekräfta att din organisation uppfyller villkoren för Unity-licensen och eventuella relevanta Industry-villkor innan du använder Unity kommersiellt. Använd versionshantering som kontrolleras av företaget, godkända paketkällor och testdata. Android Studio och Unity är utvecklingsverktyg för professionella applikationer; att de installeras innebär inte att det finns stöd för företagshantering på Aura.
Väg A – Konfigurera utvecklingsmiljön i Unity
Den här vägen installerar Unity och dess Android-verktyg, skapar ett tomt projekt och aktiverar stöd för Android XR. Den förbereder arbetsytan för senare utveckling.
Steg 1 | Installera Unity-redigeraren
Unity Hub hanterar dina installationer av redigeraren; Unity Editor är arbetsytan där du konfigurerar projekt och senare utvecklar din applikation.
Installera Unity Hub från Unitys officiella webbplats och öppna programmet. Gå till Installs och sedan Install Editor. Välj en version av Unity 6.5 (eller senare) som stöds och är kompatibel med det Android XR-paket du ska använda, för att få fullt stöd för inmatning via puckens styrplatta och andra funktioner. Googles konfigurationssida anger för närvarande 6000.0.58f2 eller senare; nyare paketkrav gäller också. [5]
Steg 2 | Lägg till Android-byggverktygen
Dessa moduler gör att Unity kan omvandla ditt projekt till en Android-applikation.
XREAL Aura kör Android XR och behöver därför en Android-applikation som operativsystemet kan installera och köra. Ditt Unity-projekt innehåller redigerbara filer för utveckling; Android-byggverktygen paketerar och kompilerar dessa filer till en installerbar app, vanligtvis en APK för test på enheten.
Bland installationsmodulerna väljer du Android Build Support och dess underalternativ, klickar sedan på Continue och slutför installationsanvisningarna. Verktygen som behövs:
· Android SDK (Software Development Kit)
· Android NDK (Native Development Kit): Det omvandlar kod på lägre nivå till en form som enhetens processor kan köra.
· JDK (Java Development Kit)
För en befintlig redigerare går du tillbaka till Unity Hub > Installs, öppnar redigerarens meny, väljer Add modules, markerar samma alternativ och klickar sedan på Installs.
Steg 3 | Skapa ett projekt
Ett tomt projekt ger dig en plats där du kan konfigurera utvecklingsmiljön för Android XR.
I Unity Hub öppnar du Projects > New project. Välj den installerade redigeraren och välj Universal 3D. Ge projektet namnet AuraDevelopmentSetup, välj en mapp och välj Create project. Universal 3D använder URP, Universal Render Pipeline, som ritar applikationens grafik.
Steg 4 | Kontrollera verktygssökvägarna
Unity behöver veta var de kompatibla Android-byggverktygen är installerade.
I Unity Editor öppnar du Edit > Preferences > External Tools (Unity > Settings eller Preferences på macOS). Behåll Unitys medföljande SDK (Androids plattformsverktyg), NDK (kompilatorverktyg för inbyggd kod) och JDK (Java-byggverktyg) valda. Dessa versioner är anpassade till din Unity-redigerare, vilket hjälper till att undvika byggfel. Ersätt dem inte med orelaterade verktygsversioner från Android Studio bara för att båda är installerade.
Konfigurera din utvecklingsmiljö för XREAL Aura i Unity
OpenXR är en öppen standard som hjälper XR-applikationer att kommunicera med kompatibla enhetsruntimes. I Unity installerar du OpenXR Plugin för grundanslutningen och Unity OpenXR: Android XR för stöd för Android XR via Package Manager. AR Foundation är Unitys gemensamma gränssnitt för AR-funktioner som stöds, till exempel miljöförståelse.
Steg 1 | Välj byggmålet Android XR
Byggmålet talar om för Unity vilken plattform applikationen ska köras på.
Öppna File > Build Profiles. I Unity 6.1 eller senare lägger du till eller väljer plattformsprofilen Android XR och växlar till den. Enligt Unitys dokumentation kan detta installera det kompatibla Android XR-paketet automatiskt. Om din redigerare som stöds i stället använder Android-plattformen väljer du Android och konfigurerar OpenXR manuellt. [7]
Steg 2 | Installera OpenXR-paketen
Paketen lägger till de programvarukomponenter som kopplar din Unity-scen till Android XR.
Öppna Window > Package Management > Package Manager, eller Window > Package Manager i redigerare med den äldre menylayouten. Kontrollera att OpenXR Plugin och Unity OpenXR: Android XR är installerade. Om Android XR-paketet saknas använder du plusmenyn > Add package by name och anger com.unity.xr.androidxr-openxr. Paketidentifieraren för OpenXR-kärnpaketet är com.unity.xr.openxr. Låt Package Manager lösa kompatibla beroenden. [6]
Steg 3 | Aktivera XR-providern
När ett paket installeras blir det tillgängligt; när providern aktiveras kan applikationen använda det.
Öppna Edit > Project Settings > XR Plug-in Management. Aktivera OpenXR på fliken Android. Öppna OpenXR-avsnittet under den och aktivera funktionsgruppen Android XR. Aktivera Android XR: Session när du använder AR Foundation-funktioner. Aktivera Android XR: AR Session för version 1.0. Undvik att aktivera orelaterade providers för den här builden. [8]
Steg 4 | Validera projektet
Valideringen identifierar inställningar som skulle förhindra en XR-build som stöds.
Öppna XR Plug-in Management > Project Validation och välj Android. Gå igenom och åtgärda de obligatoriska problemen och kontrollera sedan igen. Paketspecifika valideringskrav går före inställningar som kopierats från en äldre handledning.
Steg 5 | Håll inmatningskraven enkla
Aktivera bara funktioner som din planerade applikation kräver och som målenheten stöder.
Vänta med valfria inmatningsfunktioner till applikationsutvecklingsskedet, såvida inte ditt projekt eller din mall kräver dem. Att aktivera en profil för ögonstyrning eller handkontroller lägger inte till den maskinvaran i Aura. Gå igenom eventuella obligatoriska interaktionsinställningar i Project Validation innan du fortsätter.
Googles Android XR Extensions for Unity är ett extra paket med ytterligare funktioner. Det är skilt från Unity OpenXR: Android XR. Du behöver inte lägga till det bara för att namnen låter lika; lägg till det när din applikation behöver en funktion som det tillhandahåller. [9]
Kontrollera renderings- och bygginställningarna för Android
Vulkan är det grafikgränssnitt som används för att skicka renderingsarbete till GPU:n. Under Edit > Project Settings > Player väljer du Android > Other Settings. Om Auto Graphics API är aktiverat avmarkerar du det och placerar Vulkan först. För en enkel URP-grundkonfiguration inaktiverar du HDR i URP-tillgången och efterbehandling (post-processing) i dess renderer-tillgång. Google rekommenderar dessa inställningar för Android XR. [5]
I samma Player-inställningar anger du en unik paketidentifierare, till exempel com.yourcompany.aurapilot. Under Configuration väljer du IL2CPP och ARM64 för builden till den fysiska enheten. IL2CPP omvandlar C#-kod till inbyggd kod; ARM64 är den processorarkitektur som builden riktar sig mot. Kontrollera valideringen för de installerade paketen och enhetskraven för eventuella ytterligare begränsningar.
Google anger API 24 som minimikrav för OpenXR-laddaren, inte som Auras operativsystemversion. Använd en lägsta API-nivå som även uppfyller kraven för alla installerade paket, och en installerad mål-SDK som stöds av din redigerare och dina distributionskrav. Konfigurera GameActivity som applikationens startpunkt, avmarkera Activity och aktivera Resizable Activity under Resolution and Presentation enligt Googles anvisningar. [5]
Väg B – Konfigurera utvecklingsmiljön i Android Studio
Den här vägen installerar Android Studio, hämtar Androids utvecklingsverktyg och skapar ett XR-projekt utifrån Googles mall. Den förbereder den inbyggda Android-arbetsytan för senare applikationsutveckling. Du kan också skapa en emulator för att kontrollera att projektet byggs och startar.
Översikt över konfigurationen: installera Android Studio → hämta Android-verktygen → skapa ett XR-projekt → kontrollera beroenden → förbered ett testmål.Android Studio är Googles utvecklingsmiljö för Android-applikationer. Kotlin är det programmeringsspråk som används här. Jetpack XR SDK tillhandahåller bibliotek för inbyggt rumsligt användargränssnitt och XR, medan Jetpack Compose beskriver gränssnitt i Kotlin-kod.
Steg 1 | Installera den XR-kompatibla redigeraren
Den rekommenderade versionen av Android Studio innehåller de XR-verktyg och mallar som används i den här vägen.
Ladda ned den version av Android Studio som rekommenderas på Googles konfigurationssida för XR. Nuvarande riktlinjer rekommenderar den senaste Canary-versionen; installera den vid behov parallellt med din vanliga stabila version. Canary innebär en tidig utvecklingsversion, så dokumentera exakt vilken version ditt team använder. [10]
Steg 2 | Hämta Androids utvecklingsverktyg
SDK Manager installerar de komponenter som behövs för att bygga, köra och inspektera din applikation.
På välkomstskärmen öppnar du More Actions > SDK Manager. Under SDK Tools installerar eller uppdaterar du Android SDK Build-Tools, Android Emulator och Android SDK Platform-Tools, samt den version av Layout Inspector som anges i Googles aktuella instruktioner. Klicka på Apply och godkänn licenserna. [10]
Steg 3 | Skapa XR-projektet
En XR-mall ger en startapplikation där den rumsliga strukturen redan finns på plats.
Öppna New Project. Välj XR i mallistan och sedan den immersiva mallen för XR-headset eller trådbundna XR-glasögon. Välj inte en mall för ljudglasögon eller displayglasögon. Klicka på Next, ge projektet namnet AuraBusinessPanel, ange ett paketnamn för företaget om det erbjuds, välj en mapp att spara i och klicka på Finish. [11]
Steg 4 | Låt projektet hämta beroenden
Gradle sync förbereder biblioteken och byggkonfigurationen innan du redigerar applikationen.
Vänta tills Gradle sync är klar. Gradle är byggsystemet som hämtar beroenden och kompilerar appen. Öppna panelen Project och leta upp app/build.gradle.kts, eller Gradle-filen för app-modulen. Behåll mallens inbördes kompatibla versioner; uppgradera inte ett enskilt XR-bibliotek på måfå.
Steg 5 | Kontrollera kraven på Android-API
API-inställningarna måste uppfylla kraven för mallen och för alla bibliotek du använder.
Jämför konfigurationssidan för Jetpack XR SDK med din mall. Den publicerade baslinjen är minSdk 24 och compileSdk 34 eller högre; använd högre värden när dina valda bibliotek eller din mall kräver det. compileSdk är det Android-API som används vid kompilering, medan minSdk anger det äldsta Android-API som stöds. [12]
Konfigurationssidan för SDK:t listar beroenden för Runtime, SceneCore, Compose for XR, Material Design for XR och ARCore for Jetpack XR. Lägg bara till det som applikationen använder. SceneCore hanterar rumsligt innehåll; ARCore for Jetpack XR tillhandahåller perceptionsfunktioner som stöds. Förhandsversioner kan ändras, så använd mallen och versionsanteckningarna tillsammans i stället för att klistra in ett gammalt beroendeblock.
Om din mall inte automatiskt innehåller de grundläggande XR-biblioteken ser du till att din app/build.gradle.kts innehåller följande grundberoenden:
android {
compileSdk = 34 // eller det högre värde som din mall anger
defaultConfig {
minSdk = 24
}
}
dependencies {
// Kärnberoenden för Jetpack XR SDK
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")
}
Vid tidpunkten för researchen kräver Compose for XR 1.0.0-beta02 (21-10-2026) Kotlin 2.2, och enligt versionsinformationen är det beroende av SceneCore 1.0.0-rc01, som har en känd minnesläcka; lösningen är att själv deklarera SceneCore 1.0.0 eller senare, vilket beroendeblocket ovan redan gör. Detta är ett skäl till att dokumentera hela uppsättningen beroenden i stället för att beskriva en installation av senaste version som produktionsklar. [13]
Kör på en XR-emulator innan maskinvaran finns tillgänglig
Steg 1 | Skapa en virtuell XR-enhet
Med emulatorn kan du kontrollera programvaran innan en fysisk Aura-enhet finns tillgänglig.
Öppna Tools > Device Manager och sedan Add a new device > Create Virtual Device. Välj XR som formfaktor och välj XR Glasses för arbetsflödet med trådbundna glasögon. [4]
Steg 2 | Installera den nödvändiga systemavbildningen
Systemavbildningen tillhandahåller Android XR-operativmiljön för den virtuella enheten.
Välj den förhandsversion av systemavbildningen som Googles guide kräver för XR Glasses, ladda ned den om du uppmanas till det och slutför skapandet av den virtuella enheten. Starta den från Device Manager.
Steg 3 | Kör applikationen
Android Studio bygger projektet och installerar det på den valda virtuella enheten.
I Android Studios övre verktygsfält väljer du app-körkonfigurationen och den virtuella XR-enhet som är igång. Klicka på Run. Låt Android Studio bygga och installera den oförändrade mallen. Du behöver inte anpassa dess gränssnitt för den här miljökontrollen.
Steg 4 | Kontrollera resultatet
En lyckad build och start bekräftar att de installerade verktygen kan hantera mallen.
Kontrollera att mallen öppnas utan bygg- eller startfel. Detta validerar den grundläggande programvarukonfigurationen, inte Auras optik, fysisk spårning, prestanda eller produktionsberedskap.
Anslut XREAL Aura till utvecklingsdatorn
ADB, förkortning för Android Debug Bridge, gör att en utvecklingsdator kan installera applikationer och läsa diagnostikloggar från en Android-enhet. Både Unity och Android Studio kan använda det.
Enligt XREAL:s vanliga frågor om Aura har båda USB-C-portarna på beräkningspucken stöd för standardfelsökning via ADB med Android Studio, men specifikationstabellen anger fullt ADB-stöd endast för glasögonporten (Glasses Port), så fokusera på den porten om möjligt. Håll glasögonen anslutna enligt anvisningarna. DisplayPort-spegling och en behörig ADB-anslutning är olika funktioner, så en synlig skärm från den bärbara datorn i glasögonen bevisar inte att utvecklingsanslutningen fungerar.
Steg 1 | Aktivera behörig felsökning
Felsökning gör att din utvecklingsdator kan installera och inspektera testapplikationer.
Öppna Settings i Android XR-systemet och aktivera Developer options och USB debugging enligt instruktionerna för din firmware. I standard-Android visas Developer options ofta genom att man väljer Build number upprepade gånger, men den exakta menysökvägen i Aura kunde inte fastställas i de offentliga källor som granskades. Använd den medföljande introduktionsvägen om den skiljer sig. [14]
Steg 2 | Anslut och auktorisera datorn
En USB-dataanslutning och godkännande på enheten krävs för det här arbetsflödet för trådbunden felsökning.
Anslut värddatorn med en USB-datakabel via den dokumenterade utvecklingsporten. Godkänn datorns begäran om felsökningsbehörighet på enheten. I Windows installerar du tillverkarens ADB-drivrutin om systemet kräver det. [14]
Steg 3 | Kontrollera att ADB ser enheten
Enhetslistan bekräftar att anslutningen är redo innan du försöker bygga och köra.
I Android Studio öppnar du SDK Manager och noterar Android SDK Location. I terminalen öppnar du det SDK:ts platform-tools-mapp och kör lämpligt kommando nedan.
# Windows PowerShell, i platform-tools
.\adb.exe devices -l
# macOS eller Linux, i platform-tools
./adb devices -l
Förväntat resultat: enhetens serienummer följs av device. Om det står unauthorized godkänner du uppmaningen. Om listan är tom kontrollerar du kabeln, värdporten, felsökningsinställningen och drivrutinen. Om mer än en enhet eller emulator är ansluten väljer du det avsedda målet uttryckligen.
Bekräfta att din utvecklingsmiljö är redo
Kontroller för Unity
Steg 1 | Kontrollera byggprofilen
Kontrollera konfigurationen innan du börjar utveckla applikationen.
Öppna File > Build Profiles och bekräfta att Android XR, eller den Android-profil som konfigurerats för XR, är aktiv. Bekräfta att de nödvändiga Android-byggmodulerna finns tillgängliga för den här redigeraren.
Steg 2 | Kontrollera paket och validering
Projektet måste ha de nödvändiga XR-paketen installerade och aktiverade.
I Package Manager kontrollerar du OpenXR Plugin och Unity OpenXR: Android XR. I Project Settings > XR Plug-in Management bekräftar du Android OpenXR-providern och funktionsgruppen Android XR. Åtgärda obligatoriska problem under Project Validation.
Steg 3 | Kontrollera målenheten
En identifierad enhet slutför anslutningsdelen av konfigurationen.
I Build Profiles uppdaterar du Run Device och kontrollerar att din behöriga Aura-enhet visas. Om den inte gör det kontrollerar du ADB-anslutningen och sökvägarna under Unitys External Tools. Du kan konfigurera projektet innan maskinvaran finns tillgänglig, men validering av fysisk driftsättning måste vänta tills du har en enhet.
Kontroller för Android Studio
Bekräfta att Gradle sync slutförs utan fel, att SDK Manager har de nödvändiga verktygen installerade och att XR-emulatorn eller den behöriga Aura-enheten visas i målväljaren. Kör den oförändrade XR-mallen om ett testmål finns tillgängligt. Öppna View > Tool Windows > Logcat för att granska startfel. Logcat visar Androids diagnostikmeddelanden.
Så fungerar Unity och Android Studio tillsammans
Unity kan bygga Android-applikationer med sina egna verktyg som stöds, så Android Studio krävs inte för att konfigurera ett Unity-projekt. Android Studio kan ändå vara till hjälp för emulatorhantering och Android-diagnostik som Logcat. Värt att framhålla är att AndroidXR-emulatorn inte stöder simulering av appar som byggts med Unity, Godot, Unreal Engine eller OpenXR, så Unity-builds kräver en fysisk Aura. För en inbyggd Kotlin-applikation är Android Studio din huvudsakliga arbetsyta och Unity behövs inte.
För senare anpassning av Android-builden kan Unity exportera ett Gradle-projekt till Android Studio. Det steget behövs inte vid den första konfigurationen. Behåll Unitys egna byggverktyg som stöds valda, såvida inte din integration specifikt kräver ett exportarbetsflöde.
Felsökning vid första konfigurationen
- Byggmålet Android är inte tillgängligt: Lägg till Android Build Support i exakt den Unity-redigerarinstallation du använder
- Gruppen Android XR saknas: Kontrollera paketidentifieraren, kompatibiliteten och fliken för Android-målet
- Gradle sync misslyckas: Läs det första byggfelet; kontrollera SDK-installationen och att beroendeversionerna matchar varandra
- Nödvändiga paket eller funktioner saknas: Kontrollera Package Manager, det aktiva Android-målet och funktionsgruppen Android XR
- Project Validation visar fel: Gå igenom varje obligatoriskt problem och tillämpa åtgärden för din installerade paketversion
- Enheten är inte auktoriserad (unauthorized): Godkänn felsökningsuppmaningen på enheten
- Installationen misslyckas på emulatorn: Kontrollera att APK:ns arkitektur matchar emulatorns systemavbildning
Slutsats
Att konfigurera en utvecklingsmiljö för XREAL Aura innebär att installera kompatibla verktyg, förbereda ett Android XR-projekt, aktivera rätt plattformsstöd och kontrollera enhetsanslutningen. Unity passar projekt som ska använda interaktivt 3D-innehåll, medan Android Studio passar inbyggda Android-gränssnitt. En tydlig och repeterbar konfiguration hjälper företag att minska konfigurationsproblemen och ger utvecklare en pålitlig grund för att bygga och testa applikationer.
Planerar du utveckling för XREAL Aura? Diskutera tillgång till maskinvara, programvarukrav och stöd vid utrullning med VR Expert.
Utforska XR-maskinvara och support för företag på: https://ai.vr-expert.com/

























