Създаване на първото ви бизнес приложение за XREAL Aura с Android Studio

Създаване на първото ви бизнес приложение за XREAL Aura с Android Studio

Резюме

Това ръководство показва как да създадете бизнес приложение за XREAL Aura в Android Studio с Kotlin и Jetpack XR SDK. Ще създадете проект, ще добавите библиотеката за пространствен интерфейс, ще поставите кратък пример с панел за задачи и ще го стартирате в емулатора XR Glasses, преди да го тествате на хардуер Aura.

Примерът показва работни инструкции и позволява на потребителите да потвърждават всяка задача. Той е отправна точка за бизнес приложение – без постоянни записи на работата и без проверка дали дадена физическа задача действително е изпълнена. Кодът следва прегледаната документация, но не е компилиран, нито тестван на хардуер Aura.

Въведение

Създаването на бизнес приложение за XREAL Aura започва в Android Studio, където пишете код на Kotlin и използвате Jetpack XR SDK, за да добавите пространствен интерфейс. Това ръководство ви води от създаването на проект до стартирането му в емулатор и тестването му на Aura. Като прост пример ще изградите панел, който показва работни инструкции и позволява на потребителя да потвърждава всяка задача.

XREAL Aura съчетава кабелни очила с изчислителен модул (puck) с Android XR. Следвайте работния процес на Android XR за кабелни XR очила, а не отделния процес за аудио очила и очила с дисплей, които прожектират съдържание от телефон. За контекст относно хардуера вижте прегледа на XREAL Aura от VRX и официалната страница на Aura от XREAL. [1]

Преди да започнете

· Използвайте одобрен от компанията компютър с достъп до интернет за първоначалните изтегляния

· Проверете системните изисквания на Google за XR емулатора, които в момента обхващат поддържаните конфигурации на Windows и macOS [2]

· За физическо тестване се сдобийте с очила Aura, техния изчислителен модул и инструкциите за свързване за разработчици към комплекта

Наличност: Потвърдете регионалните доставки с VR Expert. Текущата страница на XREAL дава приоритет на САЩ, Канада, Япония и Южна Корея; по-старите списъци за резервации не бива да се приемат като потвърдена доставка в Европа. [1]

Стъпка 1 Инсталирайте Android Studio и SDK инструментите му

Започнете с инсталиране на Android Studio и SDK инструментите, с които се компилира приложението, стартира се симулирано XR устройство и се осъществява връзка с хардуера.

Google препоръчва Android Studio Canary за XR. Canary е предварителна версия с по-нови инструменти и възможно недовършени функции; можете да я инсталирате успоредно със съществуващата си инсталация на Android Studio.

· Отворете Android Studio Preview, изтеглете подходящия инсталатор и завършете съветника за инсталиране.

· На началния екран на Android Studio изберете More Actions > SDK Manager. Ако вече има отворен проект, използвайте Tools > SDK Manager в горното меню.

· В прозореца с настройки на SDK Manager намерете разделите SDK Platforms и SDK Tools над списъка с пакети за инсталиране. И двата раздела са част от един и същ прозорец на SDK Manager.

· Изберете SDK Tools. Отметнете Android SDK Build-Tools, Android Emulator и Android SDK Platform-Tools. Оставете ги избрани, ако вече са инсталирани; приложете наличните актуализации. Build-Tools подготвя инсталационния файл на приложението, Emulator стартира симулирани устройства, а Platform-Tools включва инструмента за връзка с устройства ADB.

· Щракнете върху Apply, прегледайте избраните изтегляния, приемете необходимите лицензи и изчакайте инсталацията. Щракнете върху OK, за да затворите прозореца.

Разделът SDK Platforms инсталира платформата на Android, с която се компилира приложението. Необходимата ѝ версия се определя от конфигурацията на проекта. Създайте проекта в стъпка 2, след което използвайте настройката му compileSdk, за да изберете съответната платформа. Стъпка 6 разглежда системния образ на XR емулатора, който осигурява операционната система за симулираното устройство.

Контролна точка: Трите SDK инструмента са инсталирани. Вече можете да създадете проекта. [3, 13]

Стъпка 2 Създайте проекта за бизнес приложението за XREAL Aura

