Sintesi
Per collegare XREAL Aura a un sistema aziendale, esegui un'app aziendale autorizzata sul suo compute puck Android XR e lascia che sia quell'app a richiedere i dati all'API del sistema. Un'API è un collegamento software che consente a un'applicazione di recuperare informazioni da un'altra. Questa guida mostra come creare una piccola app che recupera un ordine di lavoro e ne visualizza le istruzioni su Aura.
Un ordine di lavoro di manutenzione è un buon punto di partenza per una prima integrazione, perché combina un numero di record, i dettagli dell'apparecchiatura e istruzioni pratiche. L'app recupera questi campi tramite una connessione autorizzata e li presenta in una finestra leggibile. Lo stesso approccio può essere adattato ad altri record aziendali, se le relative API e regole di accesso lo consentono.
Come funziona l'integrazione aziendale di XREAL Aura
XREAL Aura è composto da occhiali collegati via cavo e da un compute puck, il piccolo computer che esegue Android XR e la tua app. L'app si collega al sistema aziendale tramite Wi-Fi e un percorso di rete approvato; gli occhiali mostrano le informazioni restituite. [1]
Un ordine di lavoro descrive un intervento e le istruzioni per eseguirlo. Un dipendente inserisce il numero dell'ordine nell'app di Aura e seleziona Load work order. L'app richiede quel record al sistema aziendale, quindi mostra il nome dell'apparecchiatura, la versione della procedura e le istruzioni dettagliate. Con Next e Previous il dipendente può scorrere le istruzioni, mentre il record di origine resta invariato.
Se la tua azienda dispone già di un'app Android che visualizza questi record, chiedi al relativo sviluppatore di verificare se funziona correttamente su Android XR prima di crearne un'altra. Google supporta le interfacce Android standard (come un'app Android 2D per dispositivi mobili o per schermi di grandi dimensioni) visualizzate in un pannello di sistema XR, cioè una finestra 2D mostrata all'interno dell'ambiente XR. Anche un'app esistente richiede comunque test di compatibilità e di accesso. [4]
Per informazioni sull'hardware, consulta la nostra pagina prodotto di XREAL Aura. Verifica la disponibilità e il supporto attuali per il tuo paese, poiché le informazioni sul lancio cambiano. [2]
Passaggio 1 Ottieni un ordine di lavoro di prova e i relativi dati di connessione
La tua app per Aura ha bisogno di un record da visualizzare e dell'autorizzazione per recuperarlo dal sistema aziendale. Un ordine di lavoro è un record di intervento che contiene un numero d'ordine, i dettagli dell'apparecchiatura e le istruzioni, ad esempio i passaggi per ispezionare una macchina.
· Prima di scrivere il codice, assicurati di disporre di un endpoint HTTPS, di un token di accesso di prova e di un numero di ordine di lavoro di esempio (ad es. WO-1001) conforme allo schema JSON indicato nel Riferimento per sviluppatori.
· Chiedi al tuo team IT l'indirizzo API che recupera questo ordine e un token di accesso di prova temporaneo. L'indirizzo API indica all'app dove richiedere il record; il token le concede l'autorizzazione a leggere i dati. Chiedi all'IT di confermare che entrambi funzionino e se è necessario l'accesso alla rete aziendale.
· Condividi con l'IT il Riferimento per sviluppatori alla fine di questo articolo, così potrà verificare che i dati restituiti corrispondano a quelli dell'app di esempio. In caso contrario, aggiorna il codice del Passaggio 3 in modo che legga i nomi dei campi del tuo sistema. Se non esiste un'API adatta, l'IT deve prima fornirne una.
Tieni pronti questi tre elementi: l'indirizzo API va inserito nel codice al Passaggio 3; il token e il numero dell'ordine di lavoro vanno inseriti nell'app in esecuzione al Passaggio 4. Insieme, consentono all'app di recuperare l'intervento e visualizzarne le istruzioni su Aura.
Passaggio 2 Apri Android Studio e prepara l'app
Passaggio 2.1 Crea il progetto sul tuo computer
· Nel browser del computer, apri la pagina di download ufficiale di Android Studio. Installa Android Studio e completa la configurazione. Se hai bisogno degli strumenti XR dedicati di Google, segui la relativa guida alla configurazione di Android Studio per XR, che attualmente consiglia una build Canary, ovvero una versione di sviluppo preliminare. [5]
· Apri Android Studio. Nella schermata di benvenuto, seleziona New Project. Se è aperto un altro progetto, seleziona File > New > New Project dal menu superiore di Android Studio.
· Nella finestra del progetto, seleziona Phone and Tablet > Empty Activity. Seleziona Next.
· Imposta Name su AuraWorkOrders e Package name su com.example.auraworkorders. Scegli Kotlin se compare un'opzione per il linguaggio, mantieni le impostazioni SDK del modello e seleziona Finish.
· Attendi che Android Studio completi la sincronizzazione Gradle. Gradle è lo strumento di build che prepara le librerie e le impostazioni del progetto. Risolvi eventuali errori nella finestra Build o Sync prima di proseguire.
Passaggio 2.2 Consenti all'app di accedere alla rete
Il manifest è il file Android che dichiara ciò di cui l'app ha bisogno, inclusa l'autorizzazione di rete.
· Nel riquadro Project a sinistra di Android Studio, seleziona la vista Android dal menu a discesa. Se il riquadro è nascosto, seleziona View > Tool Windows > Project.
· In quel riquadro, espandi app > manifests e apri AndroidManifest.xml.
· All'interno dell'elemento manifest, sopra l'elemento application, aggiungi questa riga. Mantieni il resto del file generato.
<uses-permission android:name="android.permission.INTERNET" />· Nello stesso file, individua il tag di apertura application. Aggiungi android:usesCleartextTraffic="false" come attributo all'interno di quel tag. Android blocca già il traffico HTTP non crittografato per le app destinate ad Android 9 o versioni successive, quindi questa riga serve a rendere esplicita l'intenzione.
L'autorizzazione INTERNET viene concessa durante l'installazione; non genera alcuna richiesta di accesso quando l'app è in esecuzione. [6] L'esempio utilizza gli strumenti di rete e JSON integrati in Android, quindi non è necessario aggiungere Retrofit o un'altra libreria di rete.
Passaggio 3 Aggiungi il codice che recupera e visualizza l'ordine di lavoro
Questo codice collega l'app all'indirizzo del Passaggio 1, legge la risposta e visualizza un'istruzione alla volta. La richiesta di rete viene eseguita separatamente dall'interfaccia, così la schermata resta reattiva.
Passaggio 3.1 Apri il file corretto in Android Studio
· Nel riquadro Project a sinistra di Android Studio, espandi app > kotlin+java > com.example.auraworkorders. In alcune versioni la cartella dei sorgenti si chiama java.
· Apri MainActivity.kt. Questo file controlla la schermata iniziale dell'app.
· Sostituiscine il contenuto con il codice riportato di seguito. Se il nome del tuo pacchetto è diverso, modifica la prima riga in modo che corrisponda al pacchetto creato nel Passaggio 2.
package com.example.auraworkorders
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.ui.Modifier
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.unit.dp
import org.json.JSONObject
import java.net.URL
import java.util.concurrent.Executors
import javax.net.ssl.HttpsURLConnection
data class WorkStep(
val number: Int, val title: String,
val instruction: String, val expectedResult: String
)
data class WorkOrder(
val id: String, val asset: String,
val revision: String, val steps: List<WorkStep>
)
fun fetchOrder(id: String, token: String): WorkOrder {
require(Regex("[A-Za-z0-9-]{1,40}").matches(id))
// Replace only this origin with your approved API origin.
val url = URL("https://api.your-company.example/work-orders/$id")
val c = url.openConnection() as HttpsURLConnection
try {
c.requestMethod = "GET"
c.instanceFollowRedirects = false
c.connectTimeout = 10000
c.readTimeout = 10000
c.setRequestProperty("Authorization", "Bearer $token")
c.setRequestProperty("Accept", "application/json")
val status = c.responseCode
check(status == 200) { "HTTP $status" }
val text = c.inputStream.bufferedReader().use { it.readText() }
val obj = JSONObject(text)
check(obj.getString("id") == id) { "Order ID mismatch" }
val array = obj.getJSONArray("steps")
check(array.length() > 0) { "No instructions available" }
val steps = (0 until array.length()).map { index ->
val s = array.getJSONObject(index)
WorkStep(s.getInt("number"), s.getString("title"),
s.getString("instruction"), s.getString("expectedResult"))
}.sortedBy { it.number }
return WorkOrder(obj.getString("id"), obj.getString("asset"),
obj.getString("revision"), steps)
} finally {
c.disconnect()
}
}
class MainActivity : ComponentActivity() {
private val worker = Executors.newSingleThreadExecutor()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MaterialTheme {
WorkOrderScreen { id, token, done ->
worker.execute {
val result = runCatching { fetchOrder(id, token) }
runOnUiThread {
if (!isDestroyed) done(result)
}
}
}
}
}
}
override fun onDestroy() {
worker.shutdownNow()
super.onDestroy()
}
}
@Composable
fun WorkOrderScreen(
load: (String, String, (Result<WorkOrder>) -> Unit) -> Unit
) {
var id by remember { mutableStateOf("WO-1001") }
var token by remember { mutableStateOf("") }
var order by remember { mutableStateOf<WorkOrder?>(null) }
var index by remember { mutableStateOf(0) }
var busy by remember { mutableStateOf(false) }
var message by remember { mutableStateOf("Enter test credentials.") }
Surface(Modifier.fillMaxSize()) {
Column(Modifier.padding(24.dp)
.verticalScroll(rememberScrollState()),
verticalArrangement = Arrangement.spacedBy(16.dp)) {
Text("Work instructions", style = MaterialTheme.typography.headlineMedium)
OutlinedTextField(value = id, onValueChange = { id = it },
label = { Text("Work order ID") },
singleLine = true, enabled = !busy)
OutlinedTextField(value = token, onValueChange = { token = it },
label = { Text("Sandbox access token") }, singleLine = true,
visualTransformation = PasswordVisualTransformation(),
enabled = !busy)
Button(enabled = !busy && token.isNotBlank() &&
Regex("[A-Za-z0-9-]{1,40}").matches(id), onClick = {
busy = true
order = null
index = 0
message = "Loading work order..."
load(id, token) { result ->
busy = false
result.onSuccess {
order = it
message = "Read-only instructions loaded."
}.onFailure {
message = "Could not load order. Check access and network."
}
}
}) { Text(if (busy) "Loading..." else "Load work order") }
Text(message)
order?.let { current ->
Text("${current.id} | ${current.asset}")
Text("Procedure revision ${current.revision}")
val step = current.steps[index]
Text("Step ${index + 1} of ${current.steps.size}",
style = MaterialTheme.typography.titleLarge)
Text(step.title, style = MaterialTheme.typography.headlineSmall)
Text(step.instruction, style = MaterialTheme.typography.bodyLarge)
Text("Expected result: ${step.expectedResult}")
Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
Button(enabled = index > 0,
onClick = { index-- }) { Text("Previous") }
Button(enabled = index < current.steps.lastIndex,
onClick = { index++ }) { Text("Next") }
}
Text("Navigation does not record task completion.")
}
}
}
}Passaggio 3.2 Inserisci l'indirizzo API della tua azienda
· Rimani in MainActivity.kt in Android Studio. Premi Ctrl+F su Windows o Linux, oppure Command+F su macOS, e cerca api.your-company.example.
· Sostituisci l'URL di esempio nella riga URL(...) con lo schema dell'endpoint della tua azienda indicato al Passaggio 1. Mantieni $id nella posizione del numero dell'ordine di lavoro. Ad esempio, se il server si aspetta /api/jobs/WO-1001, il codice deve richiedere https://YOUR-APPROVED-HOST/api/jobs/$id .· Non inserire il token in questo file. Quando esegui l'app, questa fornisce un campo di prova temporaneo in cui inserirlo.
· Se la risposta della tua API è diversa da quella del Riferimento per sviluppatori, aggiorna i nomi dei campi e la struttura letti da fetchOrder prima di eseguire l'app. In questa funzione, JSONObject legge la risposta e getJSONArray("steps") apre il relativo elenco di istruzioni.
· In Android Studio, seleziona Build > Make Project se il comando è disponibile nella tua versione, oppure usa il pulsante Run della barra degli strumenti al Passaggio 4 per compilare il progetto. Correggi eventuali errori di compilazione nella finestra Build.
Risultato atteso: il progetto viene compilato e l'URL in MainActivity.kt punta al tuo servizio di prova reale. L'indirizzo di esempio che termina con .example non si collegherà ad alcun sistema aziendale.
Passaggio 4 Testa la connessione sul tuo computer
Un emulatore è un dispositivo Android virtuale visualizzato sul computer. Usalo innanzitutto per verificare l'indirizzo API, il token e le istruzioni restituite, prima di passare alla risoluzione dei problemi su un dispositivo fisico.
Passaggio 4.1 Avvia l'app da Android Studio
· Nel menu superiore di Android Studio, seleziona Tools > Device Manager.
· Se esiste già un dispositivo virtuale Android adatto, seleziona il relativo pulsante di avvio. Altrimenti seleziona Create Device o il pulsante più, scegli un profilo telefono, seleziona un'immagine di sistema disponibile, scaricala se richiesto e completa la procedura guidata. Avvia il nuovo dispositivo.
· Tornato nella barra degli strumenti superiore di Android Studio, seleziona il dispositivo in esecuzione nel menu a discesa dei dispositivi. Lascia selezionato app come configurazione di esecuzione, quindi seleziona il pulsante verde Run.
· Attendi che l'app si apra nell'emulatore. Dovresti vedere Work instructions, Work order ID, Sandbox access token e Load work order.
Passaggio 4.2 Richiedi il record aziendale
· Nell'app in esecuzione nell'emulatore, seleziona Work order ID e inserisci il numero dell'ordine di prova del Passaggio 1.
· Nella stessa app, seleziona Sandbox access token e incolla il token temporaneo fornito dall'IT. Incolla solo il valore, senza la parola Bearer.
· Seleziona Load work order. Se la richiesta va a buon fine, l'app visualizza Read-only instructions loaded, seguito dal numero dell'ordine, dal nome dell'apparecchiatura, dalla revisione della procedura e dalla prima istruzione.
· Seleziona Next per leggere l'istruzione successiva. Seleziona Previous per tornare indietro. Scorri all'interno dell'app se un'istruzione si estende oltre il bordo inferiore della finestra.
Risultato atteso: il record visualizzato corrisponde a quello che hai aperto nell'applicazione aziendale al Passaggio 1. Se non viene caricato, consulta la sezione sulla risoluzione dei problemi prima di passare ad Aura.
Passaggio 5 Esegui la stessa app connessa su XREAL Aura
Passaggio 5.1 Prepara Aura per lo sviluppo
· Accendi Aura tramite il suo compute puck. Nell'applicazione Settings di Aura, connettiti a una rete Wi-Fi in grado di raggiungere l'API del Passaggio 1. Chiedi all'IT di confermare eventuali requisiti di rete privata.
· Segui la procedura di onboarding per sviluppatori attualmente fornita da XREAL per abilitare il debug e collegare il compute puck al computer. Parti dalle FAQ di Aura di XREAL (tutorials.xreal.com/docs/aura/troubleshooting/faq/), che contengono la voce dedicata alle risorse per sviluppatori; parti da lì se ti servono le istruzioni aggiornate.
· Nell'applicazione Settings di Aura, apri Developer options e abilita il metodo di debug supportato dal tuo dispositivo, seguendo la procedura di onboarding. Autorizza il computer di sviluppo se Aura mostra una richiesta. La guida ai dispositivi hardware di Google spiega la procedura generale di Android. [7]
Le voci di menu esatte di Aura e la disposizione dei cavi dipendono dall'hardware e dal firmware. Secondo le FAQ di XREAL Aura, entrambe le porte USB-C del compute puck supportano il debug ADB standard con Android Studio: collega quindi il computer alla Charging Port a sinistra e lascia gli occhiali collegati alla Glasses Port a destra. La tabella delle specifiche indica il supporto ADB completo solo per la Glasses Port, quindi prova quella porta se la porta sinistra non viene riconosciuta, e segui le istruzioni aggiornate di XREAL per abilitare l'accesso da sviluppatore. [1]
Passaggio 5.2 Installa l'app da Android Studio
· Sul computer, torna al progetto AuraWorkOrders in Android Studio.
· Apri il menu a discesa dei dispositivi nella barra degli strumenti superiore di Android Studio. Seleziona il dispositivo di sviluppo Aura collegato anziché l'emulatore.
· Se il dispositivo non compare, seleziona Tools > Troubleshoot Device Connections in Android Studio e segui l'assistente di connessione. Verifica l'autorizzazione al debug e il metodo di connessione con la procedura di onboarding di XREAL.
· Quando il dispositivo compare, lascia selezionato app come configurazione di esecuzione e seleziona il pulsante verde Run. Android Studio compila, installa e avvia l'app sul dispositivo selezionato.
Passaggio 5.3 Recupera il record negli occhiali
· Indossa Aura e individua la finestra dell'app Work instructions avviata da Android Studio.
· In quella finestra, inserisci lo stesso numero di ordine di prova e lo stesso token temporaneo usati nel Passaggio 4. Usa i metodi di input disponibili sul tuo dispositivo; tastiere e mouse Bluetooth standard funzionano con Aura (Settings > Connected Devices > Pair new device) e una tastiera Bluetooth compatibile può semplificare l'inserimento dei dati di prova. [1]
· Seleziona Load work order, quindi usa Next, Previous e lo scorrimento per leggerne le istruzioni.
· Confronta il numero dell'ordine, il nome dell'apparecchiatura e il testo delle istruzioni con il record originale nell'applicazione aziendale. Se corrispondono, hai dimostrato che l'app per Aura è in grado di recuperare e visualizzare quel record aziendale.
Problemi comuni e cosa verificare
· L'app non viene compilata: in Android Studio, apri View > Tool Windows > Build e leggi il primo errore segnalato. Controlla il nome del pacchetto e verifica che il progetto Empty Activity utilizzi Compose e Material 3.
· L'app non riesce a caricare l'ordine: in MainActivity.kt, in Android Studio, verifica che il nome host di esempio sia stato sostituito. Chiedi all'IT di controllare che l'endpoint sia raggiungibile dalla rete dell'emulatore o di Aura.
· L'API restituisce 401: l'API non ha accettato la credenziale. Chiedi all'IT di verificare la validità del token e il servizio a cui è destinato, oppure ottieni un nuovo token di prova.
· L'API restituisce 403: l'account non dispone dell'autorizzazione necessaria. Chiedi all'amministratore del sistema aziendale di concedere l'accesso corretto.
· L'API restituisce 404: controlla il numero dell'ordine e verifica che l'endpoint punti all'ambiente di test corretto.
· L'API restituisce dati ma l'app non funziona: chiedi allo sviluppatore dell'API di confrontare la risposta con il Riferimento per sviluppatori. L'esempio richiede un elenco steps non vuoto e un id corrispondente all'ordine richiesto.
· Funziona nell'emulatore ma non su Aura: verifica il percorso di rete di Aura e l'accesso all'API, quindi controlla l'app sul dispositivo. Non disattivare i controlli dei certificati HTTPS per aggirare un errore di connessione.
L'esempio mostra all'utente un messaggio di errore generico. Per conoscere lo stato esatto restituito dall'API, chiedi all'amministratore di esaminare i log del server senza esporre token o ordini di lavoro completi. Per gli errori dell'app, usa View > Tool Windows > Logcat in Android Studio; Logcat visualizza i log dell'applicazione.
Riferimento per sviluppatori per l'API di esempio
Consulta questa sezione quando verifichi la risposta al Passaggio 1 o adatti fetchOrder al Passaggio 3. Descrive il contratto di questa app di esempio, non un endpoint fornito da XREAL.
Richiesta: GET https://api.your-company.example/work-orders/WO-1001
Intestazioni della richiesta: Authorization: Bearer <token di accesso a breve durata> e Accept: application/json
Risposta positiva prevista: HTTP 200 con questa struttura JSON
{
"id": "WO-1001",
"asset": "Training station A",
"revision": "3",
"steps": [
{
"number": 1,
"title": "Confirm the training station",
"instruction": "Match the station label to this work order. Stop if the labels differ.",
"expectedResult": "The station label matches Training station A."
},
{
"number": 2,
"title": "Review the reference label",
"instruction": "Read the sample label and compare it with the training reference sheet.",
"expectedResult": "The sample label matches the approved reference."
}
]
}Il campo id identifica l'ordine di lavoro, asset ne identifica l'apparecchiatura e revision identifica la versione della procedura. Ogni voce all'interno di steps contiene un numero, un titolo, l'istruzione completa ed expectedResult. L'esempio ordina i passaggi in base al numero.
Per il lavoro reale utilizza istruzioni approvate; l'esempio descrive una postazione di formazione non attiva. Prima della messa in produzione, convalida le dimensioni della risposta e la lunghezza dei campi, rifiuta i dati di procedura non validi e definisci il comportamento alla scadenza del token. L'API deve verificare le autorizzazioni per ogni ordine richiesto. Il codice di esempio è illustrativo e non è stato compilato né testato con un sistema reale o su un dispositivo Aura fisico.
Conclusione
Il collegamento di XREAL Aura a un sistema aziendale parte da un indirizzo API approvato e da un'autorizzazione di accesso, seguiti da un'app Android Studio che recupera il record necessario. Testare la connessione su un computer prima di distribuirla su Aura aiuta a distinguere i problemi di accesso ai dati da quelli di configurazione del dispositivo. L'esempio dell'ordine di lavoro porta i dettagli dell'apparecchiatura e le istruzioni passo passo su un display leggibile negli occhiali, offrendo alle aziende un punto di partenza concreto per rendere le informazioni operative accessibili sul luogo di lavoro. L'accesso con le credenziali aziendali, le autorizzazioni appropriate e i test sui dispositivi preparano quel collegamento a un progetto pilota con i dipendenti.
Parla della disponibilità dell'hardware e dei requisiti del tuo progetto pilota con VR Expert.

























