Cómo crear tu primera aplicación empresarial para XREAL Aura con Android Studio

Cómo crear tu primera aplicación empresarial para XREAL Aura con Android Studio

Resumen ejecutivo

Esta guía muestra cómo crear una aplicación empresarial para XREAL Aura en Android Studio con Kotlin y el Jetpack XR SDK. Crearás un proyecto, añadirás la biblioteca de interfaz espacial, pegarás un pequeño ejemplo de panel de tareas y lo ejecutarás en el emulador de XR Glasses antes de probarlo en hardware Aura.

El ejemplo muestra instrucciones de trabajo y permite a los usuarios confirmar cada tarea. Es un punto de partida para una aplicación empresarial, sin registros de trabajo permanentes ni verificación de que una tarea física se haya completado. El código sigue la documentación revisada, pero no se ha compilado ni probado en hardware Aura.

Introducción

Crear una aplicación empresarial para XREAL Aura empieza en Android Studio, donde escribes código Kotlin y utilizas el Jetpack XR SDK para añadir una interfaz espacial. Esta guía te lleva desde la creación de un proyecto hasta su ejecución en un emulador y su prueba en Aura. Como ejemplo sencillo, crearás un panel que muestra instrucciones de trabajo y permite al usuario confirmar cada tarea.

XREAL Aura combina unas gafas con cable con un puck de computación Android XR. Sigue el flujo de trabajo de Android XR para gafas XR con cable, y no el flujo independiente para gafas de audio y pantalla proyectadas desde el teléfono. Para obtener contexto sobre el hardware, consulta la descripción general de XREAL Aura de VRX y la página oficial de Aura de XREAL. [1]

Antes de empezar

· Utiliza un ordenador aprobado por la empresa con acceso a internet para las descargas iniciales

· Consulta los requisitos del sistema del emulador XR de Google, que actualmente abarcan configuraciones compatibles de Windows y macOS [2]

· Para las pruebas físicas, consigue las gafas Aura, su puck de computación y las instrucciones de conexión para desarrolladores del kit

Disponibilidad: Confirma el suministro regional con VR Expert. La página actual de XREAL da prioridad a EE. UU., Canadá, Japón y Corea del Sur; las listas de reserva antiguas no deben considerarse una entrega confirmada en Europa. [1]

Paso 1. Instala Android Studio y sus herramientas del SDK

Empieza instalando Android Studio y las herramientas del SDK que se utilizan para compilar la aplicación, ejecutar un dispositivo XR simulado y conectarse al hardware.

Google recomienda Android Studio Canary para XR. Canary es una edición preliminar con herramientas más recientes y funciones posiblemente sin terminar; puedes instalarla junto a tu Android Studio actual.

· Abre Android Studio Preview, descarga el instalador adecuado y completa el asistente de instalación.

· En la pantalla de bienvenida de Android Studio, selecciona More Actions > SDK Manager. Si ya hay un proyecto abierto, utiliza Tools > SDK Manager en el menú superior.

· En la ventana de configuración de SDK Manager, busca las pestañas SDK Platforms y SDK Tools, encima de la lista de paquetes instalables. Ambas pestañas forman parte de la misma ventana de SDK Manager.

· Selecciona SDK Tools. Marca Android SDK Build-Tools, Android Emulator y Android SDK Platform-Tools. Mantenlos seleccionados si ya están instalados y aplica las actualizaciones disponibles. Build-Tools prepara el archivo de instalación de la aplicación, Emulator ejecuta dispositivos simulados y Platform-Tools incluye ADB, la herramienta de conexión con dispositivos.

· Haz clic en Apply, revisa las descargas seleccionadas, acepta las licencias necesarias y espera a que termine la instalación. Haz clic en OK para cerrar la ventana.

La pestaña SDK Platforms instala la plataforma Android que se utiliza para compilar la aplicación. La versión necesaria viene determinada por la configuración del proyecto. Crea el proyecto en el paso 2 y, después, utiliza su ajuste compileSdk para seleccionar la plataforma correspondiente. El paso 6 trata la imagen del sistema del emulador XR, que proporciona el sistema operativo del dispositivo simulado.

Punto de control: Las tres herramientas del SDK están instaladas. Ya puedes crear el proyecto. [3, 13]

