Usar um contexto projetado para acessar o hardware dos óculos de IA

Dispositivos XR aplicáveis

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

Saiba mais sobre os tipos de dispositivos XR →

Saiba mais sobre os tipos de dispositivos XR →

Depois de solicitar e receber as permissões necessárias, seu app poderá acessar o hardware dos óculos de IA. A chave para acessar o hardware dos óculos (em vez do hardware do smartphone) é usar um contexto projetado.

Há duas maneiras principais de receber um contexto projetado, dependendo de onde seu código está sendo executado:

Receber um contexto projetado se o código estiver sendo executado em uma atividade de óculos de IA

Se o código do app estiver sendo executado na atividade dos óculos de IA, o contexto de atividade dele já será um contexto projetado. Nesse cenário, as chamadas feitas nessa atividade já podem acessar o hardware dos óculos.

Receber um contexto projetado se o código estiver sendo executado no componente do app para smartphone

Se uma parte do app fora da atividade dos óculos de IA (como uma atividade de smartphone ou um serviço) precisar acessar o hardware dos óculos, ela precisará obter explicitamente um contexto projetado. Para fazer isso, use o método createProjectedDeviceContext():

// From a phone Activity, get a context for the AI glasses
try {
    val glassesContext = ProjectedContext.createProjectedDeviceContext(this)
    // Now use glassesContext to access glasses' system services
} catch (e: IllegalStateException) {
    // Projected device was not found
}

Verificar a validade

Depois de criar o contexto projetado, monitore ProjectedContext.isProjectedDeviceConnected. Embora esse método retorne true, o contexto projetado permanece válido para o dispositivo conectado, e a atividade ou o serviço do app de smartphone (como um CameraManager) pode acessar o hardware dos óculos de IA.

Limpar ao desconectar

O contexto projetado está vinculado ao ciclo de vida do dispositivo conectado e é destruído quando o dispositivo é desconectado. Quando o dispositivo se desconecta, ProjectedContext.isProjectedDeviceConnected retorna false. Seu app precisa detectar essa mudança e limpar todos os serviços do sistema (como um CameraManager) ou recursos que ele criou usando esse contexto projetado.

Reinicializar ao reconectar

Quando o dispositivo de óculos de IA se reconecta, o app pode receber outra instância de contexto projetado usando createProjectedDeviceContext() e reinicializar os serviços ou recursos do sistema usando o novo contexto projetado.

Acessar áudio usando Bluetooth

No momento, os óculos de IA se conectam ao smartphone como um dispositivo de áudio Bluetooth padrão. O headset e os perfis A2DP (Advanced Audio Distribution Profile) são compatíveis. Usar essa abordagem permite que qualquer app Android que ofereça suporte à entrada ou saída de áudio funcione nos óculos, mesmo que não tenha sido criado especificamente para isso. Em alguns casos, usar o Bluetooth pode funcionar melhor para o caso de uso do seu app como uma alternativa ao acesso ao hardware dos óculos usando um contexto projetado.

Assim como em qualquer dispositivo de áudio Bluetooth padrão, a permissão para conceder o RECORD_AUDIO é controlada pelo smartphone, não pelos óculos.

Capturar uma imagem com a câmera dos óculos de IA

Para capturar uma imagem com a câmera dos óculos de IA, configure e vincule o ImageCapture caso de uso do CameraX à câmera dos óculos usando o contexto correto para seu app:

private fun startCamera() {
    // Get the CameraProvider using the projected context.

    val cameraProviderFuture = ProcessCameraProvider.getInstance(
        ProjectedContext.createProjectedDeviceContext(this)
    )

    cameraProviderFuture.addListener({
        // Used to bind the lifecycle of cameras to the lifecycle owner
        val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()

        // Select the camera. When using the projected context, DEFAULT_BACK_CAMERA maps to the AI glasses' camera.
        val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
    
        // Check for the presence of a camera before initializing the ImageCapture use case.
       if (!cameraProvider.hasCamera(cameraSelector)) {
            Log.w(TAG, "The selected camera is not available.")
            return@addListener
        }

        // Get supported streaming resolutions.
        val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)
        val camera2CameraInfo = Camera2CameraInfo.from(cameraInfo)
        val cameraCharacteristics = camera2CameraInfo.getCameraCharacteristic(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)

        // Define the resolution strategy.
        val targetResolution = Size(1920, 1080)
        val resolutionStrategy = ResolutionStrategy(
            targetResolution,
            ResolutionStrategy.FALLBACK_RULE_CLOSEST_LOWER)

        val resolutionSelector = ResolutionSelector.Builder()
            .setResolutionStrategy(resolutionStrategy)
            .build()

        // If you have other continuous use cases bound, such as Preview or ImageAnalysis, you can use  Camera2 Interop's CaptureRequestOptions to set the FPS
        val fpsRange = Range(30, 30)
        val captureRequestOptions = CaptureRequestOptions.Builder()
                .setCaptureRequestOption(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,fpsRange)
                .build()

        // Initialize the ImageCapture use case.
        val imageCapture = ImageCapture.Builder()
            // Optional: Configure resolution, format, etc.
            .setResolutionSelector(resolutionSelector)
            .build()

        try {
            // Unbind use cases before rebinding
            cameraProvider.unbindAll()

            // 4. Bind use cases to camera
            cameraProvider.bindToLifecycle(this as LifecycleOwner, cameraSelector, imageCapture)

        } catch(exc: Exception) {
            // This catches exceptions like IllegalStateException if use case binding fails
            Log.e(TAG, "Use case binding failed", exc)
        }

    }, ContextCompat.getMainExecutor(this))
}

Pontos principais sobre o código

• Recebe uma instância do ProcessCameraProvider usando o contexto de dispositivo projetado.
• No escopo do contexto projetado, a câmera principal dos óculos de IA, que aponta para fora, é mapeada para o DEFAULT_BACK_CAMERA ao selecionar uma câmera.
• Uma verificação de pré-vinculação usa cameraProvider.hasCamera(cameraSelector) para verificar se a câmera selecionada está disponível no dispositivo antes de continuar.
• Usa a interoperabilidade do Camera2 com Camera2CameraInfo para ler o CameraCharacteristics#SCALER_STREAM_CONFIGURATION_MAP subjacente, o que pode ser útil para verificações avançadas em resoluções compatíveis.
• Um ResolutionSelector personalizado é criado para controlar com precisão a resolução da imagem de saída para ImageCapture.
• Cria um caso de uso de ImageCapture configurado com um ResolutionSelector personalizado.
• Vincula o caso de uso ImageCapture ao ciclo de vida da atividade. Isso gerencia automaticamente a abertura e o fechamento da câmera com base no estado da atividade (por exemplo, interrompendo a câmera quando a atividade é pausada).

Depois de configurar a câmera dos óculos de IA, você pode capturar uma imagem com a classe ImageCapture do CameraX. Consulte a documentação da CameraX para saber como usar takePicture() para capturar uma imagem.

Gravar um vídeo com a câmera dos óculos de IA

Para capturar um vídeo em vez de uma imagem com a câmera dos óculos de IA, substitua os componentes ImageCapture pelos componentes VideoCapture correspondentes e modifique a lógica de execução da captura.

As principais mudanças envolvem usar um caso de uso diferente, criar um arquivo de saída diferente e iniciar a captura usando o método de gravação de vídeo adequado. Para mais informações sobre a API VideoCapture e como usá-la, consulte a documentação de captura de vídeo do CameraX.

A tabela a seguir mostra a resolução e a taxa de frames recomendadas, dependendo do caso de uso do app:

Acessar o hardware de um smartphone em uma atividade de óculos de IA

Uma atividade dos óculos de IA também pode acessar o hardware do smartphone (como a câmera ou o microfone) usando createHostDeviceContext(context) para receber o contexto do dispositivo host (smartphone):

// From an AI glasses Activity, get a context for the phone
val phoneContext = ProjectedContext.createHostDeviceContext(this)
// Now use phoneContext to access the phone's hardware

Ao acessar hardware ou recursos específicos do dispositivo host (smartphone) em um app híbrido (um app que contém experiências para dispositivos móveis e óculos de IA), selecione explicitamente o contexto correto para garantir que o app possa acessar o hardware certo:

• Use o contexto Activity do smartphone Activity ou o ProjectedContext.createHostDeviceContext() para receber o contexto do smartphone.
• Não use getApplicationContext() porque o contexto do aplicativo pode retornar incorretamente o contexto dos óculos de IA se uma atividade deles foi o componente lançado mais recentemente.