Creare la prima app aziendale per XREAL Aura con Android Studio

Creare la prima app aziendale per XREAL Aura con Android Studio

Sintesi

Questa guida spiega come creare un'app aziendale per XREAL Aura in Android Studio utilizzando Kotlin e Jetpack XR SDK. Creerai un progetto, aggiungerai la libreria per l'interfaccia spaziale, incollerai un piccolo esempio di pannello delle attività e lo eseguirai nell'emulatore XR Glasses prima di testarlo sull'hardware Aura.

L'esempio mostra istruzioni di lavoro e consente agli utenti di confermare ogni attività. È un punto di partenza per un'applicazione aziendale, senza registrazioni permanenti del lavoro né verifica dell'effettivo completamento di un'attività fisica. Il codice segue la documentazione esaminata, ma non è stato compilato né testato sull'hardware Aura.

Introduzione

La creazione di un'app aziendale per XREAL Aura parte da Android Studio, dove si scrive codice Kotlin e si usa Jetpack XR SDK per aggiungere un'interfaccia spaziale. Questa guida ti accompagna dalla creazione di un progetto alla sua esecuzione in un emulatore, fino al test su Aura. Come semplice esempio, realizzerai un pannello che mostra istruzioni di lavoro e consente all'utente di confermare ogni attività.

XREAL Aura abbina occhiali cablati a un'unità di calcolo (puck) Android XR. Segui il flusso di lavoro Android XR per gli occhiali XR cablati, non quello distinto per gli occhiali audio e display con proiezione dallo smartphone. Per informazioni sull'hardware, consulta la panoramica di XREAL Aura di VRX e la pagina ufficiale di Aura di XREAL. [1]

Prima di iniziare

· Usa un computer approvato dall'azienda con accesso a Internet per i download iniziali

· Verifica i requisiti di sistema dell'emulatore XR di Google, che attualmente riguardano configurazioni Windows e macOS supportate [2]

· Per i test fisici, procurati gli occhiali Aura, il relativo puck di calcolo e le istruzioni del kit per la connessione da sviluppatore

Disponibilità: verifica la fornitura nella tua regione con VR Expert. La pagina attuale di XREAL dà priorità a Stati Uniti, Canada, Giappone e Corea del Sud; le vecchie liste di prenotazione non vanno considerate come conferma di consegna in Europa. [1]

Passaggio 1: installare Android Studio e gli strumenti SDK

Inizia installando Android Studio e gli strumenti SDK necessari per compilare l'app, eseguire un dispositivo XR simulato e collegarti all'hardware.

Google consiglia Android Studio Canary per XR. Canary è un'edizione di anteprima con strumenti più recenti e funzionalità potenzialmente incomplete; puoi installarla accanto alla tua versione esistente di Android Studio.

· Apri Android Studio Preview, scarica il programma di installazione adatto e completa la procedura guidata.

· Nella schermata di benvenuto di Android Studio, seleziona More Actions > SDK Manager. Se è già aperto un progetto, usa Tools > SDK Manager nel menu in alto.

· Nella finestra delle impostazioni di SDK Manager, individua le schede SDK Platforms e SDK Tools, sopra l'elenco dei pacchetti installabili. Entrambe le schede fanno parte della stessa finestra di SDK Manager.

· Seleziona SDK Tools. Spunta Android SDK Build-Tools, Android Emulator e Android SDK Platform-Tools. Lasciali selezionati se sono già installati e applica gli aggiornamenti disponibili. Build-Tools prepara il file di installazione dell'app, Emulator esegue i dispositivi simulati e Platform-Tools include ADB, lo strumento per la connessione ai dispositivi.

· Fai clic su Apply, controlla i download selezionati, accetta le licenze richieste e attendi il termine dell'installazione. Fai clic su OK per chiudere la finestra.

La scheda SDK Platforms installa la piattaforma Android usata per compilare l'app. La versione richiesta dipende dalla configurazione del progetto. Crea il progetto nel passaggio 2, quindi usa la sua impostazione compileSdk per selezionare la piattaforma corrispondente. Il passaggio 6 tratta l'immagine di sistema dell'emulatore XR, che fornisce il sistema operativo del dispositivo simulato.

Verifica: i tre strumenti SDK sono installati. Ora puoi creare il progetto. [3, 13]

Passaggio 2: creare il progetto dell'app aziendale per XREAL Aura