Шаблонът за XR проект създава началните файлове и конфигурацията за компилиране на приложението. Следвайте инструкциите на Google за проекти с Android XR за инсталираната от вас версия на Studio. [4]

· В Android Studio > върнете се на началния екран и щракнете върху New Project или изберете File > New > New Project.

· Изберете XR в списъка с шаблони, след това шаблона за XR слушалки и кабелни XR очила. Страницата на Google за проекти вече не посочва имената на шаблоните (там пише да изберете шаблона, който съответства на типа XR устройство, за което разработвате), а имената може да се променят между версиите на Canary, затова вземете точното име от IDE за екранната снимка. Не избирайте шаблона за аудио очила или очила с дисплей, който създава изживяване, прожектирано от телефон.

· Щракнете върху Next. Въведете AuraTaskPanel в полето Name. В полето Package name въведете com.example.aurataskpanel за този урок. Изберете Kotlin, ако се появи избор на език. Стойността на package name идентифицира кода на приложението и може да се персонализира за вашата организация. В Android Studio се въвежда като идентификатор, разделен с точки, без https:// или път на уеб адрес.

След това запазете настройките за компилиране от генерирания шаблон и щракнете върху Finish. Изчакайте първата синхронизация с Gradle да завърши. При синхронизацията Android Studio прочита конфигурацията за компилиране и разрешава зависимостите ѝ.

Отворете View > Tool Windows > Project, след което изберете Android в селектора на изглед на панела. Ще използвате следните файлове:

· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Съдържа входната точка и интерфейса на приложението; в някои версии папката с изходния код е обозначена като java

· AndroidManifest.xml: app > manifests. Декларира входната точка, разрешенията и настройките за стартиране на приложението

· build.gradle.kts (Module :app): Gradle Scripts. Конфигурира компилирането и библиотеките на приложението

Инсталирайте платформата, която проектът ви изисква

Настройката compileSdk указва на Android Studio кой набор от API на Android да използва при компилиране на приложението. Инсталирайте съответната SDK платформа; не я избирайте само въз основа на марката на очилата.

· В панела Project на Android Studio отворете Gradle Scripts > build.gradle.kts (Module :app). В блока android намерете compileSdk. Стойност като compileSdk = 36 означава, че проектът се нуждае от Android API 36. Това число е пример, а не задължителна стойност за всеки проект за Aura.

· Ако стойността препраща към запис в каталога, например libs.versions.compileSdk, отворете Gradle Scripts > libs.versions.toml и прочетете посочената стойност. Ако шаблонът използва име на предварителна версия или вложена конфигурация на compileSdk, запазете тази настройка и използвайте съответстващата ѝ платформа.

· Отворете Tools > SDK Manager > SDK Platforms. Изберете реда, чиято стойност в колоната API Level съответства на настройката на проекта. Щракнете върху Apply, изчакайте изтеглянето да завърши, след което щракнете върху OK.

· Върнете се в проекта и изберете File > Sync Project with Gradle Files или Sync Now, ако лентата с известие предлага тази опция. Синхронизацията с Gradle прочита настройките за компилиране и изтегля необходимите за проекта библиотеки.

Запазете настройката за платформата от шаблона. Ако Android Studio съобщи за липсваща платформа, инсталирайте я, вместо да понижавате compileSdk, за да избегнете изтеглянето. Образът на XR устройството, използван за тестване, се избира отделно в стъпка 6. [13]

Контролна точка: Необходимата SDK платформа е инсталирана, а в прозореца Build или Sync няма неразрешени грешки.

Стъпка 3 Добавете XR библиотеката и проверете съвместимостта с Kotlin

Добавете Jetpack Compose for XR, за да осигурите на приложението компоненти за пространствени панели, и проверете съвместимостта с Kotlin, за да може проектът да компилира тази библиотека без грешки във версиите. Този пример използва XR Compose 1.0.0-beta02 (21-10-2026, все още най-новата версия), която изисква Kotlin 2.2 според бележките към версията на Google. Според същите бележки beta02 зависи от SceneCore 1.0.0-rc01, която има известен проблем с изтичане на памет, затова добавете implementation (“androidx.xr.scenecore:1.0.0”) или по-нова версия към реда за Compose в стъпка 3.

