XREAL Aura mit Ihren Unternehmenssystemen verbinden

XREAL Aura mit Ihren Unternehmenssystemen verbinden

Zusammenfassung

Um XREAL Aura mit einem Unternehmenssystem zu verbinden, führen Sie auf dem Android-XR-Compute-Puck eine autorisierte Unternehmens-App aus, die Daten über die API des Systems anfordert. Eine API ist eine Softwareschnittstelle, über die eine Anwendung Informationen aus einer anderen abrufen kann. In diesem Leitfaden erstellen wir eine kleine App, die einen Arbeitsauftrag abruft und dessen Anweisungen auf Aura anzeigt.

Ein Wartungsauftrag eignet sich gut als erste Integration, da er eine Auftragsnummer, Angaben zur Anlage und praktische Anweisungen vereint. Die App ruft diese Felder über eine autorisierte Verbindung ab und stellt sie in einem gut lesbaren Fenster dar. Derselbe Ansatz lässt sich auf andere Geschäftsdatensätze übertragen, sofern deren APIs und Zugriffsregeln dies zulassen.

So funktioniert die Integration von XREAL Aura in Unternehmenssysteme

XREAL Aura besteht aus einer kabelgebundenen Brille und einem Compute Puck – dem kleinen Computer, auf dem Android XR und Ihre App laufen. Die App verbindet sich über WLAN und einen freigegebenen Netzwerkpfad mit dem Unternehmenssystem; die Brille zeigt die zurückgegebenen Informationen an. [1]

Ein Arbeitsauftrag beschreibt eine Aufgabe und die Anweisungen zu ihrer Ausführung. Ein Mitarbeiter gibt die Auftragsnummer in der Aura-App ein und wählt „Load work order“. Die App fordert diesen Datensatz vom Unternehmenssystem an und zeigt anschließend Anlagenbezeichnung, Verfahrensversion und detaillierte Anweisungen an. Mit „Next“ und „Previous“ blättert der Mitarbeiter durch die Anweisungen, während der Quelldatensatz unverändert bleibt.

Wenn Ihr Unternehmen bereits eine Android-App hat, die diese Datensätze anzeigt, lassen Sie deren Entwickler prüfen, ob sie unter Android XR korrekt läuft, bevor Sie eine weitere entwickeln. Google unterstützt Standard-Android-Oberflächen (etwa eine 2D-Mobil-App oder eine Android-App für große Bildschirme), die in einem XR-Systempanel als 2D-Fenster innerhalb der XR-Umgebung angezeigt werden. Auch eine bestehende App muss auf Kompatibilität und Zugriff getestet werden. [4]

Hintergrundinformationen zur Hardware finden Sie auf unserer Produktseite zu XREAL Aura. Prüfen Sie die aktuelle Verfügbarkeit und den Support für Ihr Land, da sich Informationen zur Markteinführung ändern. [2]

Schritt 1: Test-Arbeitsauftrag und Verbindungsdaten beschaffen

Ihre Aura-App benötigt einen Datensatz zur Anzeige und die Berechtigung, ihn aus Ihrem Unternehmenssystem abzurufen. Ein Arbeitsauftrag ist ein Auftragsdatensatz mit Auftragsnummer, Anlagendaten und Anweisungen, etwa den Schritten zur Inspektion einer Maschine.

· Stellen Sie vor dem Programmieren sicher, dass Sie einen HTTPS-Endpunkt, ein Test-Zugriffstoken und eine Beispiel-Auftragsnummer (z. B. WO-1001) haben, die dem JSON-Schema in der Entwicklerreferenz entsprechen.

· Bitten Sie Ihr IT-Team um die API-Adresse, über die dieser Auftrag abgerufen wird, sowie um ein temporäres Test-Zugriffstoken. Die API-Adresse teilt der App mit, wo sie den Datensatz anfordern soll; das Token erteilt ihr die Berechtigung, die Daten zu lesen. Lassen Sie sich von der IT bestätigen, dass beides funktioniert und ob ein Zugang zum Unternehmensnetzwerk erforderlich ist.