Paso 2. Crea el proyecto de la aplicación empresarial para XREAL Aura

La plantilla de proyecto XR crea los archivos iniciales y la configuración de compilación de la aplicación. Sigue las instrucciones para proyectos Android XR de Google correspondientes a la versión de Studio que tengas instalada. [4]

· En Android Studio > vuelve a la pantalla de bienvenida y haz clic en New Project, o elige File > New > New Project.

· Selecciona XR en la lista de plantillas y, a continuación, la plantilla para cascos XR y gafas XR con cable. La página de proyectos de Google ya no nombra las plantillas (indica que se elija la plantilla que corresponda al tipo de dispositivo XR para el que se quiere desarrollar) y los nombres pueden cambiar entre versiones Canary, así que toma el nombre exacto del IDE para la captura de pantalla. No elijas la plantilla de gafas de audio o pantalla, que crea una experiencia proyectada desde el teléfono.

· Haz clic en Next. Introduce AuraTaskPanel en Name. En Package name, introduce com.example.aurataskpanel para este tutorial. Selecciona Kotlin si aparece una opción de lenguaje. El nombre del paquete identifica el código de la aplicación y puede personalizarse para tu organización. Se introduce en Android Studio como un identificador separado por puntos, sin https:// ni una ruta de dirección web.

A continuación, mantén los ajustes de compilación de la plantilla generada y haz clic en Finish. Espera a que termine la primera sincronización de Gradle. La sincronización hace que Android Studio lea la configuración de compilación y resuelva sus dependencias.

Abre View > Tool Windows > Project y, a continuación, selecciona Android en el selector de vista del panel. Utilizarás estos archivos:

· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Contiene el punto de entrada y la interfaz de la aplicación; algunas versiones llaman java a la carpeta de código fuente

· AndroidManifest.xml: app > manifests. Declara el punto de entrada, los permisos y los ajustes de inicio de la aplicación

· build.gradle.kts (Module :app): Gradle Scripts. Configura la compilación y las bibliotecas de la aplicación

Instala la plataforma que solicita tu proyecto

El ajuste compileSdk indica a Android Studio qué conjunto de API de Android debe usar al compilar la aplicación. Instala la plataforma del SDK correspondiente; no elijas una basándote solo en la marca de las gafas.

· En el panel Project de Android Studio, abre Gradle Scripts > build.gradle.kts (Module :app). En el bloque android, busca compileSdk. Un valor como compileSdk = 36 significa que el proyecto necesita Android API 36. Este número es un ejemplo, no un valor obligatorio para todos los proyectos de Aura.

· Si el valor apunta a una entrada del catálogo, como libs.versions.compileSdk, abre Gradle Scripts > libs.versions.toml y lee el valor al que hace referencia. Si la plantilla utiliza un nombre de versión preliminar o una configuración compileSdk anidada, conserva ese ajuste y utiliza la plataforma correspondiente.

· Abre Tools > SDK Manager > SDK Platforms. Selecciona la fila cuyo API Level coincida con el ajuste del proyecto. Haz clic en Apply, completa la descarga y, después, haz clic en OK.

· Vuelve al proyecto y selecciona File > Sync Project with Gradle Files, o Sync Now si aparece en un banner. La sincronización de Gradle lee los ajustes de compilación y descarga las bibliotecas que necesita el proyecto.

Mantén el ajuste de plataforma de la plantilla. Si Android Studio indica que falta una plataforma, instálala en lugar de reducir compileSdk para evitar la descarga. La imagen del dispositivo XR que se usa para las pruebas se selecciona por separado en el paso 6. [13]

Punto de control: La plataforma del SDK necesaria está instalada y la ventana de herramientas Build o Sync no muestra errores sin resolver.

Paso 3. Añade la biblioteca XR y comprueba la compatibilidad de Kotlin

Añade Jetpack Compose for XR para dotar a la aplicación de componentes de panel espacial, y comprueba la compatibilidad de Kotlin para que el proyecto pueda compilar esa biblioteca sin errores de versión. Este ejemplo utiliza XR Compose 1.0.0-beta02 (21-10-2026, todavía la versión más reciente), que requiere Kotlin 2.2, según las notas de la versión de Google. Esas mismas notas indican que beta02 depende de SceneCore 1.0.0-rc01, que tiene una fuga de memoria conocida, así que añade implementation (“androidx.xr.scenecore:1.0.0”) o una versión posterior a la línea de Compose del paso 3.