Проверете версията на Kotlin веднъж

· В Android Studio разгънете Gradle Scripts и отворете libs.versions.toml. Когато съществува, този файл е централният списък на проекта с версиите на библиотеките и плъгините.

· Под [versions] потърсете записа за Kotlin, обикновено kotlin = "2.2.0" или друга версия 2.2.x. Запазете съвместимата версия, предоставена от текущия шаблон.

· Ако проектът използва плъгина org.jetbrains.kotlin.plugin.compose, версията му трябва да съответства на тази на Kotlin. Шаблоните обикновено карат и двата да препращат към един и същ запис за версията на Kotlin; запазете тази връзка.

· Ако няма запис за Kotlin или каталог, проверете файла build.gradle.kts на най-горно ниво за изрично декларирани плъгини за Kotlin. Някои по-нови конфигурации за компилиране управляват Kotlin чрез инструментите за компилиране на Android. В такъв случай запазете генерираната конфигурация и проверете съвместимостта на инструментариума с Kotlin, ако се появи грешка при компилиране; не добавяйте втори плъгин за Kotlin само за да създадете запис за версия.

Ако шаблонът вече предоставя съвместими инструменти за Kotlin, не променяйте нищо. Ако при компилиране се съобщи, че версията на Kotlin е твърде стара за XR библиотеката, актуализирайте едновременно инструментите за Kotlin в проекта и съответния плъгин за компилатора на Compose, ако има такъв, като използвате поддържаната конфигурация за този шаблон. Избягвайте промени в несвързани настройки за компилиране.

Добавете зависимостта за пространствен интерфейс

· Отворете Gradle Scripts > build.gradle.kts (Module :app).

· Намерете съществуващия блок dependencies { ... }.

· Потърсете зависимост за XR Compose, записана директно или чрез псевдоним (alias), например implementation(libs.androidx.xr.compose). Ако вече има псевдоним, задайте посочената от него версия на XR Compose на 1.0.0-beta02 в libs.versions.toml. Не добавяйте една и съща библиотека два пъти.

· Ако XR Compose липсва, добавете този ред в съществуващия блок dependencies:

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

Запазете останалите зависимости от шаблона. По-специално кодът по-долу използва стандартната Material 3 – библиотеката, която осигурява бутоните, текста и темата му, както и Activity Compose, която хоства Compose съдържание в Android Activity.

Синхронизирайте и продължете

Щракнете върху Sync Now в лентата на редактора или изберете File > Sync Project with Gradle Files. Изчакайте процесът на изтегляне и конфигуриране да приключи.

Контролна точка: Синхронизацията завършва без грешки в зависимостите или в съвместимостта с Kotlin. Когато синхронизацията е успешна, запазете останалите генерирани настройки за компилиране и отворете MainActivity.kt, за да добавите интерфейса. Ако синхронизацията съобщи за грешка в зависимост, сравнете посочения компонент със страницата на Google за настройка на Jetpack XR SDK. [6]

Стъпка 4 Изградете панела със задачи на Kotlin

Интерфейсът показва текста на задачата с бутон Mark complete и бутон Restart demo. По-късно примерните инструкции могат да бъдат заменени с одобрена работна процедура.

В същия файл MainActivity.kt в Android Studio запазете реда package, ако пакетът ви е различен, след което заменете останалата част от файла с кода по-долу. Премахнете старите примерни функции и функциите за преглед (preview) на шаблона от този файл, така че да има само един MainActivity. Activity е входна точка в Android, която хоства интерфейс. Примерът по-долу включва Activity и нейните импорти.

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

Какво прави кодът

· steps съдържа текста на инструкциите

· completed брои потвържденията и не позволява преминаване отвъд последната задача

· rememberSaveable запазва тази малка стойност при поддържаното от Android пресъздаване на екрана и възстановяване на състоянието; това не е постоянно хранилище

· LocalSpatialCapabilities проверява дали е наличен пространствен потребителски интерфейс [7]

· Subspace създава област за пространствено съдържание, а SpatialPanel поставя интерфейса в нея [8]