· Geben Sie die Entwicklerreferenz am Ende dieses Artikels an die IT weiter, damit dort geprüft werden kann, ob die zurückgegebenen Daten zur Beispiel-App passen. Falls sie abweichen, passen Sie den Code in Schritt 3 an die Feldnamen Ihres Systems an. Gibt es keine geeignete API, muss die IT zunächst eine bereitstellen.

Halten Sie diese drei Angaben bereit: Die API-Adresse kommt in Schritt 3 in den Code; Token und Auftragsnummer geben Sie in Schritt 4 in die laufende App ein. Zusammen ermöglichen sie es der App, den Auftrag abzurufen und seine Anweisungen auf Aura anzuzeigen.

Schritt 2: Android Studio öffnen und die App vorbereiten

Schritt 2.1: Projekt auf Ihrem Computer anlegen

· Öffnen Sie im Browser Ihres Computers die offizielle Download-Seite von Android Studio. Installieren Sie Android Studio und schließen Sie die Einrichtung ab. Falls Sie Googles spezielle XR-Tools benötigen, folgen Sie der Einrichtungsanleitung für Android Studio for XR, die derzeit einen Canary-Build empfiehlt, also eine frühe Entwicklungsversion. [5]

· Öffnen Sie Android Studio. Wählen Sie auf dem Startbildschirm New Project. Ist bereits ein anderes Projekt geöffnet, wählen Sie im oberen Menü von Android Studio File > New > New Project.

· Wählen Sie im Projektfenster Phone and Tablet > Empty Activity. Klicken Sie auf Next.

· Setzen Sie Name auf AuraWorkOrders und Package name auf com.example.auraworkorders. Wählen Sie Kotlin, sofern eine Sprachoption angezeigt wird, übernehmen Sie die SDK-Einstellungen der Vorlage und klicken Sie auf Finish.

· Warten Sie, bis Android Studio die Gradle-Synchronisierung abgeschlossen hat. Gradle ist das Build-Tool, das die Bibliotheken und Einstellungen des Projekts vorbereitet. Beheben Sie etwaige Fehler im Build- oder Sync-Fenster, bevor Sie fortfahren.

Schritt 2.2: Der App den Netzwerkzugriff erlauben

Das Manifest ist die Android-Datei, in der deklariert wird, was die App benötigt – einschließlich der Netzwerkberechtigung.

· Wählen Sie im linken Project-Bereich von Android Studio im Dropdown-Menü die Ansicht Android. Ist der Bereich ausgeblendet, wählen Sie View > Tool Windows > Project.

· Klappen Sie in diesem Bereich app > manifests auf und öffnen Sie AndroidManifest.xml.

· Fügen Sie diese Zeile innerhalb des manifest-Elements oberhalb des application-Elements ein. Der Rest der generierten Datei bleibt unverändert.

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

· Suchen Sie in derselben Datei das öffnende application-Tag. Fügen Sie android:usesCleartextTraffic="false" als Attribut innerhalb dieses Tags hinzu. Android blockiert unverschlüsseltes HTTP bereits für Apps, die auf Android 9 oder neuer ausgerichtet sind; diese Zeile macht die Absicht lediglich explizit.

Die INTERNET-Berechtigung wird bei der Installation erteilt; beim Ausführen der App erscheint keine Zugriffsabfrage. [6] Das Beispiel nutzt die integrierten Netzwerk- und JSON-Werkzeuge von Android, sodass Sie weder Retrofit noch eine andere Netzwerkbibliothek hinzufügen müssen.

Schritt 3: Code zum Abrufen und Anzeigen des Arbeitsauftrags hinzufügen

Dieser Code verbindet die App mit der Adresse aus Schritt 1, liest die Antwort aus und zeigt jeweils eine Anweisung an. Die Netzwerkanfrage läuft getrennt von der Benutzeroberfläche, damit der Bildschirm reaktionsfähig bleibt.

Schritt 3.1: Die richtige Datei in Android Studio öffnen

