Criar a sua primeira aplicação empresarial para XREAL Aura com o Android Studio

Criar a sua primeira aplicação empresarial para XREAL Aura com o Android Studio

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:

  1. Abra View > Tool Windows > Terminal no Android Studio.
  1. Execute o seguinte comando:
adb devices -l

Verifique 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.

João Noronha

Escrito por

João Noronha

Especialista em XR e Conteúdo Imersivo na VR Expert

João Noronha é Especialista em XR e Conteúdo Imersivo na VR Expert, com um forte interesse por tecnologias emergentes e as suas aplicações práticas no mundo real. Dedica-se a transformar desenvolvimentos complexos em VR, AR, óculos de IA e tecnologia imersiva em conteúdos claros e práticos para empresas e profissionais que exploram o setor XR.

Perguntas frequentes

Este artigo

Sim. Comece pelo emulador Android XR Glasses para desenvolver a interface e o fluxo de tarefas. Os testes físicos no Aura continuam a ser necessários antes de um projeto-piloto no local de trabalho.

Não. O Android Studio, o Kotlin e o Jetpack Compose for XR são adequados para este exemplo centrado na interface. O Unity é um motor de desenvolvimento distinto que pode ser adequado para projetos com conteúdo 3D interativo extenso.

Não. Fornece capacidades XR. A sua equipa continua a ter de implementar e validar os requisitos de segurança, armazenamento de dados, identidade, distribuição, suporte e integração.

Não. Apresenta texto armazenado localmente e regista as confirmações no estado da IU. O reconhecimento de equipamento, a compreensão da cena e os registos de trabalho verificados exigem conceção e implementação adicionais.

Este exemplo não implementa uma âncora física persistente. Uma âncora é uma referência espacial utilizada para posicionar conteúdo em relação a um local; o posicionamento específico numa máquina exige um fluxo de trabalho de ancoragem suportado adicional e validação no dispositivo.