Ansluta XREAL Aura till era affärssystem

Ansluta XREAL Aura till era affärssystem

Sammanfattning

För att ansluta XREAL Aura till ett affärssystem kör du en auktoriserad företagsapp på dess Android XR-beräkningsenhet (compute puck) och låter appen begära data från systemets API. Ett API är en mjukvarukoppling som gör att en applikation kan hämta information från en annan. I den här guiden bygger vi en liten app som hämtar en arbetsorder och visar dess instruktioner på Aura.

En underhållsorder är en bra första integration eftersom den kombinerar ett ordernummer, uppgifter om utrustningen och praktiska instruktioner. Appen hämtar de fälten via en auktoriserad anslutning och presenterar dem i ett lättläst fönster. Samma tillvägagångssätt kan anpassas till andra affärsposter när deras API:er och åtkomstregler tillåter det.

Så fungerar en affärsintegration med XREAL Aura

XREAL Aura består av trådanslutna glasögon och en beräkningsenhet, den lilla dator som kör Android XR och din app. Appen ansluter till företagssystemet via Wi-Fi och en godkänd nätverksväg; glasögonen visar den information som returneras. [1]

En arbetsorder beskriver ett jobb och instruktionerna för att utföra det. En medarbetare anger ordernumret i Aura-appen och väljer Load work order. Appen begär posten från affärssystemet och visar sedan utrustningens namn, procedurversion och detaljerade instruktioner. Med Next och Previous kan medarbetaren bläddra mellan instruktionerna medan källposten förblir oförändrad.

Om ditt företag redan har en Android-app som visar de här posterna, be dess utvecklare kontrollera om den fungerar korrekt på Android XR innan ni bygger en till. Google stöder vanliga Android-gränssnitt (som en 2D-mobilapp eller en Android-app för stora skärmar) som visas i en XR-systempanel, det vill säga ett 2D-fönster som visas i XR-miljön. En befintlig app behöver ändå testas med avseende på kompatibilitet och åtkomst. [4]

Information om hårdvaran finns på vår produktsida för XREAL Aura. Kontrollera aktuell tillgänglighet och support i ditt land, eftersom lanseringsinformationen ändras. [2]

Steg 1 Skaffa en testarbetsorder och dess anslutningsuppgifter

Din Aura-app behöver en post att visa och behörighet att hämta den från företagets system. En arbetsorder är en jobbpost som innehåller ordernummer, uppgifter om utrustningen och instruktioner, till exempel stegen för att inspektera en maskin.

· Innan du skriver koden, se till att du har en HTTPS-slutpunkt, en åtkomsttoken för test och ett exempelnummer för en arbetsorder (t.ex. WO-1001) som följer JSON-schemat i utvecklarreferensen.

· Be IT-avdelningen om API-adressen som hämtar den här ordern och en tillfällig åtkomsttoken för test. API-adressen talar om för appen var posten ska begäras; token ger appen behörighet att läsa data. Be IT bekräfta att båda fungerar och om åtkomst till företagets nätverk krävs.

· Dela utvecklarreferensen i slutet av den här artikeln med IT så att de kan kontrollera att den returnerade datan stämmer med exempelappen. Om den avviker uppdaterar du koden i steg 3 så att den läser ditt systems fältnamn. Om det inte finns något lämpligt API måste IT först tillhandahålla ett.

Ha de här tre sakerna till hands: API-adressen förs in i koden i steg 3; token och arbetsordernumret anges i den körande appen i steg 4. Tillsammans gör de att appen kan hämta jobbet och visa dess instruktioner på Aura.

Steg 2 Öppna Android Studio och förbered appen

Steg 2.1 Skapa projektet på din dator

· Öppna den officiella nedladdningssidan för Android Studio i datorns webbläsare. Installera Android Studio och slutför installationen. Om du behöver Googles särskilda XR-verktyg följer du dess installationsguide för Android Studio for XR, som för närvarande rekommenderar en Canary-version, en tidig utvecklingsversion. [5]

· Öppna Android Studio. Välj New Project på välkomstskärmen. Om ett annat projekt är öppet väljer du File > New > New Project i Android Studios toppmeny.

· I projektfönstret väljer du Phone and Tablet > Empty Activity. Välj Next.

· Ställ in Name till AuraWorkOrders och Package name till com.example.auraworkorders. Välj Kotlin där ett språkalternativ visas, behåll mallens SDK-inställningar och välj Finish.

· Vänta tills Android Studio har slutfört Gradle-synkroniseringen. Gradle är byggverktyget som förbereder projektets bibliotek och inställningar. Åtgärda eventuella fel i fönstret Build eller Sync innan du fortsätter.

