Streszczenie
Ten przewodnik pokazuje, jak utworzyć aplikację biznesową na XREAL Aura w Android Studio przy użyciu Kotlina i Jetpack XR SDK. Utworzysz projekt, dodasz bibliotekę interfejsu przestrzennego, wkleisz niewielki przykład panelu zadań i uruchomisz go w emulatorze XR Glasses, zanim przetestujesz go na sprzęcie Aura.
Przykład wyświetla instrukcje robocze i pozwala użytkownikom potwierdzać kolejne zadania. Stanowi punkt wyjścia do aplikacji biznesowej – bez trwałej rejestracji pracy ani weryfikacji, czy zadanie fizyczne zostało faktycznie wykonane. Kod jest zgodny z przeanalizowaną dokumentacją, ale nie został skompilowany ani przetestowany na sprzęcie Aura.
Wprowadzenie
Tworzenie aplikacji biznesowej na XREAL Aura zaczyna się w Android Studio, gdzie piszesz kod w Kotlinie i korzystasz z Jetpack XR SDK, aby dodać interfejs przestrzenny. Ten przewodnik prowadzi od utworzenia projektu, przez uruchomienie go w emulatorze, po testy na Aura. Jako prosty przykład zbudujesz panel, który wyświetla instrukcje robocze i pozwala użytkownikowi potwierdzać kolejne zadania.
XREAL Aura łączy przewodowe okulary z jednostką obliczeniową (tzw. puckiem) z systemem Android XR. Postępuj zgodnie ze ścieżką Android XR dla przewodowych okularów XR, a nie z osobną ścieżką dla okularów audio i z wyświetlaczem, w których obraz jest projektowany z telefonu. Informacje o sprzęcie znajdziesz w omówieniu XREAL Aura od VRX oraz na oficjalnej stronie Aura firmy XREAL. [1]
Zanim zaczniesz
· Do pierwszego pobierania plików użyj zatwierdzonego przez firmę komputera z dostępem do internetu
· Sprawdź opublikowane przez Google wymagania systemowe emulatora XR, które obecnie obejmują obsługiwane konfiguracje systemów Windows i macOS [2]
· Do testów fizycznych zdobądź okulary Aura, ich jednostkę obliczeniową oraz dołączone do zestawu instrukcje podłączania w trybie deweloperskim
Dostępność: Potwierdź dostępność w swoim regionie w VR Expert. Obecna strona XREAL stawia na pierwszym miejscu USA, Kanadę, Japonię i Koreę Południową; starszych list rezerwacyjnych nie należy traktować jako potwierdzenia dostaw do Europy. [1]
Krok 1. Zainstaluj Android Studio i narzędzia SDK
Zacznij od zainstalowania Android Studio oraz narzędzi SDK służących do budowania aplikacji, uruchamiania symulowanego urządzenia XR i łączenia się ze sprzętem.
Google zaleca do pracy z XR wersję Android Studio Canary. Canary to wydanie podglądowe z nowszymi narzędziami i potencjalnie niedokończonymi funkcjami; można je zainstalować obok dotychczasowego Android Studio.
· Otwórz stronę Android Studio Preview, pobierz odpowiedni instalator i przejdź przez kreator instalacji.
· Na ekranie powitalnym Android Studio wybierz More Actions > SDK Manager. Jeśli projekt jest już otwarty, użyj opcji Tools > SDK Manager w górnym menu.
· W oknie ustawień SDK Manager znajdź karty SDK Platforms i SDK Tools nad listą pakietów do zainstalowania. Obie karty należą do tego samego okna SDK Manager.
· Wybierz kartę SDK Tools. Zaznacz Android SDK Build-Tools, Android Emulator i Android SDK Platform-Tools. Jeśli są już zainstalowane, pozostaw je zaznaczone; zainstaluj dostępne aktualizacje. Build-Tools przygotowuje plik instalacyjny aplikacji, Emulator uruchamia symulowane urządzenia, a Platform-Tools zawiera narzędzie ADB do łączenia się z urządzeniami.
· Kliknij Apply, przejrzyj wybrane pliki do pobrania, zaakceptuj wymagane licencje i poczekaj na zakończenie instalacji. Kliknij OK, aby zamknąć okno.
Karta SDK Platforms służy do instalowania platformy Androida używanej do kompilacji aplikacji. Wymagana wersja wynika z konfiguracji projektu. Utwórz projekt w kroku 2, a następnie na podstawie jego ustawienia compileSdk wybierz odpowiednią platformę. Krok 6 dotyczy obrazu systemu emulatora XR, który dostarcza system operacyjny dla symulowanego urządzenia.
Punkt kontrolny: Trzy narzędzia SDK są zainstalowane. Możesz teraz utworzyć projekt. [3, 13]
Krok 2. Utwórz projekt aplikacji biznesowej na XREAL Aura
Szablon projektu XR tworzy początkowe pliki aplikacji i konfigurację kompilacji. Postępuj zgodnie z instrukcjami Google dotyczącymi projektów Android XR właściwymi dla zainstalowanej wersji Studio. [4]
· W Android Studio wróć do ekranu powitalnego i kliknij New Project albo wybierz File > New > New Project.
· Na liście szablonów wybierz XR, a następnie szablon dla gogli XR i przewodowych okularów XR. Strona projektu Google nie podaje już nazw szablonów (zaleca wybór szablonu odpowiadającego typowi urządzenia XR, dla którego tworzysz aplikację), a nazwy mogą się zmieniać między wydaniami Canary, więc dokładną nazwę na potrzeby zrzutu ekranu odczytaj z IDE. Nie wybieraj szablonu dla okularów audio i z wyświetlaczem, który tworzy doświadczenie projektowane z telefonu.
· Kliknij Next. Wpisz AuraTaskPanel w polu Name. W polu Package name wpisz com.example.aurataskpanel na potrzeby tego samouczka. Jeśli pojawi się wybór języka, wybierz Kotlin. Nazwa pakietu (package name) identyfikuje kod aplikacji i można ją dostosować do swojej organizacji. W Android Studio wpisuje się ją jako identyfikator rozdzielony kropkami, bez https:// ani ścieżki adresu internetowego.
Następnie pozostaw ustawienia kompilacji wygenerowane przez szablon i kliknij Finish. Poczekaj na zakończenie pierwszej synchronizacji Gradle. Podczas synchronizacji Android Studio odczytuje konfigurację kompilacji i rozwiązuje jej zależności.
Otwórz View > Tool Windows > Project, a następnie w selektorze widoku panelu wybierz Android. Będziesz korzystać z następujących plików:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Zawiera punkt wejścia i interfejs aplikacji; w niektórych wersjach folder źródłowy nosi nazwę java
· AndroidManifest.xml: app > manifests. Deklaruje punkt wejścia aplikacji, uprawnienia i ustawienia uruchamiania
· build.gradle.kts (Module :app): Gradle Scripts. Konfiguruje kompilację i biblioteki aplikacji
Zainstaluj platformę wymaganą przez projekt
Ustawienie compileSdk informuje Android Studio, którego zestawu API Androida użyć podczas kompilacji aplikacji. Zainstaluj odpowiadającą mu platformę SDK; nie wybieraj jej wyłącznie na podstawie marki okularów.
· W panelu Project w Android Studio otwórz Gradle Scripts > build.gradle.kts (Module :app). W bloku android znajdź compileSdk. Wartość taka jak compileSdk = 36 oznacza, że projekt wymaga Android API 36. Ta liczba jest przykładem, a nie wartością wymaganą w każdym projekcie Aura.
· Jeśli wartość odwołuje się do wpisu w katalogu, np. libs.versions.compileSdk, otwórz Gradle Scripts > libs.versions.toml i odczytaj wskazaną wartość. Jeśli szablon używa nazwy wersji podglądowej lub zagnieżdżonej konfiguracji compileSdk, zachowaj to ustawienie i użyj odpowiadającej mu platformy.
· Otwórz Tools > SDK Manager > SDK Platforms. Zaznacz wiersz, w którym wartość API Level odpowiada ustawieniu projektu. Kliknij Apply, dokończ pobieranie, a następnie kliknij OK.
· Wróć do projektu i wybierz File > Sync Project with Gradle Files lub Sync Now, jeśli pojawi się baner z tą opcją. Synchronizacja Gradle odczytuje ustawienia kompilacji i pobiera biblioteki wymagane przez projekt.
Zachowaj ustawienie platformy z szablonu. Jeśli Android Studio zgłosi brak platformy, zainstaluj ją, zamiast obniżać compileSdk, by uniknąć pobierania. Obraz urządzenia XR używany do testów wybiera się osobno w kroku 6. [13]
Punkt kontrolny: Wymagana platforma SDK jest zainstalowana, a okno narzędzia Build lub Sync nie zawiera nierozwiązanych błędów.
Krok 3. Dodaj bibliotekę XR i sprawdź zgodność Kotlina
Dodaj Jetpack Compose for XR, aby udostępnić aplikacji komponenty paneli przestrzennych, i sprawdź zgodność Kotlina, aby projekt mógł skompilować tę bibliotekę bez błędów wersji. W tym przykładzie użyto XR Compose 1.0.0-beta02 (21-10-2026, nadal najnowsze wydanie), które według informacji o wydaniu Google wymaga Kotlina 2.2. Te same informacje podają, że beta02 zależy od SceneCore 1.0.0-rc01, w którym występuje znany wyciek pamięci, dlatego do linii Compose w kroku 3 dodaj implementation (“androidx.xr.scenecore:1.0.0”) lub nowszą wersję.
Jednorazowo sprawdź wersję Kotlina
· W Android Studio rozwiń Gradle Scripts, a następnie kliknij, aby otworzyć libs.versions.toml. Ten plik, jeśli istnieje, stanowi centralną listę wersji bibliotek i wtyczek projektu.
· W sekcji [versions] poszukaj wpisu Kotlina, zwykle kotlin = "2.2.0" lub innej wersji 2.2.x. Zachowaj zgodną wersję dostarczoną przez bieżący szablon.
· Jeśli projekt używa wtyczki org.jetbrains.kotlin.plugin.compose, jej wersja musi odpowiadać wersji Kotlina. Szablony zwykle odwołują się w obu przypadkach do tego samego wpisu wersji Kotlina; zachowaj to powiązanie.
· Jeśli nie ma wpisu Kotlina ani katalogu, sprawdź w głównym pliku .build.gradle.kts, czy jawnie zadeklarowano wtyczki Kotlina. Niektóre nowsze konfiguracje kompilacji zarządzają Kotlinem za pośrednictwem narzędzi kompilacji Androida. W takim przypadku zachowaj wygenerowaną konfigurację i – jeśli pojawi się błąd kompilacji – sprawdź zgodność Kotlina z łańcuchem narzędzi; nie dodawaj drugiej wtyczki Kotlina tylko po to, by utworzyć wpis wersji.
Jeśli szablon zawiera już zgodne narzędzia Kotlina, niczego nie zmieniaj. Jeśli kompilacja zgłosi, że Kotlin jest zbyt stary dla biblioteki XR, zaktualizuj narzędzia Kotlina w projekcie razem z odpowiadającą im wtyczką kompilatora Compose, korzystając z konfiguracji obsługiwanej przez dany szablon. Unikaj zmieniania niepowiązanych ustawień kompilacji.
Dodaj zależność interfejsu przestrzennego
· Otwórz Gradle Scripts > build.gradle.kts (Module :app).
· Znajdź istniejący blok dependencies { ... }.
· Poszukaj zależności XR Compose zapisanej bezpośrednio lub za pomocą aliasu, np. implementation(libs.androidx.xr.compose). Jeśli alias już istnieje, ustaw wskazywaną przez niego wersję XR Compose na 1.0.0-beta02 w pliku libs.versions.toml. Nie dodawaj tej samej biblioteki dwukrotnie.
· Jeśli brakuje XR Compose, dodaj ten wiersz wewnątrz istniejącego bloku dependencies:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Zachowaj pozostałe zależności z szablonu. W szczególności poniższy kod korzysta ze standardowej biblioteki Material 3, która dostarcza używane w nim przyciski, tekst i motyw, oraz z biblioteki Activity Compose, która osadza zawartość Compose w aktywności Androida (Activity).
Synchronizuj i kontynuuj
Kliknij Sync Now na banerze edytora lub wybierz File > Sync Project with Gradle Files. Poczekaj na zakończenie pobierania i konfiguracji.
Punkt kontrolny: Synchronizacja kończy się bez błędów zależności ani zgodności Kotlina. Jeśli synchronizacja się powiedzie, zachowaj pozostałe wygenerowane ustawienia kompilacji, a następnie otwórz MainActivity.kt, aby dodać interfejs. Jeśli synchronizacja zgłosi błąd zależności, porównaj wskazany komponent z informacjami na stronie konfiguracji Jetpack XR SDK od Google. [6]
Krok 4. Zbuduj panel zadań w Kotlinie
Interfejs wyświetla treść zadania wraz z przyciskiem Mark complete oraz przyciskiem Restart demo. Przykładowe instrukcje można później zastąpić zatwierdzoną procedurą stanowiskową.
W tym samym pliku MainActivity.kt w Android Studio zachowaj wiersz package, jeśli Twój pakiet jest inny, a resztę pliku zastąp poniższym kodem. Usuń z tego pliku stare przykładowe funkcje i funkcje podglądu z szablonu, tak aby istniała tylko jedna klasa MainActivity. Activity (aktywność) to punkt wejścia Androida, który hostuje interfejs. Poniższy przykład zawiera aktywność wraz z importami.
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)
}
}
}
}Co robi ten kod
· steps przechowuje treść instrukcji
· completed zlicza potwierdzenia i uniemożliwia przejście dalej po ostatnim zadaniu
· rememberSaveable zachowuje tę niewielką wartość podczas obsługiwanego przez Androida odtwarzania ekranu i przywracania stanu; nie jest to trwały zapis
· LocalSpatialCapabilities sprawdza, czy interfejs przestrzenny jest dostępny [7]
· Subspace tworzy obszar dla treści przestrzennych, a SpatialPanel umieszcza w nim interfejs [8]
· Gałąź awaryjna wyświetla tę samą zawartość w zwykłym oknie, gdy interfejs przestrzenny jest niedostępny
Jednostka dp skaluje wymiary układu zależnie od gęstości ekranu; sp skaluje tekst i uwzględnia preferencje rozmiaru czcionki. Kontener przewijania zapewnia dostęp do dłuższych instrukcji. Traktuj rozmiar panelu jako punkt wyjścia i sprawdź czytelność na Aura.
Punkt kontrolny: Android Studio rozpoznaje importy i nie pokazuje błędów składni Kotlina. Jeśli zainstalowana biblioteka wymaga wyrażenia zgody na użycie eksperymentalnego API (opt-in), użyj dokładnie tej adnotacji, którą wskazuje komunikat diagnostyczny kompilatora, i sprawdź dokumentację API danego wydania.
Krok 5. Sprawdź, jak aplikacja uruchamia się w Android XR
Skonfiguruj tryb uruchamiania, aby Android XR mógł otworzyć aplikację z układem przestrzennym użytym w tym przykładzie.
W okularach Aura tryby Home Space i Full Space są już wbudowane w Android XR i określają, jak wyświetlane są uruchomione aplikacje. Emulator XR Glasses udostępnia te tryby na potrzeby programowania, więc nie trzeba niczego osobno instalować.
W panelu Project w Android Studio otwórz app > manifests > AndroidManifest.xml i sprawdź wpis MainActivity. Zachowaj jego filtr intencji MAIN i LAUNCHER, ustawienie exported oraz wygenerowany motyw. Właściwość odpowiednią dla trybu Full Space zarządzanego przez Compose przedstawiono poniżej. Jeśli szablon deklaruje już właściwość uruchamiania na poziomie aplikacji lub aktywności, edytuj odpowiednią istniejącą wartość zamiast ją duplikować. [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" />Zarządzany tryb Full Space oznacza, że Android zarządza sceną przestrzenną aktywności. Wartość UNMANAGED jest przeznaczona dla aplikacji renderujących za pomocą OpenXR – wieloplatformowego interfejsu XR; ten przykład w Compose jej nie używa. Porównując szablony, sprawdź dokumentację stałych manifestu. [9]
W istniejącym elemencie application zachowaj również lub dodaj android:enableOnBackInvokedCallback="true", aby panel przestrzenny otrzymywał zdarzenia cofania, jak opisano w przewodniku Google dotyczącym paneli; w tamtym przykładzie atrybut ustawiono w elemencie activity, ale jest on prawidłowy także w elemencie application. Nie dodawaj uprawnień do kamery, mikrofonu ani rozumienia sceny dla tej statycznej listy kontrolnej. Nie odczytuje ona otoczenia ani nie rozpoznaje obiektów. [8]
Krok 6. Utwórz emulator okularów XR i uruchom aplikację
Przed podłączeniem Aura uruchom aplikację na symulowanych okularach XR. Emulator symuluje urządzenie na komputerze; AVD to jego zapisana konfiguracja.
· W Android Studio otwórz Tools > Device Manager. Kliknij przycisk dodawania urządzenia i wybierz Create Virtual Device.
· W sekcji Form Factor wybierz XR, a następnie XR Glasses. Kliknij Next.
· Wybierz obraz systemu Preview API wymagany dla profilu XR Glasses i pobierz go, jeśli pojawi się monit. Dopasuj obsługiwaną architekturę obrazu do swojego komputera. Dokończ konfigurację.
· Uruchom AVD przyciskiem odtwarzania. Poczekaj, aż środowisko Android XR całkowicie się załaduje.
· Na górnym pasku narzędzi Android Studio wybierz konfigurację uruchamiania aplikacji i działające urządzenie XR Glasses. Kliknij Run (zielony trójkąt).
Emulator zainstaluje i otworzy aplikację. Użyj jego elementów sterujących, aby aktywować Mark complete. Jeśli panel pozostaje w trybie Home Space, przed zmianą układu w Kotlinie sprawdź manifest i ustawienia Full Space w środowisku. Zobacz oficjalne instrukcje dotyczące AVD.
Przeprowadź następujący test akceptacyjny:
· Pierwszy ekran pokazuje zero z trzech potwierdzonych zadań oraz pierwszą instrukcję
· Każde aktywowanie Mark complete przesuwa dokładnie o jedną instrukcję
· Trzecie aktywowanie wyświetla Checklist complete i wyłącza Mark complete
· Restart demo przywraca pierwszą instrukcję i zero potwierdzeń
· Dłuższy tekst pozostaje dostępny przez przewijanie
· Zawartość nadal się wyświetla, gdy interfejs przestrzenny jest niedostępny
Pomyślny test w emulatorze weryfikuje część logiki i układu aplikacji. Nie weryfikuje optyki Aura, niezawodności sterowania ani przydatności w miejscu pracy.
Krok 7. Wdróż aplikację na autoryzowanym sprzęcie Aura
Poniższe kroki opierają się na standardowym procesie debugowania w Androidzie. Menu i opcje połączenia Aura mogą się różnić w zależności od wersji oprogramowania, dlatego w razie rozbieżności postępuj zgodnie z instrukcjami dla danego zestawu.
Podłącz Aura i uruchom aplikację
· Uruchom Aura z podłączonymi okularami i otwórz aplikację Settings (Ustawienia)
· W interfejsie ustawień Aura włącz Developer options (Opcje programisty) oraz debugowanie zgodnie z instrukcjami zestawu; jeśli te opcje są niedostępne, zdobądź przewodnik konfiguracji deweloperskiej
· Podłącz komputer do portu ładowania (Charging Port, lewa strona) jednostki obliczeniowej za pomocą kabla USB do transmisji danych, a okulary pozostaw podłączone do portu okularów (Glasses Port, prawa strona). Jeśli to nie zadziała, podłącz kabel do portu po prawej stronie, aby uzyskać pełną obsługę ADB.
· Zaakceptuj na urządzeniu monit o autoryzację debugowania; urządzenie zarządzane może wymagać zgody administratora
· Na górnym pasku narzędzi Android Studio wybierz Aura z listy urządzeń i kliknij Run
· Na Aura powtórz testy panelu zadań z kroku 6, w tym przechodzenie między zadaniami i ponowne uruchamianie listy kontrolnej
Rozwiązywanie problemów z połączeniem urządzenia
Jeśli Aura nie pojawia się w selektorze urządzeń docelowych w Android Studio, sprawdź połączenie za pomocą ADB:
- Otwórz View > Tool Windows > Terminal w Android Studio.
- Uruchom następujące polecenie:
adb devices -lSprawdź wynik:
· Jeśli urządzenie jest widoczne ze statusem device, jest podłączone i autoryzowane.
· Jeśli widnieje status unauthorized, załóż okulary i zaakceptuj wyświetlony monit o zezwolenie na debugowanie USB.
· Jeśli lista jest pusta, ponownie sprawdź kabel USB do transmisji danych, upewnij się, że jednostka obliczeniowa jest włączona, i potwierdź, że debugowanie USB jest nadal włączone w ustawieniach.
Podsumowanie
Tworzenie pierwszej aplikacji biznesowej na XREAL Aura zaczyna się od Android Studio, Kotlina i Jetpack XR SDK, a następnie prowadzi od prostego panelu instrukcji roboczych do testów w emulatorze i wdrożenia na autoryzowanym sprzęcie. Takie podejście daje firmom ukierunkowany sposób oceny, czy instrukcje przestrzenne usprawniają rzeczywisty proces pracy, zanim zainwestują w integracje i wdrożenie na całą flotę urządzeń. Gdy panel okaże się czytelny i użyteczny oraz zostanie zweryfikowany na Aura, kolejnym krokiem jest połączenie zatwierdzonych procedur i wiarygodnej rejestracji pracy z systemami firmy.
Porozmawiaj z VR Expert o dostępności Aura oraz o wymaganiach dotyczących sprzętu, tworzenia oprogramowania i wsparcia w ramach pilotażu w Twojej firmie.

