· Резервният клон показва същото съдържание в обикновен прозорец, когато пространственият потребителски интерфейс не е наличен

Единицата dp мащабира размерите на оформлението спрямо плътността на екрана; sp мащабира текста и зачита предпочитанията за размер на шрифта. Контейнерът с превъртане поддържа по-дългите инструкции достъпни. Приемете размера на панела като отправна точка и проверете четимостта на Aura.

Контролна точка: Android Studio разпознава импортите и не показва синтактични грешки в Kotlin. Ако инсталираната ви библиотека изисква изрично съгласие (opt-in) за експериментален API, използвайте точната анотация, посочена в диагностичното съобщение на компилатора, и проверете справочника за API на съответната версия.

Стъпка 5 Проверете как се стартира приложението в Android XR

Конфигурирайте режима на стартиране, така че Android XR да може да отвори приложението с пространственото оформление, използвано в този пример.

На очилата Aura Home Space и Full Space вече са вградени в Android XR и определят как се показват работещите приложения. Емулаторът XR Glasses предоставя тези режими за разработка, така че не е необходима отделна инсталация.

В панела Project на Android Studio > отворете app > manifests > AndroidManifest.xml и прегледайте записа за MainActivity. Запазете неговия intent filter за MAIN и LAUNCHER, настройката exported и генерираната тема. За управляван от Compose Full Space съответното свойство е показано по-долу. Ако шаблонът вече декларира свойство за стартиране на ниво application или Activity, редактирайте съответната съществуваща стойност, вместо да я дублирате. [9]

<!-- Inside the existing MainActivity element -->
<property
    android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
    android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />

Managed Full Space означава, че Android управлява пространствената сцена за Activity. Стойността UNMANAGED е предназначена за приложения, които рендират чрез OpenXR – междуплатформен XR интерфейс; този пример с Compose не я използва. Когато сравнявате шаблони, вижте справочника за константите в манифеста. [9]

В съществуващия елемент application също запазете или добавете android:enableOnBackInvokedCallback="true", за да може пространственият панел да получава събития за връщане назад, както е документирано в ръководството на Google за панелите; в неговия пример атрибутът е зададен на елемента activity, но е валиден и за елемента application. Не добавяйте разрешения за камера, микрофон или разпознаване на сцената за този статичен контролен списък. Той не сканира помещението и не разпознава обекти. [8]

Стъпка 6 Създайте емулатор на XR очила и стартирайте приложението

Стартирайте приложението на симулирано устройство с XR очила, преди да свържете Aura. Емулаторът симулира устройство на компютъра ви; AVD е неговата запазена конфигурация.

· В Android Studio > отворете Tools > Device Manager. Щракнете върху контролата за добавяне на устройство и изберете Create Virtual Device.

· Под Form Factor изберете XR, след това XR Glasses. Щракнете върху Next.

· Изберете системния образ Preview API, необходим за профила XR Glasses, и го изтеглете, ако бъдете подканени. Изберете поддържаната архитектура на образа според компютъра си. Завършете конфигурирането.

· Стартирайте AVD с бутона за пускане. Изчакайте средата на Android XR да се зареди напълно.

· В горната лента с инструменти на Android Studio изберете конфигурацията за стартиране на приложението и работещото устройство XR Glasses. Щракнете върху Run – зеления триъгълник.

Емулаторът инсталира и отваря приложението. Използвайте неговите контроли за въвеждане, за да активирате Mark complete. Ако панелът остане в Home Space, проверете манифеста и контролите за Full Space в средата, преди да променяте оформлението в Kotlin. Вижте официалните инструкции за AVD.

Изпълнете тази проверка за приемане:

· Първият екран показва нула от три потвърдени задачи и първата инструкция

· Всяко активиране на Mark complete придвижва напред точно с една инструкция

· Третото активиране показва Checklist complete и деактивира Mark complete

· Restart demo възстановява първата инструкция и нула потвърждения

· По-дългият текст остава достъпен чрез превъртане

· Съдържанието продължава да се показва, когато пространственият потребителски интерфейс не е наличен

Успешният тест в емулатора валидира част от логиката и оформлението на приложението. Той не валидира оптиката на Aura, надеждността на въвеждането или пригодността за работната среда.