Steg 2.2 Ge appen åtkomst till nätverket

Manifestet är den Android-fil som anger vad appen behöver, bland annat nätverksbehörighet.

· I Android Studios Project-panel till vänster väljer du vyn Android i rullgardinsmenyn. Om panelen är dold väljer du View > Tool Windows > Project.

· Expandera app > manifests i den panelen och öppna AndroidManifest.xml.

· Lägg till den här raden inuti manifest-elementet, ovanför application-elementet. Behåll resten av den genererade filen.

<uses-permission android:name="android.permission.INTERNET" />

· Leta upp den inledande application-taggen i samma fil. Lägg till android:usesCleartextTraffic="false" som ett attribut i den taggen. Android blockerar redan okrypterad HTTP för appar som riktar sig mot Android 9 eller senare, så den här raden gör avsikten uttrycklig.

Behörigheten INTERNET beviljas vid installationen; den ger ingen dialogruta om åtkomst när appen körs. [6] Exemplet använder Androids inbyggda verktyg för nätverk och JSON, så du behöver inte lägga till Retrofit eller något annat nätverksbibliotek.

Steg 3 Lägg till koden som hämtar och visar arbetsordern

Den här koden ansluter appen till adressen från steg 1, läser svaret och visar en instruktion i taget. Nätverksanropet körs separat från gränssnittet så att skärmen förblir responsiv.

Steg 3.1 Öppna rätt fil i Android Studio

· Expandera app > kotlin+java > com.example.auraworkorders i Android Studios Project-panel till vänster. I vissa versioner heter källmappen java.

· Öppna MainActivity.kt. Den här filen styr appens startskärm.

· Ersätt innehållet med koden nedan. Om ditt paketnamn är ett annat ändrar du första raden så att den matchar paketet du skapade i steg 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.")
        	}
    	}
    }
}

Steg 3.2 Ange företagets API-adress

· Stanna kvar i MainActivity.kt i Android Studio. Tryck Ctrl+F i Windows eller Linux, eller Command+F i macOS, och sök efter api.your-company.example.

· Ersätt exempel-URL:en på raden URL(...) med företagets slutpunktsmönster från steg 1. Behåll $id där arbetsordernumret ska stå. Om servern till exempel förväntar sig /api/jobs/WO-1001 ska koden anropa https://YOUR-APPROVED-HOST/api/jobs/$id .· Lägg inte in token i den här filen. Appen har ett tillfälligt testfält för den när du kör appen.

· Om ditt API-svar skiljer sig från utvecklarreferensen uppdaterar du fältnamnen och strukturen som fetchOrder läser innan du kör appen. I den här funktionen läser JSONObject svaret och getJSONArray("steps") öppnar listan med instruktioner.

· Välj Build > Make Project i Android Studio om kommandot finns i din version, eller använd verktygsfältets Run-knapp i steg 4 för att kompilera projektet. Åtgärda eventuella kompileringsfel i fönstret Build.

Förväntat resultat: projektet byggs och URL:en i MainActivity.kt pekar på din riktiga testtjänst. Exempeladressen som slutar på .example ansluter inte till något affärssystem.

Steg 4 Testa anslutningen på datorn

En emulator är en virtuell Android-enhet som visas på din dator. Använd den först för att kontrollera API-adressen, token och de returnerade instruktionerna innan du felsöker en fysisk enhet.

Steg 4.1 Starta appen från Android Studio

· Välj Tools > Device Manager i Android Studios toppmeny.

· Om det redan finns en lämplig virtuell Android-enhet väljer du dess startknapp. Annars väljer du Create Device eller plusknappen, väljer en telefonprofil, väljer en tillgänglig systemavbildning, laddar ned den om du ombeds göra det och slutför guiden. Starta den nya enheten.

· Gå tillbaka till Android Studios övre verktygsfält och välj den körande enheten i enhetsmenyn. Behåll app som körkonfiguration och välj sedan den gröna Run-knappen.

· Vänta tills appen öppnas i emulatorn. Du bör se Work instructions, Work order ID, Sandbox access token och Load work order.

Steg 4.2 Begär affärsposten

· I appen som körs i emulatorn väljer du Work order ID och anger testordernumret från steg 1.

· I samma app väljer du Sandbox access token och klistrar in den tillfälliga token som IT har tillhandahållit. Klistra bara in själva värdet, utan ordet Bearer.

· Välj Load work order. När anropet lyckas visar appen Read-only instructions loaded, följt av ordernumret, utrustningens namn, procedurrevisionen och den första instruktionen.