Il modello di progetto XR crea i file iniziali dell'app e la configurazione di build. Segui le istruzioni di Google per i progetti Android XR relative alla versione di Studio installata. [4]

· In Android Studio, torna alla schermata di benvenuto e fai clic su New Project, oppure scegli File > New > New Project.

· Seleziona XR nell'elenco dei modelli, quindi il modello per visori XR e occhiali XR cablati. La pagina di Google sui progetti non indica più i nomi dei modelli (dice di scegliere il modello corrispondente al tipo di dispositivo XR per cui si vuole sviluppare) e i nomi possono cambiare da una release Canary all'altra, quindi ricava il nome esatto dall'IDE per lo screenshot. Non scegliere il modello per occhiali audio o display, che crea un'esperienza proiettata dallo smartphone.

· Fai clic su Next. Inserisci AuraTaskPanel in Name. In Package name, inserisci com.example.aurataskpanel per questo tutorial. Seleziona Kotlin se viene proposta la scelta del linguaggio. Il package name identifica il codice dell'app e può essere personalizzato per la tua organizzazione. In Android Studio si inserisce come identificatore separato da punti, senza https:// né percorso di un indirizzo web.

Quindi mantieni le impostazioni di build generate dal modello e fai clic su Finish. Attendi il completamento della prima sincronizzazione Gradle. La sincronizzazione fa sì che Android Studio legga la configurazione di build e risolva le dipendenze.

Apri View > Tool Windows > Project, quindi seleziona Android nel selettore di visualizzazione del riquadro. Userai questi file:

· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Contiene il punto di ingresso e l'interfaccia dell'app; in alcune versioni la cartella dei sorgenti si chiama java

· AndroidManifest.xml: app > manifests. Dichiara il punto di ingresso dell'app, le autorizzazioni e le impostazioni di avvio

· build.gradle.kts (Module :app): Gradle Scripts. Configura la build e le librerie dell'app

Installare la piattaforma richiesta dal progetto

L'impostazione compileSdk indica ad Android Studio quale set di API Android usare per compilare l'app. Installa la piattaforma SDK corrispondente; non sceglierne una basandoti solo sulla marca degli occhiali.

· Nel riquadro Project di Android Studio, apri Gradle Scripts > build.gradle.kts (Module :app). Nel blocco android, trova compileSdk. Un valore come compileSdk = 36 significa che il progetto richiede Android API 36. Questo numero è un esempio, non un valore obbligatorio per ogni progetto Aura.

· Se il valore rimanda a una voce del catalogo, come libs.versions.compileSdk, apri Gradle Scripts > libs.versions.toml e leggi il valore a cui fa riferimento. Se il modello usa un nome di anteprima o una configurazione compileSdk annidata, mantieni tale impostazione e usa la piattaforma corrispondente.

· Apri Tools > SDK Manager > SDK Platforms. Seleziona la riga in cui API Level corrisponde all'impostazione del progetto. Fai clic su Apply, completa il download, quindi fai clic su OK.

· Torna al progetto e seleziona File > Sync Project with Gradle Files, oppure Sync Now se compare in un banner. La sincronizzazione Gradle legge le impostazioni di build e scarica le librerie richieste dal progetto.

Mantieni l'impostazione della piattaforma del modello. Se Android Studio segnala una piattaforma mancante, installala invece di abbassare compileSdk per evitare il download. L'immagine del dispositivo XR usata per i test si seleziona separatamente nel passaggio 6. [13]

Verifica: la piattaforma SDK richiesta è installata e la finestra degli strumenti Build o Sync non contiene errori irrisolti.

Passaggio 3: aggiungere la libreria XR e verificare la compatibilità di Kotlin

Aggiungi Jetpack Compose for XR per fornire all'app i componenti dei pannelli spaziali e verifica la compatibilità di Kotlin, in modo che il progetto possa compilare la libreria senza errori di versione. Questo esempio usa XR Compose 1.0.0-beta02 (21-10-2026, ancora la release più recente), che secondo le note di rilascio di Google richiede Kotlin 2.2. Le stesse note indicano che beta02 dipende da SceneCore 1.0.0-rc01, che presenta una perdita di memoria nota, quindi aggiungi implementation (“androidx.xr.scenecore:1.0.0”) o una versione più recente alla riga di Compose nel passaggio 3.