· Klappen Sie im linken Project-Bereich von Android Studio app > kotlin+java > com.example.auraworkorders auf. In manchen Versionen heißt der Quellordner java.

· Öffnen Sie MainActivity.kt. Diese Datei steuert den Startbildschirm der App.

· Ersetzen Sie den Inhalt durch den folgenden Code. Weicht Ihr Paketname ab, passen Sie die erste Zeile an das in Schritt 2 erstellte Paket an.

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

Schritt 3.2: API-Adresse Ihres Unternehmens eintragen

· Bleiben Sie in Android Studio in MainActivity.kt. Drücken Sie unter Windows oder Linux Strg+F bzw. unter macOS Befehlstaste+F und suchen Sie nach api.your-company.example.

· Ersetzen Sie die Beispiel-URL in der Zeile URL(...) durch das Endpunktmuster Ihres Unternehmens aus Schritt 1. Behalten Sie $id an der Stelle bei, an die die Auftragsnummer gehört. Erwartet der Server beispielsweise /api/jobs/WO-1001, sollte der Code https://YOUR-APPROVED-HOST/api/jobs/$id anfordern.· Legen Sie das Token nicht in dieser Datei ab. Die App stellt beim Ausführen ein temporäres Testfeld dafür bereit.

· Weicht Ihre API-Antwort von der Entwicklerreferenz ab, passen Sie vor dem Ausführen die Feldnamen und die Struktur an, die fetchOrder ausliest. In dieser Funktion liest JSONObject die Antwort, und getJSONArray("steps") öffnet die darin enthaltene Liste der Anweisungen.

· Wählen Sie in Android Studio Build > Make Project, sofern dieser Befehl in Ihrer Version verfügbar ist, oder kompilieren Sie das Projekt in Schritt 4 über die Run-Schaltfläche in der Symbolleiste. Beheben Sie etwaige Kompilierungsfehler im Build-Fenster.

Erwartetes Ergebnis: Das Projekt lässt sich erstellen, und die URL in MainActivity.kt verweist auf Ihren tatsächlichen Testdienst. Die Beispieladresse mit der Endung .example stellt keine Verbindung zu einem Unternehmenssystem her.

Schritt 4: Verbindung auf Ihrem Computer testen

Ein Emulator ist ein virtuelles Android-Gerät, das auf Ihrem Computer angezeigt wird. Prüfen Sie damit zunächst API-Adresse, Token und zurückgegebene Anweisungen, bevor Sie sich der Fehlersuche auf einem physischen Gerät widmen.

Schritt 4.1: App aus Android Studio starten

· Wählen Sie im oberen Menü von Android Studio Tools > Device Manager.

· Ist bereits ein geeignetes virtuelles Android-Gerät vorhanden, klicken Sie auf dessen Start-Schaltfläche. Andernfalls wählen Sie Create Device oder die Plus-Schaltfläche, wählen ein Smartphone-Profil und ein verfügbares System-Image aus, laden es bei Aufforderung herunter und schließen den Assistenten ab. Starten Sie das neue Gerät.

· Wählen Sie anschließend in der oberen Symbolleiste von Android Studio dieses laufende Gerät im Geräte-Dropdown aus. Behalten Sie app als Run-Konfiguration bei und klicken Sie dann auf die grüne Run-Schaltfläche.

· Warten Sie, bis sich die App im Emulator öffnet. Sie sollten Work instructions, Work order ID, Sandbox access token und Load work order sehen.

Schritt 4.2: Den Geschäftsdatensatz anfordern

· Wählen Sie in der laufenden App im Emulator das Feld Work order ID aus und geben Sie die Test-Auftragsnummer aus Schritt 1 ein.

· Wählen Sie in derselben App Sandbox access token aus und fügen Sie das temporäre Token ein, das Sie von der IT erhalten haben. Fügen Sie nur den Wert ein, ohne das Wort Bearer.