Comprueba la versión de Kotlin una sola vez

· En Android Studio, despliega Gradle Scripts y, a continuación, haz clic para abrir libs.versions.toml. Este archivo, cuando existe, es la lista central de versiones de bibliotecas y plugins del proyecto.

· En [versions], busca la entrada de Kotlin, normalmente kotlin = "2.2.0" u otra versión 2.2.x. Mantén la versión compatible que proporciona la plantilla actual.

· Si el proyecto utiliza el plugin org.jetbrains.kotlin.plugin.compose, su versión debe coincidir con la de Kotlin. Las plantillas suelen hacer que ambos hagan referencia a la misma entrada de versión de Kotlin; conserva ese vínculo.

· Si no hay entrada de Kotlin ni catálogo, revisa el archivo build.gradle.kts de nivel superior en busca de plugins de Kotlin declarados explícitamente. Algunas configuraciones de compilación más recientes gestionan Kotlin a través de las herramientas de compilación de Android. En ese caso, mantén la configuración generada y comprueba la compatibilidad de Kotlin de la cadena de herramientas si aparece un error de compilación; no añadas un segundo plugin de Kotlin solo para crear una entrada de versión.

Si la plantilla ya proporciona herramientas de Kotlin compatibles, no cambies nada. Si una compilación indica que Kotlin es demasiado antiguo para la biblioteca XR, actualiza a la vez las herramientas de Kotlin del proyecto y el plugin del compilador de Compose correspondiente, si lo hay, utilizando la configuración compatible con esa plantilla. Evita cambiar ajustes de compilación no relacionados.

Añade la dependencia de interfaz espacial

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

· Busca el bloque dependencies { ... } existente.

· Busca una dependencia de XR Compose, ya sea escrita directamente o mediante un alias como implementation(libs.androidx.xr.compose). Si ya existe un alias, establece la versión de XR Compose a la que hace referencia en 1.0.0-beta02 en libs.versions.toml. No añadas la misma biblioteca dos veces.

· Si XR Compose no está presente, añade esta línea dentro del bloque dependencies existente:

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

Mantén las demás dependencias de la plantilla. En concreto, el código siguiente utiliza la biblioteca estándar Material 3, que proporciona sus botones, texto y tema, y Activity Compose, que aloja contenido de Compose en una Activity de Android.

Sincroniza y continúa

Haz clic en Sync Now en el banner del editor, o en File > Sync Project with Gradle Files. Espera a que termine el proceso de descarga y configuración.

Punto de control: La sincronización se completa sin errores de dependencias ni de compatibilidad de Kotlin. Si la sincronización se realiza correctamente, mantén el resto de ajustes de compilación generados y, después, abre MainActivity.kt para añadir la interfaz. Si la sincronización indica un error de dependencia, compara el componente mencionado con la página de configuración del Jetpack XR SDK de Google. [6]

Paso 4. Crea el panel de tareas en Kotlin

La interfaz muestra el texto de la tarea con un botón Mark complete y un botón Restart demo. Más adelante, las instrucciones de ejemplo pueden sustituirse por un procedimiento de trabajo aprobado.

En el mismo archivo MainActivity.kt de Android Studio, conserva la línea del paquete si tu paquete es distinto y, a continuación, sustituye el resto del archivo por el código siguiente. Elimina de este archivo las antiguas funciones de ejemplo y de vista previa de la plantilla para que solo haya una MainActivity. Una Activity es un punto de entrada de Android que aloja una interfaz. El ejemplo siguiente incluye la Activity y sus importaciones.

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

Qué hace el código

· steps contiene el texto de las instrucciones

· completed cuenta las confirmaciones e impide avanzar más allá de la última tarea

· rememberSaveable conserva ese pequeño valor durante la recreación de pantalla y la restauración de estado compatibles de Android; no es un almacenamiento permanente

· LocalSpatialCapabilities comprueba si la UI espacial está disponible [7]

· Subspace crea un área para el contenido espacial, y SpatialPanel coloca la interfaz dentro de ella [8]

· La rama alternativa muestra el mismo contenido en una ventana normal cuando la UI espacial no está disponible