· Välj Next för att läsa nästa instruktion. Välj Previous för att gå tillbaka. Scrolla i appen om en instruktion fortsätter nedanför fönstret.

Förväntat resultat: posten som visas stämmer med den post du öppnade i affärsapplikationen i steg 1. Om den inte laddas går du igenom felsökningsavsnittet innan du går vidare till Aura.

Steg 5 Kör samma uppkopplade app på XREAL Aura

Steg 5.1 Förbered Aura för utveckling

· Starta Aura med beräkningsenheten. Anslut i Auras inställningsapp (Settings) till ett Wi-Fi-nätverk som kan nå API:t från steg 1. Be IT bekräfta eventuella krav för privata nätverk.

· Följ XREAL:s aktuella introduktion för utvecklare för att aktivera felsökning och ansluta beräkningsenheten till datorn. Börja med XREAL:s vanliga frågor om Aura (tutorials.xreal.com/docs/aura/troubleshooting/faq/), där det finns en post om utvecklarresurser; börja där om du behöver de aktuella instruktionerna.

· Öppna Developer options i Auras inställningsapp och aktivera den felsökningsmetod som din enhet stöder, enligt introduktionen. Godkänn din utvecklingsdator om Aura visar en uppmaning. Googles guide för hårdvaruenheter förklarar den allmänna processen för Android. [7]

Exakta menyetiketter och kabeldragningar för Aura beror på hårdvara och firmware. Enligt XREAL Auras vanliga frågor stöder båda USB-C-portarna på beräkningsenheten standardfelsökning via ADB med Android Studio, så anslut datorn till Charging Port till vänster och låt glasögonen sitta kvar i Glasses Port till höger. Specifikationstabellen anger fullt ADB-stöd endast för Glasses Port, så prova den porten om den vänstra inte känns igen, och följ XREAL:s aktuella instruktioner för att aktivera utvecklaråtkomst. [1]

Steg 5.2 Installera appen från Android Studio

· Gå tillbaka till projektet AuraWorkOrders i Android Studio på datorn.

· Öppna enhetsmenyn i Android Studios övre verktygsfält. Välj din anslutna Aura-utvecklingsenhet i stället för emulatorn.

· Om enheten saknas väljer du Tools > Troubleshoot Device Connections i Android Studio och följer anslutningsassistenten. Kontrollera felsökningsbehörigheten och anslutningsmetoden mot XREAL:s introduktion.

· När enheten visas behåller du app som körkonfiguration och väljer den gröna Run-knappen. Android Studio bygger, installerar och startar appen på den valda enheten.

Steg 5.3 Hämta posten i glasögonen

· Ta på dig Aura och leta upp appfönstret Work instructions som Android Studio startade.

· Ange samma testordernummer och tillfälliga token som i steg 4 i det fönstret. Använd de inmatningsmetoder som finns på din enhet; vanliga Bluetooth-tangentbord och möss fungerar med Aura (Settings > Connected Devices > Pair new device), och ett kompatibelt Bluetooth-tangentbord kan förenkla inmatningen under testet. [1]

· Välj Load work order och använd sedan Next, Previous och scrollning för att läsa instruktionerna.

· Jämför ordernumret, utrustningens namn och instruktionstexten med originalposten i affärsapplikationen. Om de stämmer har du visat att Aura-appen kan hämta och visa den affärsposten.

Vanliga problem och vad du ska kontrollera

· Appen byggs inte: Öppna View > Tool Windows > Build i Android Studio och läs det första rapporterade felet. Kontrollera paketnamnet och om Empty Activity-projektet använder Compose och Material 3.

· Appen kan inte ladda ordern: Kontrollera i MainActivity.kt i Android Studio att exempelvärdnamnet har ersatts. Be IT kontrollera att slutpunkten kan nås från emulatorn eller Auras nätverk.

· API:t returnerar 401: API:t godtog inte autentiseringsuppgiften. Be IT kontrollera tokens giltighet och vilken tjänst den är avsedd för, eller skaffa en ny testtoken.

· API:t returnerar 403: Kontot saknar behörighet. Be administratören för affärssystemet att ge rätt åtkomst.

· API:t returnerar 404: Kontrollera ordernumret och om slutpunkten pekar på rätt testmiljö.

· API:t returnerar data men appen misslyckas: Be API-utvecklaren jämföra svaret med utvecklarreferensen. Exemplet kräver en steps-lista som inte är tom och ett id som matchar den begärda ordern.