· Wählen Sie Load work order. Ist die Anfrage erfolgreich, zeigt die App Read-only instructions loaded an, gefolgt von Auftragsnummer, Anlagenbezeichnung, Verfahrensrevision und der ersten Anweisung.

· Wählen Sie Next, um die nächste Anweisung zu lesen, und Previous, um zurückzugehen. Scrollen Sie innerhalb der App, wenn eine Anweisung über den unteren Fensterrand hinausreicht.

Erwartetes Ergebnis: Der angezeigte Datensatz stimmt mit dem Datensatz überein, den Sie in Schritt 1 in der Geschäftsanwendung geöffnet haben. Wird er nicht geladen, nutzen Sie den Abschnitt zur Fehlerbehebung, bevor Sie zu Aura wechseln.

Schritt 5: Dieselbe verbundene App auf XREAL Aura ausführen

Schritt 5.1: Aura für die Entwicklung vorbereiten

· Schalten Sie Aura über den Compute Puck ein. Verbinden Sie sich in der Einstellungen-App von Aura mit einem WLAN, über das die API aus Schritt 1 erreichbar ist. Lassen Sie sich von der IT etwaige Anforderungen an private Netzwerke bestätigen.

· Folgen Sie dem aktuellen Entwickler-Onboarding von XREAL, um das Debugging zu aktivieren und den Compute Puck mit Ihrem Computer zu verbinden. Beginnen Sie mit der Aura-FAQ von XREAL (tutorials.xreal.com/docs/aura/troubleshooting/faq/); dort finden Sie den Eintrag zu den Entwicklerressourcen – starten Sie dort, wenn Sie die aktuellen Anweisungen benötigen.

· Öffnen Sie in der Einstellungen-App von Aura die Entwickleroptionen und aktivieren Sie gemäß diesem Onboarding die von Ihrem Gerät unterstützte Debugging-Methode. Autorisieren Sie Ihren Entwicklungscomputer, falls Aura eine entsprechende Abfrage anzeigt. Googles Leitfaden für Hardwaregeräte erläutert den allgemeinen Android-Ablauf. [7]

Die genauen Menübezeichnungen und Kabelanordnungen von Aura hängen von Hardware und Firmware ab. Laut der FAQ von XREAL Aura unterstützen beide USB-C-Anschlüsse am Compute Puck das standardmäßige ADB-Debugging mit Android Studio; schließen Sie den Computer daher am Charging Port links an und lassen Sie die Brille am Glasses Port rechts. In der Spezifikationstabelle wird die volle ADB-Unterstützung allerdings nur für den Glasses Port aufgeführt – versuchen Sie es also mit diesem Anschluss, falls der linke nicht erkannt wird, und befolgen Sie die aktuellen Anweisungen von XREAL zum Aktivieren des Entwicklerzugriffs. [1]

Schritt 5.2: App aus Android Studio installieren

· Kehren Sie auf Ihrem Computer zum Projekt AuraWorkOrders in Android Studio zurück.

· Öffnen Sie das Geräte-Dropdown in der oberen Symbolleiste von Android Studio. Wählen Sie Ihr verbundenes Aura-Entwicklungsgerät statt des Emulators aus.

· Fehlt das Gerät, wählen Sie in Android Studio Tools > Troubleshoot Device Connections und folgen Sie dem Verbindungsassistenten. Prüfen Sie Debugging-Autorisierung und Verbindungsmethode anhand des Onboardings von XREAL.

· Sobald das Gerät erscheint, behalten Sie app als Run-Konfiguration bei und klicken auf die grüne Run-Schaltfläche. Android Studio erstellt, installiert und startet die App auf dem ausgewählten Gerät.

Schritt 5.3: Datensatz in der Brille abrufen

· Setzen Sie Aura auf und suchen Sie das App-Fenster Work instructions, das Android Studio gestartet hat.

· Geben Sie in diesem Fenster dieselbe Test-Auftragsnummer und dasselbe temporäre Token wie in Schritt 4 ein. Nutzen Sie die auf Ihrem Gerät verfügbaren Eingabemethoden; handelsübliche Bluetooth-Tastaturen und -Mäuse funktionieren mit Aura (Settings > Connected Devices > Pair new device), und eine kompatible Bluetooth-Tastatur kann die Testeingabe vereinfachen. [1]