Verificare una volta la versione di Kotlin

· In Android Studio, espandi Gradle Scripts, quindi fai clic per aprire libs.versions.toml. Questo file, se presente, è l'elenco centrale delle versioni di librerie e plugin del progetto.

· Sotto [versions], cerca la voce di Kotlin, di solito kotlin = "2.2.0" o un'altra versione 2.2.x. Mantieni la versione compatibile fornita dal modello attuale.

· Se il progetto usa il plugin org.jetbrains.kotlin.plugin.compose, la sua versione deve corrispondere a quella di Kotlin. In genere i modelli fanno riferire entrambi alla stessa voce di versione di Kotlin; mantieni questo collegamento.

· Se non c'è alcuna voce di Kotlin né un catalogo, controlla il file build.gradle.kts di primo livello alla ricerca di plugin Kotlin dichiarati esplicitamente. Alcune configurazioni di build più recenti gestiscono Kotlin tramite gli strumenti di build Android. In tal caso, mantieni la configurazione generata e verifica la compatibilità Kotlin della toolchain se compare un errore di build; non aggiungere un secondo plugin Kotlin solo per creare una voce di versione.

Se il modello fornisce già strumenti Kotlin compatibili, non modificare nulla. Se una build segnala che Kotlin è troppo vecchio per la libreria XR, aggiorna insieme gli strumenti Kotlin del progetto e l'eventuale plugin del compilatore Compose corrispondente, usando la configurazione supportata per quel modello. Evita di modificare impostazioni di build non correlate.

Aggiungere la dipendenza per l'interfaccia spaziale

· Apri Gradle Scripts > build.gradle.kts (Module :app).

· Trova il blocco esistente dependencies { ... }.

· Cerca una dipendenza XR Compose, scritta direttamente o tramite un alias come implementation(libs.androidx.xr.compose). Se esiste già un alias, imposta la versione di XR Compose a cui fa riferimento su 1.0.0-beta02 in libs.versions.toml. Non aggiungere due volte la stessa libreria.

· Se XR Compose non è presente, aggiungi questa riga all'interno del blocco dependencies esistente:

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

Mantieni le altre dipendenze del modello. In particolare, il codice seguente usa il normale Material 3, la libreria che fornisce pulsanti, testo e tema, e Activity Compose, che ospita i contenuti Compose in un'Activity Android.

Sincronizzare e proseguire

Fai clic su Sync Now nel banner dell'editor, oppure su File > Sync Project with Gradle Files. Attendi il termine del processo di download e configurazione.

Verifica: la sincronizzazione si completa senza errori di dipendenze o di compatibilità di Kotlin. Se la sincronizzazione riesce, mantieni le restanti impostazioni di build generate, quindi apri MainActivity.kt per aggiungere l'interfaccia. Se la sincronizzazione segnala un errore di dipendenza, confronta il componente indicato con la pagina di configurazione di Jetpack XR SDK di Google. [6]

Passaggio 4: creare il pannello delle attività in Kotlin

L'interfaccia mostra il testo dell'attività con un pulsante Mark complete e un pulsante Restart demo. Le istruzioni di esempio possono essere sostituite in seguito con una procedura aziendale approvata.

Nello stesso file MainActivity.kt di Android Studio, mantieni la riga package se il tuo pacchetto è diverso, quindi sostituisci il resto del file con il codice seguente. Rimuovi da questo file le vecchie funzioni di esempio e di anteprima del modello, in modo che ci sia una sola MainActivity. Un'Activity è un punto di ingresso Android che ospita un'interfaccia. L'esempio seguente include l'Activity e le relative importazioni.

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

Cosa fa il codice

· steps contiene il testo delle istruzioni

· completed conta le conferme e impedisce di andare oltre l'ultima attività

· rememberSaveable conserva questo piccolo valore durante la ricreazione della schermata e il ripristino dello stato supportati da Android; non è un'archiviazione permanente

· LocalSpatialCapabilities verifica se l'interfaccia utente spaziale è disponibile [7]

· Subspace crea un'area per i contenuti spaziali e SpatialPanel vi colloca l'interfaccia [8]

· Il ramo di fallback mostra gli stessi contenuti in una finestra normale quando l'interfaccia spaziale non è disponibile