La unidad dp escala las dimensiones del diseño según la densidad de pantalla; sp escala el texto y respeta las preferencias de tamaño de fuente. El contenedor con desplazamiento mantiene accesibles las instrucciones más largas. Considera el tamaño del panel como un punto de partida y comprueba la legibilidad en Aura.

Punto de control: Android Studio reconoce las importaciones y no muestra errores de sintaxis de Kotlin. Si la biblioteca instalada requiere la aceptación explícita (opt-in) de una API experimental, utiliza la anotación exacta que indique el diagnóstico del compilador y consulta la referencia de la API de esa versión.

Paso 5. Comprueba cómo se inicia la aplicación en Android XR

Configura el modo de inicio para que Android XR pueda abrir la aplicación con el diseño espacial que se utiliza en este ejemplo.

En las gafas Aura, Home Space y Full Space ya están integrados en Android XR y controlan cómo aparecen las aplicaciones en ejecución. El emulador de XR Glasses ofrece estos modos para el desarrollo, por lo que no es necesaria ninguna instalación adicional.

En el panel Project de Android Studio > abre app > manifests > AndroidManifest.xml y revisa la entrada de MainActivity. Conserva su intent filter MAIN y LAUNCHER, el ajuste exported y el tema generado. Para Full Space gestionado por Compose, la propiedad correspondiente se muestra a continuación. Si la plantilla ya declara una propiedad de inicio a nivel de aplicación o de Activity, edita el valor existente correspondiente en lugar de duplicarlo. [9]

<!-- Inside the existing MainActivity element -->
<property
    android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
    android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />

Managed Full Space significa que Android gestiona la escena espacial de la Activity. El valor UNMANAGED está pensado para aplicaciones que renderizan mediante OpenXR, una interfaz XR multiplataforma; este ejemplo de Compose no lo utiliza. Consulta la referencia de constantes del manifiesto al comparar plantillas. [9]

En el elemento application existente, conserva o añade también android:enableOnBackInvokedCallback="true" para que el panel espacial reciba los eventos de retroceso, tal como documenta la guía de paneles de Google; su ejemplo lo establece en el elemento activity, y también es válido en el elemento application. No añadas permisos de cámara, micrófono ni comprensión de la escena para esta lista de comprobación estática. La aplicación no lee la sala ni identifica objetos. [8]

Paso 6. Crea un emulador de gafas XR y ejecuta la aplicación

Ejecuta la aplicación en un dispositivo de gafas XR simulado antes de conectar Aura. Un emulador simula un dispositivo en tu ordenador; un AVD es su configuración guardada.

· En Android Studio > abre Tools > Device Manager. Haz clic en el control para añadir dispositivos y elige Create Virtual Device.

· En Form Factor, elige XR y, a continuación, XR Glasses. Haz clic en Next.

· Selecciona la imagen del sistema Preview API necesaria para el perfil XR Glasses y descárgala si se te solicita. Elige la arquitectura de imagen compatible con tu ordenador. Completa la configuración.

· Inicia el AVD con su control de reproducción. Espera a que el entorno Android XR termine de cargarse.

· En la barra de herramientas superior de Android Studio, selecciona la configuración de ejecución de la aplicación y el dispositivo XR Glasses en ejecución. Haz clic en Run, el triángulo verde.

El emulador instala y abre la aplicación. Utiliza sus controles de entrada para activar Mark complete. Si el panel permanece en Home Space, revisa el manifiesto y los controles de Full Space del entorno antes de modificar el diseño de Kotlin. Consulta las instrucciones oficiales sobre AVD.

Realiza esta comprobación de aceptación:

· La primera pantalla muestra cero de tres tareas confirmadas y la primera instrucción

· Cada activación de Mark complete avanza exactamente una instrucción

· La tercera activación muestra Checklist complete y desactiva Mark complete

· Restart demo restablece la primera instrucción y cero confirmaciones

· El texto más largo sigue siendo accesible mediante desplazamiento

· El contenido sigue apareciendo cuando la UI espacial no está disponible

Una prueba satisfactoria en el emulador valida parte de la lógica y el diseño de la aplicación. No valida la óptica de Aura, la fiabilidad de la entrada ni la idoneidad para el lugar de trabajo.

