Criar sua primeira atividade para óculos de IA

Dispositivos XR relevantes

Estas orientações ajudam você a criar experiências para esses tipos de dispositivos XR.

Saiba mais sobre esses dispositivos →

Óculos de IA

Saiba mais sobre esses dispositivos →

A experiência dos óculos de IA é criada na API do framework Activity do Android e inclui outros conceitos para oferecer suporte aos aspectos exclusivos dos óculos de IA. Ao contrário dos headsets de XR que executam um APK completo no dispositivo, os óculos de IA usam uma atividade dedicada que é executada no app atual do smartphone. Essa atividade é projetada do dispositivo host para os óculos de IA.

Para criar a experiência de óculos de IA do seu app, estenda o app para smartphone atual criando um novo Activity projetado para óculos de IA. Essa atividade serve como o principal ponto de entrada de inicialização do seu app em óculos de IA. Essa abordagem simplifica o desenvolvimento porque você pode compartilhar e reutilizar a lógica de negócios entre as experiências do smartphone e dos óculos de IA.

Compatibilidade de versões

Confira os requisitos de compatibilidade do SDK do Android para o SDK do Jetpack XR.

Dependências

Adicione as seguintes dependências de biblioteca para óculos de IA:

Groovy

dependencies {
    implementation "androidx.xr.runtime:runtime:1.0.0-alpha10"
    implementation "androidx.xr.glimmer:glimmer:1.0.0-alpha06"
    implementation "androidx.xr.projected:projected:1.0.0-alpha04"
    implementation "androidx.xr.arcore:arcore:1.0.0-alpha10"
}

Kotlin

dependencies {
    implementation("androidx.xr.runtime:runtime:1.0.0-alpha10")
    implementation("androidx.xr.glimmer:glimmer:1.0.0-alpha06")
    implementation("androidx.xr.projected:projected:1.0.0-alpha04")
    implementation("androidx.xr.arcore:arcore:1.0.0-alpha10")
}

Declare sua atividade no manifesto do app

Assim como outros tipos de atividades, é necessário declarar sua atividade no arquivo de manifesto do app para que o sistema a veja e a execute.

<application>
  <activity
      android:name="com.example.xr.projected.GlassesMainActivity"
      android:exported="true"
      android:requiredDisplayCategory="xr_projected"
      android:label="Example AI Glasses activity">
      <intent-filter>
          <action android:name="android.intent.action.MAIN" />
      </intent-filter>
  </activity>
</application>

Pontos principais sobre o código

• Especifica xr_projected para o atributo android:requiredDisplayCategory e informa ao sistema que essa atividade precisa usar um contexto projetado para acessar hardware de um dispositivo conectado.

Criar sua atividade

Em seguida, você vai criar uma pequena atividade que pode mostrar algo nos óculos de IA sempre que a tela for ativada.

@OptIn(ExperimentalProjectedApi::class)
class GlassesMainActivity : ComponentActivity() {

    private var displayController: ProjectedDisplayController? = null
    private var isVisualUiSupported by mutableStateOf(false)
    private var areVisualsOn by mutableStateOf(true)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycle.addObserver(object : DefaultLifecycleObserver {
            override fun onDestroy(owner: LifecycleOwner) {
                displayController?.close()
                displayController = null
            }
        })

        lifecycleScope.launch {
            // Check device capabilities
            val projectedDeviceController = ProjectedDeviceController.create(this@GlassesMainActivity)
            isVisualUiSupported = projectedDeviceController.capabilities.contains(CAPABILITY_VISUAL_UI)

            val controller = ProjectedDisplayController.create(this@GlassesMainActivity)
            displayController = controller
            val observer = GlassesLifecycleObserver(
                context = this@GlassesMainActivity,
                controller = controller,
                onVisualsChanged = { visualsOn -> areVisualsOn = visualsOn }
            )
            lifecycle.addObserver(observer)
        }

        setContent {
            GlimmerTheme {
                HomeScreen(
                    areVisualsOn = areVisualsOn,
                    isVisualUiSupported = isVisualUiSupported,
                    onClose = { finish() }
                )
            }
        }
    }
}
GlassesMainActivity.kt