Стъпка 7 Внедрете на оторизиран хардуер Aura

Стъпките по-долу следват стандартния процес за дебъгване в Android. Менютата и опциите за свързване на Aura може да се различават в зависимост от версията на софтуера, затова там, където има разлики, следвайте инструкциите за конкретния комплект.

Свържете Aura и стартирайте приложението

· Стартирайте Aura със свързани очила и отворете Settings – приложението за настройки

· На Aura > в интерфейса за настройки > активирайте Developer options и дебъгването според инструкциите за комплекта; ако тези контроли не са налични, сдобийте се с ръководството за настройка за разработчици

· Свържете компютъра към порта за зареждане (Charging Port, отляво) на изчислителния модул с USB кабел за данни и оставете очилата свързани към порта за очила (Glasses Port, отдясно); ако това не проработи, включете кабела в десния порт за пълна поддръжка на ADB.

· Приемете подканата на устройството за разрешаване на дебъгването; управлявано устройство може да изисква одобрение от администратор

· В горната лента с инструменти на Android Studio изберете Aura в падащото меню с устройства и щракнете върху Run

· На Aura повторете проверките на панела със задачи от стъпка 6, включително преминаването между задачите и рестартирането на контролния списък

Отстраняване на проблеми с връзката с устройството

Ако Aura не се показва в селектора на целеви устройства в Android Studio, проверете връзката чрез ADB:

  1. Отворете View > Tool Windows > Terminal в Android Studio.
  1. Изпълнете следната команда:
adb devices -l

Проверете резултата:

· Ако устройството ви е посочено със статус device, то е свързано и оторизирано.

· Ако се показва unauthorized, сложете очилата и приемете подканата за USB дебъгване на екрана.

· Ако списъкът е празен, проверете отново USB кабела за данни, уверете се, че изчислителният модул е включен, и потвърдете, че USB дебъгването все още е активирано в Settings.

Заключение

Създаването на първо бизнес приложение за XREAL Aura започва с Android Studio, Kotlin и Jetpack XR SDK и преминава от прост панел с работни инструкции към тестване в емулатор и внедряване на оторизиран хардуер. Този подход дава на бизнеса целенасочен начин да прецени дали пространствените инструкции подобряват реален работен процес, преди да инвестира в интеграции и внедряване в целия парк от устройства. След като панелът стане четим, използваем и валидиран на Aura, следващата стъпка е одобрените процедури и надеждните записи на работата да се свържат със системите на компанията.

Обърнете се към VR Expert относно наличността на Aura и изискванията за хардуер, разработка на софтуер и поддръжка за вашия бизнес пилотен проект.

João Noronha

Написано от

João Noronha

Специалист по XR и имерсивно съдържание във VR Expert

João Noronha е специалист по XR и имерсивно съдържание във VR Expert, с силен интерес към нововъзникващите технологии и тяхното практическо приложение в реалния свят. Той се фокусира върху превръщането на сложните разработки в областта на VR, AR, AI очила и имерсивните технологии в ясно и практично съдържание за компании и специалисти, които проучват индустрията на XR.

Често задавани въпроси

Тази статия

Да. Започнете с емулатора Android XR Glasses, за да разработите интерфейса и последователността на задачите. Физическото тестване на Aura остава необходимо преди пилотен проект в работна среда.

Не. Android Studio, Kotlin и Jetpack Compose for XR са подходящи за този пример, насочен към интерфейса. Unity е отделен двигател за разработка, който може да е подходящ за проекти с обширно интерактивно 3D съдържание.

Не. То предоставя XR възможности. Екипът ви пак трябва да внедри и валидира изискванията за сигурност, съхранение на данни, идентичност, разпространение, поддръжка и интеграция.

Не. То показва локално съхранен текст и записва потвържденията в състоянието на потребителския интерфейс. Разпознаването на оборудване, разпознаването на сцената и проверените записи на работата изискват допълнително проектиране и внедряване.

Този пример не реализира постоянна физическа котва. Котвата е пространствена отправна точка, използвана за позициониране на съдържание спрямо дадено местоположение; разполагането спрямо конкретна машина изисква допълнителен поддържан процес за закотвяне и валидиране на самото устройство.