Resumo executivo
Este guia mostra como criar uma aplicação empresarial para XREAL Aura no Android Studio com o Kotlin e o Jetpack XR SDK. Vai criar um projeto, adicionar a biblioteca de interface espacial, colar um pequeno exemplo de painel de tarefas e executá-lo no emulador XR Glasses antes de o testar no hardware Aura.
O exemplo apresenta instruções de trabalho e permite aos utilizadores confirmar cada tarefa. É um ponto de partida para uma aplicação empresarial, sem registos de trabalho permanentes nem verificação de que uma tarefa física foi concluída. O código segue a documentação analisada, mas não foi compilado nem testado em hardware Aura.
Introdução
A criação de uma aplicação empresarial para XREAL Aura começa no Android Studio, onde escreve código Kotlin e utiliza o Jetpack XR SDK para adicionar uma interface espacial. Este guia acompanha-o desde a criação de um projeto até à sua execução num emulador e ao teste no Aura. Como exemplo simples, vai construir um painel que apresenta instruções de trabalho e permite ao utilizador confirmar cada tarefa.
O XREAL Aura combina óculos com ligação por cabo com um puck de computação Android XR. Siga o fluxo de trabalho Android XR para óculos XR com cabo, e não o fluxo separado para óculos de áudio e ecrã com projeção a partir do telemóvel. Para contexto sobre o hardware, consulte a visão geral do XREAL Aura da VRX e a página oficial do Aura da XREAL. [1]
Antes de começar
· Utilize um computador aprovado pela empresa com acesso à Internet para as transferências iniciais
· Consulte os requisitos de sistema do emulador XR da Google, que atualmente abrangem configurações Windows e macOS suportadas [2]
· Para testes físicos, obtenha os óculos Aura, o respetivo puck de computação e as instruções de ligação para programadores do kit
Disponibilidade: Confirme o fornecimento na sua região com a VR Expert. A página atual da XREAL dá prioridade aos EUA, Canadá, Japão e Coreia do Sul; as listas de reserva mais antigas não devem ser consideradas como entrega confirmada na Europa. [1]
Passo 1 Instalar o Android Studio e as respetivas ferramentas SDK
Comece por instalar o Android Studio e as ferramentas SDK utilizadas para compilar a aplicação, executar um dispositivo XR simulado e ligar ao hardware.
A Google recomenda o Android Studio Canary para XR. O Canary é uma edição de pré-visualização com ferramentas mais recentes e funcionalidades potencialmente inacabadas; pode instalá-lo em paralelo com o Android Studio que já tem.
· Abra o Android Studio Preview, transfira o instalador adequado e conclua o assistente de instalação.
· No ecrã de boas-vindas do Android Studio, selecione More Actions > SDK Manager. Se já tiver um projeto aberto, utilize Tools > SDK Manager no menu superior.
· Na janela de definições do SDK Manager, encontre os separadores SDK Platforms e SDK Tools, por cima da lista de pacotes instaláveis. Ambos os separadores fazem parte da mesma janela do SDK Manager.
· Selecione SDK Tools. Assinale Android SDK Build-Tools, Android Emulator e Android SDK Platform-Tools. Mantenha-os selecionados se já estiverem instalados; aplique as atualizações disponíveis. O Build-Tools prepara o ficheiro de instalação da aplicação, o Emulator executa dispositivos simulados e o Platform-Tools inclui a ferramenta de ligação a dispositivos ADB.
· Clique em Apply, reveja as transferências selecionadas, aceite as licenças necessárias e aguarde pela instalação. Clique em OK para fechar a janela.
O separador SDK Platforms instala a plataforma Android utilizada para compilar a aplicação. A versão necessária é determinada pela configuração do projeto. Crie o projeto no Passo 2 e, em seguida, utilize a definição compileSdk para selecionar a plataforma correspondente. O Passo 6 aborda a imagem de sistema do emulador XR, que fornece o sistema operativo do dispositivo simulado.
Ponto de verificação: As três ferramentas SDK estão instaladas. Já pode criar o projeto. [3, 13]
Passo 2 Criar o projeto da aplicação empresarial para XREAL Aura
O modelo de projeto XR cria os ficheiros iniciais e a configuração de compilação da aplicação. Siga as instruções de projeto Android XR da Google para a versão do Studio que tem instalada. [4]
· No Android Studio > regresse ao ecrã de boas-vindas e clique em New Project, ou escolha File > New > New Project.
· Selecione XR na lista de modelos e, em seguida, o modelo para headsets XR e óculos XR com cabo. A página de projeto da Google já não indica os nomes dos modelos (diz para escolher o modelo que corresponde ao tipo de dispositivo XR para o qual pretende desenvolver) e os nomes podem mudar entre versões Canary, por isso retire o nome exato do IDE para a captura de ecrã. Não escolha o modelo de óculos de áudio ou de ecrã, que cria uma experiência projetada a partir do telemóvel.
· Clique em Next. Introduza AuraTaskPanel em Name. Em Package name, introduza com.example.aurataskpanel para este tutorial. Selecione Kotlin se surgir uma opção de linguagem. O nome do pacote identifica o código da aplicação e pode ser personalizado para a sua organização. É introduzido no Android Studio como um identificador separado por pontos, sem https:// nem caminho de endereço web.
Em seguida, mantenha as definições de compilação do modelo gerado e clique em Finish. Aguarde pela conclusão da primeira sincronização do Gradle. A sincronização faz com que o Android Studio leia a configuração de compilação e resolva as respetivas dependências.
Abra View > Tool Windows > Project e, em seguida, selecione Android no seletor de vista do painel. Vai utilizar estes ficheiros:
· MainActivity.kt: app > kotlin+java > com.example.aurataskpanel. Contém o ponto de entrada e a interface da aplicação; algumas versões designam a pasta de origem por java
· AndroidManifest.xml: app > manifests. Declara o ponto de entrada, as permissões e as definições de arranque da aplicação
· build.gradle.kts (Module :app): Gradle Scripts. Configura a compilação e as bibliotecas da aplicação
Instalar a plataforma pedida pelo projeto
A definição compileSdk indica ao Android Studio que conjunto de API Android deve utilizar ao compilar a aplicação. Instale a plataforma SDK correspondente; não escolha uma apenas com base na marca dos óculos.
· No painel Project do Android Studio, abra Gradle Scripts > build.gradle.kts (Module :app). No bloco android, encontre compileSdk. Um valor como compileSdk = 36 significa que o projeto precisa da Android API 36. Este número é um exemplo, não um valor obrigatório para todos os projetos Aura.
· Se o valor remeter para uma entrada de catálogo, como libs.versions.compileSdk, abra Gradle Scripts > libs.versions.toml e leia o valor referenciado. Se o modelo utilizar um nome de pré-visualização ou uma configuração compileSdk aninhada, mantenha essa definição e utilize a plataforma correspondente.
· Abra Tools > SDK Manager > SDK Platforms. Selecione a linha cujo API Level corresponde à definição do projeto. Clique em Apply, conclua a transferência e, depois, clique em OK.
· Regresse ao projeto e selecione File > Sync Project with Gradle Files, ou Sync Now se surgir uma faixa com essa opção. A sincronização do Gradle lê as definições de compilação e transfere as bibliotecas necessárias para o projeto.
Mantenha a definição de plataforma do modelo. Se o Android Studio indicar que falta uma plataforma, instale essa plataforma em vez de baixar o compileSdk para evitar a transferência. A imagem de dispositivo XR utilizada nos testes é selecionada separadamente no Passo 6. [13]
Ponto de verificação: A plataforma SDK necessária está instalada e a janela de ferramentas Build ou Sync não apresenta erros por resolver.
Passo 3 Adicionar a biblioteca XR e verificar a compatibilidade do Kotlin
Adicione o Jetpack Compose for XR para dar à aplicação componentes de painel espacial e verifique a compatibilidade do Kotlin para que o projeto consiga compilar essa biblioteca sem erros de versão. Este exemplo utiliza o XR Compose 1.0.0-beta02 (21-10-2026, ainda a versão mais recente), que requer o Kotlin 2.2, de acordo com as notas de versão da Google. As mesmas notas indicam que a beta02 depende do SceneCore 1.0.0-rc01, que tem uma fuga de memória conhecida, por isso adicione implementation (“androidx.xr.scenecore:1.0.0”) ou uma versão mais recente à linha do Compose no Passo 3.
Verificar a versão do Kotlin uma única vez
· No Android Studio, expanda Gradle Scripts e, em seguida, clique para abrir libs.versions.toml. Este ficheiro, quando existe, é a lista central de versões de bibliotecas e plugins do projeto.
· Em [versions], procure a entrada do Kotlin, normalmente kotlin = "2.2.0" ou outra versão 2.2.x. Mantenha a versão compatível fornecida pelo modelo atual.
· Se o projeto utilizar o plugin org.jetbrains.kotlin.plugin.compose, a respetiva versão tem de corresponder à do Kotlin. Os modelos costumam fazer com que ambos remetam para a mesma entrada de versão do Kotlin; mantenha essa ligação.
· Se não existir uma entrada do Kotlin nem um catálogo, inspecione o ficheiro build.gradle.kts de nível superior para ver se há plugins Kotlin declarados explicitamente. Algumas configurações de compilação mais recentes gerem o Kotlin através das ferramentas de compilação Android. Nesse caso, mantenha a configuração gerada e verifique a compatibilidade do Kotlin da toolchain se surgir um erro de compilação; não adicione um segundo plugin Kotlin apenas para criar uma entrada de versão.
Se o modelo já fornecer ferramentas Kotlin compatíveis, não altere nada. Se uma compilação indicar que o Kotlin é demasiado antigo para a biblioteca XR, atualize em conjunto as ferramentas Kotlin do projeto e qualquer plugin do compilador Compose correspondente, utilizando a configuração suportada para esse modelo. Evite alterar definições de compilação não relacionadas.
Adicionar a dependência da interface espacial
· Abra Gradle Scripts > build.gradle.kts (Module :app).
· Encontre o bloco dependencies { ... } existente.
· Procure uma dependência do XR Compose, escrita diretamente ou através de um alias como implementation(libs.androidx.xr.compose). Se já existir um alias, defina a versão do XR Compose a que este remete como 1.0.0-beta02 em libs.versions.toml. Não adicione a mesma biblioteca duas vezes.
· Se o XR Compose não estiver presente, adicione esta linha dentro do bloco dependencies existente:
implementation("androidx.xr.compose:compose:1.0.0-beta02")Mantenha as restantes dependências do modelo. Em particular, o código abaixo utiliza o Material 3 normal, a biblioteca que fornece os botões, o texto e o tema, e o Activity Compose, que aloja conteúdo Compose numa Activity Android.
Sincronizar e continuar
Clique em Sync Now na faixa do editor, ou em File > Sync Project with Gradle Files. Aguarde que o processo de transferência e configuração termine.
Ponto de verificação: A sincronização é concluída sem erros de dependências nem de compatibilidade do Kotlin. Quando a sincronização for bem-sucedida, mantenha as restantes definições de compilação geradas e abra o MainActivity.kt para adicionar a interface. Se a sincronização indicar um erro de dependência, compare o componente indicado com a página de configuração do Jetpack XR SDK da Google. [6]
Passo 4 Construir o painel de tarefas em Kotlin
A interface apresenta o texto da tarefa com um botão Mark complete e um botão Restart demo. As instruções de exemplo podem mais tarde ser substituídas por um procedimento de trabalho aprovado.
No mesmo Android Studio > MainActivity.kt, mantenha a linha package se o seu pacote for diferente e, em seguida, substitua o resto do ficheiro pelo código abaixo. Remova deste ficheiro as antigas funções de exemplo e de pré-visualização do modelo, para que exista apenas uma MainActivity. Uma Activity é um ponto de entrada Android que aloja uma interface. O exemplo abaixo inclui a Activity e as respetivas importações.
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)
}
}
}
}O que o código faz
· steps contém o texto das instruções
· completed conta as confirmações e impede o avanço para além da última tarefa
· rememberSaveable conserva esse pequeno valor durante a recriação de ecrã e o restauro de estado suportados pelo Android; não é armazenamento permanente
· LocalSpatialCapabilities verifica se a IU espacial está disponível [7]
· Subspace cria uma área para conteúdo espacial e SpatialPanel coloca a interface dentro dela [8]
· O ramo alternativo mostra o mesmo conteúdo numa janela normal quando a IU espacial não está disponível
A unidade dp ajusta as dimensões do esquema à densidade do ecrã; a sp ajusta o texto e respeita as preferências de tamanho de letra. O contentor de deslocamento mantém acessíveis as instruções mais longas. Considere o tamanho do painel como um ponto de partida e verifique a legibilidade no Aura.
Ponto de verificação: O Android Studio reconhece as importações e não apresenta erros de sintaxe Kotlin. Se a biblioteca instalada exigir uma ativação (opt-in) de API experimental, utilize a anotação exata indicada no diagnóstico do compilador e consulte a referência de API dessa versão.
Passo 5 Verificar como a aplicação arranca no Android XR
Configure o modo de arranque para que o Android XR possa abrir a aplicação com o esquema espacial utilizado neste exemplo.
Nos óculos Aura, o Home Space e o Full Space já estão integrados no Android XR e controlam a forma como as aplicações em execução são apresentadas. O emulador XR Glasses disponibiliza estes modos para desenvolvimento, pelo que não é necessária qualquer instalação adicional.
No painel Project do Android Studio > abra app > manifests > AndroidManifest.xml e inspecione a entrada MainActivity. Mantenha o filtro de intenção MAIN e LAUNCHER, a definição exported e o tema gerado. Para o Full Space gerido pelo Compose, a propriedade relevante é apresentada abaixo. Se o modelo já declarar uma propriedade de arranque ao nível da aplicação ou da Activity, edite o valor existente relevante em vez de o duplicar. [9]
<!-- Dentro do elemento MainActivity existente -->
<property
android:name="android.window.PROPERTY_XR_ACTIVITY_START_MODE"
android:value="XR_ACTIVITY_START_MODE_FULL_SPACE_MANAGED" />Full Space gerido significa que o Android gere a cena espacial da Activity. O valor UNMANAGED destina-se a aplicações que renderizam através do OpenXR, uma interface XR multiplataforma; este exemplo em Compose não o utiliza. Consulte a referência de constantes do manifesto quando comparar modelos. [9]
No elemento application existente, mantenha ou adicione também android:enableOnBackInvokedCallback="true" para que o painel espacial receba eventos de retrocesso, conforme documentado no guia de painéis da Google; o exemplo desse guia define-o no elemento activity, mas também é válido no elemento application. Não adicione permissões de câmara, microfone ou compreensão da cena para esta lista de verificação estática. Esta não lê a divisão nem identifica objetos. [8]
Passo 6 Criar um emulador de óculos XR e executar a aplicação
Execute a aplicação num dispositivo de óculos XR simulado antes de ligar o Aura. Um emulador simula um dispositivo no seu computador; um AVD é a respetiva configuração guardada.
· No Android Studio > abra Tools > Device Manager. Clique no controlo de adicionar dispositivo e escolha Create Virtual Device.
· Em Form Factor, escolha XR e, depois, XR Glasses. Clique em Next.
· Selecione a imagem de sistema Preview API necessária para o perfil XR Glasses e transfira-a, se lhe for pedido. Faça corresponder a arquitetura de imagem suportada ao seu computador. Conclua a configuração.
· Inicie o AVD com o respetivo controlo de reprodução. Aguarde que o ambiente Android XR termine de carregar.
· Na barra de ferramentas superior do Android Studio, selecione a configuração de execução da aplicação e o dispositivo XR Glasses em execução. Clique em Run, o triângulo verde.
O emulador instala e abre a aplicação. Utilize os controlos de entrada do emulador para ativar Mark complete. Se o painel permanecer no Home Space, verifique o manifesto e os controlos de Full Space do ambiente antes de alterar o esquema Kotlin. Consulte as instruções oficiais do AVD.
Execute esta verificação de aceitação:
· O primeiro ecrã mostra zero de três tarefas confirmadas e a primeira instrução
· Cada ativação de Mark complete avança exatamente uma instrução
· A terceira ativação mostra Checklist complete e desativa Mark complete
· Restart demo repõe a primeira instrução e zero confirmações
· O texto mais longo continua acessível através do deslocamento
· O conteúdo continua a aparecer quando a IU espacial não está disponível
Um teste bem-sucedido no emulador valida parte da lógica e do esquema da aplicação. Não valida a ótica do Aura, a fiabilidade da entrada nem a adequação ao local de trabalho.
Passo 7 Implementar em hardware Aura autorizado
Os passos abaixo seguem o processo de depuração Android padrão. Os menus e as opções de ligação do Aura podem variar consoante a versão do software, por isso siga as instruções específicas do kit sempre que forem diferentes.
Ligar o Aura e executar a aplicação
· Inicie o Aura com os óculos ligados e abra a aplicação Settings do Aura
· No Aura > na interface de definições > ative as Developer options e a depuração seguindo as instruções do kit; obtenha o guia de configuração para programadores se esses controlos não estiverem disponíveis
· Ligue o computador à porta de carregamento (Charging Port, lado esquerdo) do puck de computação com um cabo USB de dados e mantenha os óculos ligados à porta dos óculos (Glasses Port, lado direito); caso isso não funcione, ligue-o à porta do lado direito para obter suporte ADB completo.
· Aceite o pedido de autorização de depuração do dispositivo; um dispositivo gerido pode exigir a aprovação de um administrador
· Na barra de ferramentas superior do Android Studio, selecione Aura na lista pendente de dispositivos e clique em Run
· No Aura, repita as verificações do painel de tarefas do Passo 6, incluindo o avanço das tarefas e o reinício da lista de verificação
Resolução de problemas de ligação do dispositivo
Se o Aura não aparecer no seletor de destino do Android Studio, verifique a ligação com o ADB:
- Abra View > Tool Windows > Terminal no Android Studio.
- Execute o seguinte comando:
adb devices -lVerifique o resultado:
· Se o dispositivo estiver listado com device, está ligado e autorizado.
· Se mostrar unauthorized, coloque os óculos e aceite o pedido de depuração USB no ecrã.
· Se a lista estiver vazia, volte a verificar o cabo USB de dados, certifique-se de que o puck de computação está ligado e confirme que a depuração USB continua ativada nas Definições.
Conclusão
A criação de uma primeira aplicação empresarial para XREAL Aura começa com o Android Studio, o Kotlin e o Jetpack XR SDK, e avança depois de um simples painel de instruções de trabalho para os testes no emulador e a implementação em hardware autorizado. Esta abordagem dá às empresas uma forma focada de avaliar se as instruções espaciais melhoram um fluxo de trabalho real antes de investirem em integrações e na implementação em toda a frota. Depois de o painel estar legível, utilizável e validado no Aura, o passo seguinte é ligar procedimentos aprovados e registos de trabalho fiáveis aos sistemas da empresa.
Fale com a VR Expert sobre a disponibilidade do Aura e os requisitos de hardware, desenvolvimento de software e suporte para o projeto-piloto da sua empresa.

