Pontos principais sobre o código

• Ativa o uso de APIs experimentais da biblioteca Jetpack Projected (link em inglês).
• GlassesMainActivity estende ComponentActivity, como seria de se esperar no desenvolvimento para dispositivos móveis.
• Como nem todos os óculos de IA têm uma tela, verifique se o dispositivo tem uma tela usando ProjectedDeviceController.
• O bloco setContent na função onCreate define a raiz da árvore de interface combinável da atividade. Você vai implementar o elemento combinável HomeScreen usando o Jetpack Compose Glimmer.
• Inicializa a interface durante o método onCreate da atividade. Consulte o ciclo de vida da atividade projetada.

Implementar o elemento combinável

A atividade criada faz referência a uma função combinável HomeScreen que você precisa implementar. O código a seguir usa o Jetpack Compose Glimmer para definir um elemento combinável que pode mostrar algum texto na tela dos óculos de IA:

@Composable
fun HomeScreen(
    areVisualsOn: Boolean,
    isVisualUiSupported: Boolean,
    onClose: () -> Unit,
    modifier: Modifier = Modifier
) {
    Box(
        modifier = modifier
            .surface(focusable = false)
            .fillMaxSize(),
        contentAlignment = Alignment.Center
    ) {
        if (isVisualUiSupported) {
            Card(
                title = { Text("Android XR") },
                action = {
                    Button(onClick = onClose) {
                        Text("Close")
                    }
                }
            ) {
                if (areVisualsOn) {
                    Text("Hello, AI Glasses!")
                } else {
                    Text("Display is off. Audio guidance active.")
                }
            }
        } else {
            Text("Audio Guidance Mode Active")
        }
    }
}
GlassesMainActivity.kt

Pontos principais sobre o código

• Como você definiu na atividade anterior, a função HomeScreen inclui o conteúdo combinável que o usuário vê quando a tela dos óculos de IA está ligada.
• O componente Text do Glimmer do Jetpack Compose mostra o texto "Hello, AI Glasses!" na tela dos óculos.
• O Glimmer Button do Jetpack Compose fecha a atividade chamando finish() por onClose na atividade dos óculos de IA.

Observação: para um exemplo de desenvolvimento para uma experiência sem tela, consulte Processar entrada de áudio usando o reconhecimento automático de fala e Processar entrada de áudio usando a conversão de texto em voz.

Verificar se os óculos de IA estão conectados

Para determinar se os óculos de IA de um usuário estão conectados ao smartphone antes de iniciar sua atividade, use o método ProjectedContext.isProjectedDeviceConnected. Esse método retorna um Flow<Boolean> que seu app pode observar para receber atualizações em tempo real sobre o status da conexão.

Começar a atividade

Prévia: há um problema de renderização conhecido que faz com que a tela dos óculos de IA pisque brevemente em branco quando uma atividade projetada é iniciada.

Agora que você criou uma atividade básica, é possível iniciá-la nos óculos. Para acessar o hardware dos óculos, o app precisa iniciar a atividade com opções específicas que informam ao sistema para usar um contexto projetado, conforme mostrado no código a seguir:

val options = ProjectedContext.createProjectedActivityOptions(context)
val intent = Intent(context, GlassesMainActivity::class.java)
context.startActivity(intent, options.toBundle())
PhoneMainActivity.kt

O método createProjectedActivityOptions em ProjectedContext gera as opções necessárias para iniciar sua atividade em um contexto projetado. O parâmetro context pode ser um contexto do smartphone ou do dispositivo de óculos.

Prévia: quando o app inicia uma atividade projetada, ele não ativa automaticamente a tela dos óculos de IA. Planejamos adicionar essa funcionalidade no futuro.

Próximas etapas

Agora que você criou sua primeira atividade para óculos de IA, confira outras maneiras de ampliar a funcionalidade deles:

• Processar a saída de áudio usando o Text-to-Speech
• Processar entrada de áudio usando o reconhecimento de fala automático
• Criar interface com o Glimmer do Jetpack Compose
• Acessar o hardware dos óculos com IA