· Wählen Sie Load work order und lesen Sie die Anweisungen dann mithilfe von Next, Previous und Scrollen.

· Vergleichen Sie Auftragsnummer, Anlagenbezeichnung und Anweisungstext mit dem Originaldatensatz in Ihrer Geschäftsanwendung. Stimmen sie überein, haben Sie nachgewiesen, dass die Aura-App diesen Geschäftsdatensatz abrufen und anzeigen kann.

Häufige Probleme und was Sie prüfen sollten

· App lässt sich nicht erstellen: Öffnen Sie in Android Studio View > Tool Windows > Build und lesen Sie den ersten gemeldeten Fehler. Prüfen Sie den Paketnamen und ob das Empty-Activity-Projekt Compose und Material 3 verwendet.

· App kann den Auftrag nicht laden: Vergewissern Sie sich in MainActivity.kt in Android Studio, dass der Beispiel-Hostname ersetzt wurde. Lassen Sie die IT prüfen, ob der Endpunkt aus dem Emulator bzw. dem Aura-Netzwerk erreichbar ist.

· API gibt 401 zurück: Die API hat die Anmeldedaten nicht akzeptiert. Lassen Sie die IT die Gültigkeit des Tokens und den vorgesehenen Dienst prüfen, oder besorgen Sie sich ein neues Test-Token.

· API gibt 403 zurück: Dem Konto fehlt die Berechtigung. Bitten Sie den Administrator des Unternehmenssystems, den richtigen Zugriff zu gewähren.

· API gibt 404 zurück: Prüfen Sie die Auftragsnummer und ob der Endpunkt auf die richtige Testumgebung verweist.

· API liefert Daten, aber die App schlägt fehl: Bitten Sie den API-Entwickler, die Antwort mit der Entwicklerreferenz abzugleichen. Das Beispiel erfordert eine nicht leere steps-Liste und eine id, die dem angeforderten Auftrag entspricht.

· Funktioniert im Emulator, aber nicht auf Aura: Prüfen Sie den Netzwerkpfad und den API-Zugriff von Aura und testen Sie dann die App auf dem Gerät. Deaktivieren Sie keine HTTPS-Zertifikatsprüfungen, um einen Verbindungsfehler zu umgehen.

Das Beispiel zeigt dem Benutzer eine allgemeine Fehlermeldung an. Für den genauen API-Status bitten Sie den Administrator, die Serverprotokolle einzusehen, ohne Tokens oder vollständige Arbeitsaufträge offenzulegen. Bei App-Fehlern nutzen Sie in Android Studio View > Tool Windows > Logcat; Logcat zeigt die Anwendungsprotokolle an.

Entwicklerreferenz für die Beispiel-API

Nutzen Sie diesen Abschnitt, wenn Sie in Schritt 1 die Antwort prüfen oder in Schritt 3 fetchOrder anpassen. Er beschreibt die Schnittstellenvereinbarung für diese Beispiel-App, keinen von XREAL bereitgestellten Endpunkt.

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

Anfrage-Header: Authorization: Bearer <kurzlebiges Zugriffstoken> und Accept: application/json

Erwartete erfolgreiche Antwort: HTTP 200 mit dieser JSON-Struktur