L'unità dp adatta le dimensioni del layout alla densità dello schermo; sp adatta il testo e rispetta le preferenze sulla dimensione dei caratteri. Il contenitore scorrevole mantiene raggiungibili le istruzioni più lunghe. Considera le dimensioni del pannello come un punto di partenza e verifica la leggibilità su Aura.

Verifica: Android Studio riconosce le importazioni e non mostra errori di sintassi Kotlin. Se la libreria installata richiede l'opt-in a un'API sperimentale, usa esattamente l'annotazione indicata dalla diagnostica del compilatore e consulta il riferimento API di quella release.

Passaggio 5: verificare come si avvia l'app in Android XR

Configura la modalità di avvio in modo che Android XR possa aprire l'app con il layout spaziale usato in questo esempio.

Sugli occhiali Aura, Home Space e Full Space sono già integrati in Android XR e controllano il modo in cui appaiono le app in esecuzione. L'emulatore XR Glasses fornisce queste modalità per lo sviluppo, quindi non è necessaria alcuna installazione separata.

Nel riquadro Project di Android Studio, apri app > manifests > AndroidManifest.xml ed esamina la voce MainActivity. Mantieni il filtro intent MAIN e LAUNCHER, l'impostazione exported e il tema generato. Per la modalità Full Space gestita da Compose, la proprietà pertinente è riportata di seguito. Se il modello dichiara già una proprietà di avvio a livello di applicazione o di Activity, modifica il valore esistente pertinente invece di duplicarlo. [9]

<!-- All'interno dell'elemento MainActivity esistente -->
<property
    android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
    android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />

Managed Full Space significa che Android gestisce la scena spaziale per l'Activity. Il valore UNMANAGED è destinato alle app che eseguono il rendering tramite OpenXR, un'interfaccia XR multipiattaforma; questo esempio Compose non lo usa. Consulta il riferimento delle costanti del manifest quando confronti i modelli. [9]

Nell'elemento application esistente, mantieni o aggiungi anche android:enableOnBackInvokedCallback="true" affinché il pannello spaziale riceva gli eventi Indietro, come documentato nella guida di Google sui pannelli; il suo esempio lo imposta sull'elemento activity, ma è valido anche sull'elemento application. Non aggiungere autorizzazioni per fotocamera, microfono o comprensione della scena per questa checklist statica: non legge l'ambiente circostante né identifica oggetti. [8]

Passaggio 6: creare un emulatore di occhiali XR ed eseguire l'app

Esegui l'app su un dispositivo simulato di occhiali XR prima di collegare Aura. Un emulatore simula un dispositivo sul computer; un AVD è la sua configurazione salvata.

· In Android Studio, apri Tools > Device Manager. Fai clic sul comando per aggiungere un dispositivo e scegli Create Virtual Device.

· In Form Factor, scegli XR, quindi XR Glasses. Fai clic su Next.

· Seleziona l'immagine di sistema Preview API richiesta per il profilo XR Glasses e scaricala se richiesto. Scegli l'architettura dell'immagine supportata adatta al tuo computer. Completa la configurazione.

· Avvia l'AVD con il relativo pulsante di riproduzione. Attendi che l'ambiente Android XR finisca di caricarsi.

· Nella barra degli strumenti in alto di Android Studio, seleziona la configurazione di esecuzione dell'app e il dispositivo XR Glasses in esecuzione. Fai clic su Run, il triangolo verde.

L'emulatore installa e apre l'app. Usa i suoi controlli di input per attivare Mark complete. Se il pannello rimane in Home Space, controlla il manifest e i controlli Full Space dell'ambiente prima di modificare il layout Kotlin. Consulta le istruzioni ufficiali sugli AVD.

Esegui questo controllo di accettazione:

· La prima schermata mostra zero attività confermate su tre e la prima istruzione

· Ogni attivazione di Mark complete fa avanzare esattamente di un'istruzione

· La terza attivazione mostra Checklist complete e disattiva Mark complete

· Restart demo ripristina la prima istruzione e azzera le conferme

· Il testo più lungo resta raggiungibile scorrendo

· I contenuti vengono comunque visualizzati quando l'interfaccia spaziale non è disponibile

Un test riuscito nell'emulatore convalida parte della logica e del layout dell'applicazione. Non convalida l'ottica di Aura, l'affidabilità dell'input né l'idoneità all'ambiente di lavoro.

Passaggio 7: distribuire l'app su hardware Aura autorizzato