· Fungerar i emulatorn men inte på Aura: Kontrollera Auras nätverksväg och API-åtkomst och kontrollera sedan appen på enheten. Inaktivera inte kontrollen av HTTPS-certifikat för att kringgå ett anslutningsfel.

Exemplet visar ett allmänt felmeddelande för användaren. Be administratören granska serverloggarna för att få fram den exakta API-statusen, utan att exponera token eller fullständiga arbetsordrar. För appfel använder du View > Tool Windows > Logcat i Android Studio; Logcat visar applikationsloggar.

Utvecklarreferens för exempel-API:t

Använd det här avsnittet när du kontrollerar svaret i steg 1 eller anpassar fetchOrder i steg 3. Det beskriver kontraktet för den här exempelappen, inte en slutpunkt som tillhandahålls av XREAL.

Anrop: GET https://api.your-company.example/work-orders/WO-1001

Anropshuvuden: Authorization: Bearer <kortlivad åtkomsttoken> och Accept: application/json

Förväntat lyckat svar: HTTP 200 med den här JSON-strukturen

{
  "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."
    }
  ]
}

id identifierar arbetsordern, asset identifierar utrustningen och revision identifierar procedurversionen. Varje post i steps har ett nummer (number), en rubrik (title), en fullständig instruktion (instruction) och ett expectedResult. Exemplet sorterar stegen efter nummer.

Använd godkända instruktioner för verkligt arbete; exemplet beskriver en inaktiv utbildningsstation. Före produktion bör du validera svarsstorlek och fältlängder, avvisa ogiltiga proceduruppgifter och definiera hur utgångna token ska hanteras. API:t måste kontrollera behörigheten för varje begärd order. Exempelkoden är illustrativ och har inte kompilerats eller testats mot ett livesystem eller en fysisk Aura-enhet.

Slutsats

Att ansluta XREAL Aura till ett affärssystem börjar med en godkänd API-adress och åtkomstbehörighet, följt av en Android Studio-app som hämtar den post som behövs. Genom att testa anslutningen på en dator innan den driftsätts på Aura blir det lättare att skilja problem med dataåtkomst från problem med enhetskonfigurationen. Arbetsorderexemplet för in uppgifter om utrustningen och stegvisa instruktioner i en lättläst glasögonvy, vilket ger företag en praktisk utgångspunkt för att göra verksamhetsinformation tillgänglig där arbetet utförs. Företagsinloggning, lämpliga behörigheter och enhetstester förbereder den anslutningen för en pilot med medarbetare.

Diskutera tillgången på hårdvara och era krav på piloten med VR Expert.

João Noronha

Skriven av

João Noronha

XR- och Immersive Content-specialist på VR Expert

João Noronha är XR- och Immersive Content-specialist på VR Expert, med ett starkt intresse för ny teknik och dess praktiska tillämpningar. Han fokuserar på att omvandla komplexa utvecklingar inom VR, AR, AI-glasögon och immersiv teknik till tydligt, praktiskt innehåll för företag och yrkesverksamma som utforskar XR-branschen.

Vanliga frågor

Den här artikeln

Ett system behöver ett tillgängligt API, en godkänd autentiseringsmetod och behörighet att hämta de poster som behövs. Programvara för affärsresursplanering (ERP) samordnar verksamhetens processer, medan programvara för underhållshantering organiserar service av utrustning. Deras API:er och datastrukturer varierar, så varje integration måste kontrolleras mot den specifika produkten och konfigurationen.

Google stöder vanliga Android-gränssnitt i systempaneler i Android XR. 2D-mobilappar och Android-appar för stora skärmar fungerar som standard i Android XR och visas som en 2D-panel i en XR-/3D-miljö. Testa appens inloggning, nätverksåtkomst, visning och inmatning på Aura innan du godkänner den för medarbetare. En befintlig app som redan tillhandahåller de poster som behövs kan minska mängden utveckling som krävs. [4]

Ett vanligt Android-appfönster kan visa arbetsordern och dess instruktioner. Anpassade Jetpack XR-paneler är ett valfritt tillägg när en viss uppgift gynnas av ett annat sätt att ordna informationen. [4]

Ett internt företags-API kan vara nåbart via ett godkänt lokalt eller privat nätverk. Enheten måste ändå kunna nå API:t och alla tjänster som krävs för autentisering. Exemplet kräver en aktiv anslutning och lagrar inte arbetsordrar för användning offline.

Exemplet hämtar och visar information. För att skicka in resultat krävs ytterligare en API-operation, användarbehörighet och ett bekräftelsegränssnitt. Servern måste validera det som skickas in och hantera upprepade anrop på ett säkert sätt.