{
  "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 identifiziert den Arbeitsauftrag, asset die zugehörige Anlage und revision die Verfahrensversion. Jeder Eintrag in steps hat eine Nummer, einen Titel, die vollständige Anweisung und ein expectedResult. Das Beispiel sortiert die Schritte nach Nummer.

Verwenden Sie für echte Arbeiten freigegebene Anweisungen; das Beispiel beschreibt eine inaktive Schulungsstation. Validieren Sie vor dem Produktivbetrieb Antwortgröße und Feldlängen, weisen Sie ungültige Verfahrensdaten zurück und legen Sie das Verhalten bei Ablauf des Tokens fest. Die API muss für jeden angeforderten Auftrag die Berechtigung prüfen. Der Beispielcode dient der Veranschaulichung und wurde weder kompiliert noch mit einem Live-System oder einem physischen Aura-Gerät getestet.

Fazit

Die Anbindung von XREAL Aura an ein Unternehmenssystem beginnt mit einer freigegebenen API-Adresse und einer Zugriffsberechtigung, gefolgt von einer Android-Studio-App, die den benötigten Datensatz abruft. Wenn Sie die Verbindung zunächst auf einem Computer testen, bevor Sie sie auf Aura bereitstellen, lassen sich Probleme beim Datenzugriff leichter von solchen bei der Geräteeinrichtung unterscheiden. Das Beispiel mit dem Arbeitsauftrag bringt Anlagendaten und Schritt-für-Schritt-Anweisungen auf eine gut lesbare Brillenanzeige und bietet Unternehmen damit einen praxisnahen Ausgangspunkt, um betriebliche Informationen direkt am Arbeitsplatz verfügbar zu machen. Unternehmensanmeldung, passende Berechtigungen und Gerätetests bereiten diese Verbindung auf ein Pilotprojekt mit Mitarbeitenden vor.

Besprechen Sie die Hardwareverfügbarkeit und Ihre Anforderungen an das Pilotprojekt mit VR Expert.

João Noronha

Geschrieben von

João Noronha

XR- und Immersive-Content-Spezialist bei VR Expert

João Noronha ist XR- und Immersive-Content-Spezialist bei VR Expert und interessiert sich besonders für neue Technologien und deren praktische Anwendungen. Er konzentriert sich darauf, komplexe Entwicklungen in den Bereichen VR, AR, KI-Brillen und immersive Technologie in klare, praxisnahe Inhalte für Unternehmen und Fachleute zu übersetzen, die sich mit der XR-Branche befassen.

Häufig gestellte Fragen

Dieser Artikel

Ein System benötigt eine zugängliche API, eine freigegebene Authentifizierungsmethode und die Berechtigung, die benötigten Datensätze abzurufen. ERP-Software (Enterprise Resource Planning) koordiniert Geschäftsprozesse, während Instandhaltungsmanagement-Software die Wartung von Anlagen organisiert. Ihre APIs und Datenstrukturen unterscheiden sich, daher muss jede Integration anhand des konkreten Produkts und seiner Konfiguration geprüft werden.

Google unterstützt Standard-Android-Oberflächen in Android-XR-Systempanels. 2D-Mobil-Apps und Android-Apps für große Bildschirme funktionieren unter Android XR standardmäßig und werden als 2D-Panel in einem XR-/3D-Raum angezeigt. Testen Sie Anmeldung, Netzwerkzugriff, Darstellung und Eingabe der App auf Aura, bevor Sie sie für Mitarbeitende freigeben. Eine bestehende App, die die benötigten Datensätze bereits bereitstellt, kann den Entwicklungsaufwand verringern. [4]

Ein Standard-Android-App-Fenster kann den Arbeitsauftrag und seine Anweisungen anzeigen. Benutzerdefinierte Jetpack-XR-Panels sind eine optionale Erweiterung, wenn eine bestimmte Aufgabe von einer anderen Anordnung der Informationen profitiert. [4]

Eine interne Unternehmens-API kann über ein freigegebenes lokales oder privates Netzwerk erreichbar sein. Das Gerät muss dennoch die API und alle für die Authentifizierung erforderlichen Dienste erreichen können. Das Beispiel erfordert eine aktive Verbindung und speichert keine Arbeitsaufträge für die Offline-Nutzung.

Das Beispiel ruft Informationen ab und zeigt sie an. Für das Übermitteln von Ergebnissen sind eine zusätzliche API-Operation, eine Benutzerberechtigung und eine Bestätigungsoberfläche erforderlich. Der Server muss die Übermittlung validieren und wiederholte Anfragen sicher verarbeiten.