I passaggi seguenti riprendono la procedura di debug standard di Android. I menu e le opzioni di connessione di Aura possono variare a seconda della versione software, quindi, dove differiscono, segui le istruzioni specifiche del kit.

Collegare Aura ed eseguire l'app

· Avvia Aura con gli occhiali collegati e apri Settings, l'app delle impostazioni

· Su Aura, nell'interfaccia delle impostazioni, attiva Developer options e il debug seguendo le istruzioni del kit; se questi controlli non sono disponibili, procurati la guida di configurazione per sviluppatori

· Collega il computer alla Charging Port del puck di calcolo (lato sinistro) con un cavo dati USB e lascia gli occhiali sulla Glasses Port (lato destro); se non funziona, collegalo alla porta sul lato destro per il supporto ADB completo.

· Accetta la richiesta di autorizzazione al debug sul dispositivo; un dispositivo gestito può richiedere l'approvazione di un amministratore

· Nella barra degli strumenti in alto di Android Studio, seleziona Aura nel menu a discesa dei dispositivi e fai clic su Run

· Su Aura, ripeti i controlli del pannello delle attività del passaggio 6, inclusi l'avanzamento delle attività e il riavvio della checklist

Risoluzione dei problemi di connessione del dispositivo

Se Aura non compare nel selettore di destinazione di Android Studio, verifica la connessione con ADB:

  1. Apri View > Tool Windows > Terminal in Android Studio.
  1. Esegui il seguente comando:
adb devices -l

Controlla l'output:

· Se il dispositivo è elencato con device, è connesso e autorizzato.

· Se mostra unauthorized, indossa gli occhiali e accetta la richiesta di debug USB sullo schermo.

· Se l'elenco è vuoto, ricontrolla il cavo dati USB, assicurati che il puck di calcolo sia acceso e verifica che il debug USB sia ancora attivo in Settings.

Conclusione

La creazione di una prima app aziendale per XREAL Aura parte da Android Studio, Kotlin e Jetpack XR SDK, per poi passare da un semplice pannello di istruzioni di lavoro ai test nell'emulatore e alla distribuzione su hardware autorizzato. Questo approccio offre alle aziende un modo mirato per valutare se le istruzioni spaziali migliorano un flusso di lavoro reale prima di investire in integrazioni e nella distribuzione su larga scala dei dispositivi. Una volta che il pannello risulta leggibile, utilizzabile e convalidato su Aura, il passo successivo è collegare procedure approvate e registrazioni affidabili del lavoro ai sistemi aziendali.

Parla con VR Expert della disponibilità di Aura e dei requisiti di hardware, sviluppo software e assistenza per il tuo progetto pilota aziendale.

João Noronha

Scritto da

João Noronha

Specialista XR e Contenuti Immersivi presso VR Expert

João Noronha è Specialista XR e Contenuti Immersivi presso VR Expert, con un forte interesse per le tecnologie emergenti e le loro applicazioni pratiche. Si occupa di trasformare sviluppi complessi in ambito VR, AR, occhiali IA e tecnologia immersiva in contenuti chiari e pratici per aziende e professionisti che esplorano il settore XR.

Domande frequenti

Questo articolo

Sì. Inizia con l'emulatore Android XR Glasses per sviluppare l'interfaccia e il flusso delle attività. I test fisici su Aura restano comunque necessari prima di un progetto pilota sul posto di lavoro.

No. Android Studio, Kotlin e Jetpack Compose for XR sono adatti a questo esempio incentrato sull'interfaccia. Unity è un motore di sviluppo distinto che può essere indicato per progetti con molti contenuti 3D interattivi.

No. Fornisce funzionalità XR. Il tuo team deve comunque implementare e convalidare i requisiti di sicurezza, archiviazione dei dati, identità, distribuzione, assistenza e integrazione.

No. Mostra testo memorizzato localmente e registra le conferme nello stato dell'interfaccia utente. Il riconoscimento delle apparecchiature, la comprensione della scena e le registrazioni verificate del lavoro richiedono ulteriore progettazione e implementazione.

Questo esempio non implementa un ancoraggio fisico persistente. Un ancoraggio è un riferimento spaziale usato per posizionare i contenuti rispetto a un luogo; il posizionamento specifico per una macchina richiede un ulteriore flusso di ancoraggio supportato e una convalida sul dispositivo.