Paso 7. Despliega en hardware Aura autorizado

Los pasos siguientes se basan en el proceso estándar de depuración de Android. Los menús y las opciones de conexión de Aura pueden variar según la versión de software, así que sigue las instrucciones específicas del kit cuando difieran.

Conecta Aura y ejecuta la aplicación

· Inicia Aura con las gafas conectadas y abre la aplicación Settings del dispositivo

· En Aura > en su interfaz de ajustes > activa las Developer options y la depuración siguiendo las instrucciones del kit; consigue la guía de configuración para desarrolladores si esos controles no están disponibles

· Conecta el ordenador al puerto de carga (Charging Port, lado izquierdo) del puck de computación con un cable USB de datos y deja las gafas en el puerto de las gafas (Glasses Port, lado derecho); si eso no funciona, conéctalo al puerto del lado derecho para disponer de compatibilidad completa con ADB.

· Acepta la solicitud de autorización de depuración del dispositivo; un dispositivo gestionado puede requerir la aprobación de un administrador

· En la barra de herramientas superior de Android Studio, selecciona Aura en el desplegable de dispositivos y haz clic en Run

· En Aura, repite las comprobaciones del panel de tareas del paso 6, incluidos el avance de tareas y el reinicio de la lista de comprobación

Solución de problemas de conexión del dispositivo

Si Aura no aparece en el selector de destino de Android Studio, verifica la conexión mediante ADB:

  1. Abre View > Tool Windows > Terminal en Android Studio.
  1. Ejecuta el siguiente comando:
adb devices -l

Comprueba el resultado:

· Si tu dispositivo aparece con el estado device, está conectado y autorizado.

· Si aparece unauthorized, ponte las gafas y acepta la solicitud de depuración USB en la pantalla.

· Si la lista está vacía, vuelve a comprobar el cable USB de datos, asegúrate de que el puck de computación esté encendido y confirma que la depuración USB sigue activada en Settings.

Conclusión

Crear una primera aplicación empresarial para XREAL Aura empieza con Android Studio, Kotlin y el Jetpack XR SDK, y avanza desde un sencillo panel de instrucciones de trabajo hasta las pruebas en el emulador y el despliegue en hardware autorizado. Este enfoque ofrece a las empresas una forma acotada de evaluar si las instrucciones espaciales mejoran un flujo de trabajo real antes de invertir en integraciones y en el despliegue a toda la flota. Cuando el panel sea legible, utilizable y esté validado en Aura, el siguiente paso es conectar procedimientos aprobados y registros de trabajo fiables con los sistemas de la empresa.

Habla con VR Expert sobre la disponibilidad de Aura y los requisitos de hardware, desarrollo de software y soporte para el piloto de tu empresa.

João Noronha

Escrito por

João Noronha

Especialista en XR y Contenido Inmersivo en VR Expert

João Noronha es Especialista en XR y Contenido Inmersivo en VR Expert, con un gran interés por las tecnologías emergentes y sus aplicaciones en el mundo real. Se dedica a transformar los avances complejos en VR, AR, gafas de IA y tecnología inmersiva en contenido claro y práctico para empresas y profesionales que exploran el sector XR.

Preguntas frecuentes

Este artículo

Sí. Empieza con el emulador de Android XR Glasses para desarrollar la interfaz y el flujo de tareas. Las pruebas físicas en Aura siguen siendo necesarias antes de un piloto en el lugar de trabajo.

No. Android Studio, Kotlin y Jetpack Compose for XR son adecuados para este ejemplo centrado en la interfaz. Unity es un motor de desarrollo independiente que puede ser apropiado para proyectos con abundante contenido 3D interactivo.

No. Proporciona capacidades XR. Tu equipo sigue teniendo que implementar y validar los requisitos de seguridad, almacenamiento de datos, identidad, distribución, soporte e integración.

No. Muestra texto almacenado localmente y registra las confirmaciones en el estado de la UI. El reconocimiento de equipos, la comprensión de la escena y los registros de trabajo verificados requieren diseño e implementación adicionales.

Este ejemplo no implementa un anclaje físico persistente. Un anclaje es una referencia espacial que se utiliza para posicionar contenido en relación con una ubicación; la colocación específica para una máquina requiere un flujo de anclaje adicional compatible y validación en el dispositivo.