Crea tu primera actividad para lentes con IA

Dispositivos de realidad extendida correspondientes

Esta guía te ayuda a crear experiencias para estos tipos de dispositivos de realidad extendida.

Más información sobre los tipos de dispositivos de realidad extendida →

Más información sobre los tipos de dispositivos de realidad extendida →

La experiencia de los lentes con IA se basa en la API del framework Activity de Android existente y se incluyen conceptos adicionales para admitir los aspectos únicos de los lentes con IA. A diferencia de los visores de RE que ejecutan un APK completo en el dispositivo, los lentes con IA usan una actividad dedicada que se ejecuta dentro de la app existente de tu teléfono. Esta actividad se proyecta desde el dispositivo host hacia los lentes con IA.

Para crear la experiencia de lentes con IA de tu app, extiende tu app para teléfonos existente creando un nuevo Activity proyectado para lentes con IA. Esta actividad sirve como el punto de entrada principal de inicio para tu app en los lentes con IA. Este enfoque simplifica el desarrollo porque puedes compartir y reutilizar la lógica empresarial entre las experiencias de tu teléfono y tus lentes con IA.

Compatibilidad de versiones

Consulta los requisitos de compatibilidad del SDK de Android para el SDK de XR de Jetpack.

Dependencias

Agrega las siguientes dependencias de biblioteca para los lentes con IA:

dependencies {
    implementation "androidx.xr.runtime:runtime:1.0.0-alpha11"
    implementation "androidx.xr.glimmer:glimmer:1.0.0-alpha08"
    implementation "androidx.xr.projected:projected:1.0.0-alpha05"
    implementation "androidx.xr.arcore:arcore:1.0.0-alpha11"
}

dependencies {
    implementation("androidx.xr.runtime:runtime:1.0.0-alpha11")
    implementation("androidx.xr.glimmer:glimmer:1.0.0-alpha08")
    implementation("androidx.xr.projected:projected:1.0.0-alpha05")
    implementation("androidx.xr.arcore:arcore:1.0.0-alpha11")
}

Declara tu actividad en el manifiesto de la app

Al igual que con otros tipos de actividades, debes declarar tu actividad en el archivo de manifiesto de la app para que el sistema la vea y la ejecute.

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

Puntos clave sobre el código

• Especifica xr_projected para el atributo android:requiredDisplayCategory para indicarle al sistema que esta actividad debe usar un contexto proyectado para acceder al hardware de un dispositivo conectado.

Crea tu actividad

A continuación, crearás una pequeña actividad que pueda mostrar algo en los lentes con IA cada vez que se encienda la pantalla.

@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

Puntos clave sobre el código

• Habilita el uso de APIs experimentales de la biblioteca de Jetpack Projected.
• GlassesMainActivity extiende ComponentActivity, tal como esperarías en el desarrollo para dispositivos móviles.
• Como no todos los lentes con IA tienen pantalla, verifica si el dispositivo tiene una pantalla con ProjectedDeviceController.
• El bloque setContent dentro de la función onCreate define la raíz del árbol de IU componible para la actividad. Implementarás el elemento HomeScreen componible con Jetpack Compose Glimmer.
• Inicializa la IU durante el método onCreate de la actividad (consulta el ciclo de vida proyectado de la actividad).

Implementa el elemento componible

La actividad que creaste hace referencia a una función HomeScreen componible que debes implementar. El siguiente código usa Jetpack Compose Glimmer para definir un elemento componible que puede mostrar texto en la pantalla de los lentes con 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

Puntos clave sobre el código

• Como definiste en tu actividad anteriormente, la función HomeScreen incluye el contenido componible que el usuario ve cuando la pantalla de los lentes con IA está encendida.
• El componente Text de Glimmer de Jetpack Compose muestra el texto "Hello, AI Glasses!" en la pantalla de los lentes.
• El Button de Glimmer de Jetpack Compose cierra la actividad llamando a finish() a través de onClose en la actividad de los lentes con IA.

Cómo verificar si los lentes con IA están conectados

Para determinar si los lentes con IA de un usuario están conectados a su teléfono antes de iniciar tu actividad, usa el método ProjectedContext.isProjectedDeviceConnected. Este método devuelve un Flow<Boolean> que tu app puede observar para obtener actualizaciones en tiempo real sobre el estado de la conexión.

Cómo iniciar tu actividad

Ahora que creaste una actividad básica, puedes lanzarla en tus lentes. Para acceder al hardware de los lentes, tu app debe iniciar la actividad con opciones específicas que le indiquen al sistema que use un contexto proyectado, como se muestra en el siguiente código:

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

El método createProjectedActivityOptions en ProjectedContext genera las opciones necesarias para iniciar tu actividad en un contexto proyectado. El parámetro context puede ser un contexto del teléfono o del dispositivo de anteojos.

Próximos pasos

Ahora que creaste tu primera actividad para los lentes con IA, explora otras formas de extender su funcionalidad:

• Cómo controlar la salida de audio con Text-to-Speech
• Cómo controlar la entrada de audio con el reconocimiento de voz automático
• Compila una IU con Jetpack Compose Glimmer
• Acceder al hardware de los lentes potenciados por IA