A equipe do CameraX tem o prazer de anunciar o lançamento da versão 1.5. A atualização mais recente se concentra em oferecer recursos de nível profissional ao seu alcance, além de facilitar a configuração da sessão de câmera.

Para gravação de vídeo, os usuários agora podem capturar vídeos incríveis em câmera lenta ou com alta taxa de frames sem esforço. E o mais importante: a nova API Feature Group permite ativar com confiança combinações complexas, como HDR de 10 bits e 60 FPS, garantindo resultados consistentes em todos os dispositivos compatíveis.

Na parte de captura de imagens, você tem máxima flexibilidade com suporte para captura de arquivos DNG (RAW) não processados e não compactados. Além disso, agora você pode aproveitar a saída Ultra HDR mesmo ao usar extensões de câmera avançadas.

Esses recursos são baseados na nova API SessionConfig, que simplifica a configuração e a reconfiguração da câmera. Agora, vamos conhecer os detalhes desses novos recursos incríveis.

Gravação de vídeo avançada: alta velocidade e combinações de recursos

O CameraX 1.5 expande significativamente os recursos de vídeo, permitindo experiências de gravação mais criativas e robustas.

Vídeo em câmera lenta e com alta taxa de frames

Um dos recursos mais aguardados, o vídeo em câmera lenta, já está disponível. Agora você pode capturar vídeos em alta velocidade (por exemplo, 120 ou 240 fps) e codificá-los diretamente em um vídeo dramático em câmera lenta. Como alternativa, grave com a mesma alta taxa de frames para produzir um vídeo excepcionalmente suave.

A implementação é simples se você conhece a API VideoCapture.

1. Verifique se há suporte para alta velocidade:use o novo método Recorder.getHighSpeedVideoCapabilities() para consultar se o dispositivo é compatível com esse recurso.

  val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

if (highSpeedCapabilities == null) {
    // This camera device does not support high-speed video.
    return
}

2. Configure e vincule o caso de uso:use o videoCapabilities retornado (que contém informações sobre a qualidade de vídeo compatível) para criar um HighSpeedVideoSessionConfig. Em seguida, consulte os intervalos de frame rate compatíveis usando cameraInfo.getSupportedFrameRateRanges() e defina o intervalo desejado. Invoque setSlowMotionEnabled(true) para gravar vídeos em câmera lenta. Caso contrário, serão gravados vídeos com alta taxa de frames. A etapa final é usar o Recorder.prepareRecording().start() normal para começar a gravar o vídeo.

  val preview = Preview.Builder().build()
val quality = highSpeedCapabilities
        .getSupportedQualities(DynamicRange.SDR).first()

val recorder = Recorder.Builder()
      .setQualitySelector(QualitySelector.from(quality)))
      .build()

val videoCapture = VideoCapture.withOutput(recorder)

val frameRateRange = cameraInfo.getSupportedFrameRateRanges(      
       HighSpeedVideoSessionConfig(videoCapture, preview)
).first()

val sessionConfig = HighSpeedVideoSessionConfig(
    videoCapture, 
    preview, 
    frameRateRange = frameRateRange, 
    // Set true for slow-motion playback, or false for high-frame-rate
    isSlowMotionEnabled = true
)

cameraProvider.bindToLifecycle(
     lifecycleOwner, cameraSelector, sessionConfig)

// Start recording slow motion videos. 
val recording = recorder.prepareRecording(context, outputOption)
      .start(executor, {})

Compatibilidade e limitações

A gravação em alta velocidade exige suporte específico para CameraConstrainedHighSpeedCaptureSession e CamcorderProfile. Sempre faça a verificação de capacidade e ative a gravação em alta velocidade apenas em dispositivos compatíveis para evitar uma experiência ruim do usuário. No momento, esse recurso é compatível com as câmeras traseiras de quase todos os dispositivos Pixel e alguns modelos de outros fabricantes.

Confira mais detalhes na postagem do blog.

Combinar recursos com confiança: a API Feature Group

O CameraX 1.5 apresenta a API Feature Group, que elimina a necessidade de adivinhar a compatibilidade de recursos. Com base na API de consulta de combinação de recursos do Android 15, agora é possível ativar vários recursos juntos com confiança, garantindo uma sessão de câmera estável. No momento, o grupo de recursos é compatível com: HDR (HLG), 60 QPS, estabilização de prévia e Ultra HDR. Por exemplo, é possível ativar o HDR, 60 fps e a estabilização de prévia simultaneamente nas séries Pixel 10 e Galaxy S25. As melhorias futuras incluem gravação em 4K e zoom ultralargo. 

A API Feature Group permite dois casos de uso essenciais:

Caso de uso 1: priorizar a melhor qualidade

Se quiser capturar usando a melhor combinação possível de recursos, forneça uma lista priorizada. A CameraX vai tentar ativar essas opções em ordem, selecionando a primeira combinação totalmente compatível com o dispositivo.

  val sessionConfig = SessionConfig(
    useCases = listOf(preview, videoCapture),
    preferredFeatureGroup = listOf(
        GroupableFeature.HDR_HLG10,
        GroupableFeature.FPS_60,
        GroupableFeature.PREVIEW_STABILIZATION
    )
).apply {
    // (Optional) Get a callback with the enabled features to update your UI.
    setFeatureSelectionListener { selectedFeatures ->
        updateUiIndicators(selectedFeatures)
    }
}
processCameraProvider.bindToLifecycle(activity, cameraSelector, sessionConfig)

Neste exemplo, a CameraX tenta ativar os recursos nesta ordem:

1. HDR + 60 QPS + estabilização da visualização
2. HDR + 60 QPS
3. Estabilização da visualização HDR+
4. HDR
5. 60 QPS + estabilização da visualização
6. 60 QPS
7. Estabilização da visualização
8. Nenhum

Caso de uso 2: como criar uma interface de configurações voltada ao usuário

Agora você pode refletir com precisão quais combinações de recursos são compatíveis na interface de configurações do app, desativando as opções não compatíveis, como na imagem abaixo. 

Para determinar se um botão precisa ser esmaecido, use os códigos a seguir para verificar a compatibilidade com a combinação de recursos. Inicialmente, consulte o status de cada recurso individual. Depois que um recurso é ativado, consulte novamente os recursos restantes com os ativados para verificar se os botões precisam ser esmaecidos devido a restrições de compatibilidade.

  fun disableFeatureIfNotSuported(
   enabledFeatures: Set<GroupableFeature>,     
   featureToCheck:GroupableFeature
) {
 val sessionConfig = SessionConfig(
     useCases = useCases,
     requiredFeatureGroup = enabledFeatures + featureToCheck
 )
 val isSupported = cameraInfo.isFeatureGroupSupported(sessionConfig)

 if (!isSupported) {
     // disable the toggle for featureToCheck
 }
}

Consulte a postagem do blog sobre grupos de recursos para mais informações. 

Mais melhorias de vídeo

• Melhorias na câmera simultânea:com a CameraX 1.5.1, agora é possível vincular casos de uso de visualização, captura de imagem e captura de vídeo simultaneamente para cada SingleCameraConfig no modo não de composição. Além disso, no modo de composição (mesmos casos de uso com CompositionSettings),  agora é possível definir o CameraEffect aplicado ao resultado final da composição.
• Desativação dinâmica:agora você pode iniciar uma gravação no estado desativado usando PendingRecording.withAudioEnabled(boolean initialMuted) e permitir que o usuário ative o som depois usando Recording.mute(boolean muted).
• Melhoria no tratamento de armazenamento insuficiente:agora o CameraX envia de forma confiável o erro VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE, permitindo que seu app processe situações de pouco armazenamento e informe o usuário.
• Otimização com pouca luz:em dispositivos compatíveis (como a série Pixel 10), é possível ativar CameraControl.enableLowLightBoostAsync para aumentar automaticamente o brilho da prévia e dos fluxos de vídeo em ambientes escuros.

Captura de imagens de nível profissional

O CameraX 1.5 traz grandes upgrades para o ImageCapture (link em inglês) para desenvolvedores que exigem máxima qualidade e flexibilidade.

Solte o controle criativo com a captura DNG (RAW)

Para controle total sobre o pós-processamento, o CameraX agora oferece suporte à captura em DNG (RAW). Isso dá acesso aos dados de imagem não processados e não compactados diretamente do sensor da câmera, permitindo edição e gradação de cores de nível profissional. A API permite capturar apenas o arquivo DNG ou saídas simultâneas em JPEG e DNG. Confira abaixo um exemplo de código para capturar arquivos JPEG e DNG simultaneamente.

  val capabilities = ImageCapture.getImageCaptureCapabilities(cameraInfo)
val imageCapture = ImageCapture.Builder().apply {
    if (capabilities.supportedOutputFormats
             .contains(OUTPUT_FORMAT_RAW_JPEG)) {
        // Capture both RAW and JPEG formats.
        setOutputFormat(OUTPUT_FORMAT_RAW_JPEG)
    }
}.build()
// ... bind imageCapture to lifecycle ...


// Provide separate output options for each format.
val outputOptionRaw = /* ... configure for image/x-adobe-dng ... */
val outputOptionJpeg = /* ... configure for image/jpeg ... */
imageCapture.takePicture(
    outputOptionRaw,
    outputOptionJpeg,
    executor,
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(results: OutputFileResults) {
            // This callback is invoked twice: once for the RAW file
            // and once for the JPEG file.
        }

        override fun onError(exception: ImageCaptureException) {}
    }
)

Ultra HDR para extensões de câmera

Aproveite o melhor dos dois mundos: a incrível fotografia computacional das extensões de câmera (como o Modo noturno) combinada com a cor brilhante e o alcance dinâmico do Ultra HDR. Esse recurso agora está disponível em muitos smartphones Android premium recentes, como as séries Pixel 9/10 e Samsung S24/S25.

  // Support UltraHDR when Extension is enabled. 

val extensionsEnabledCameraSelector = extensionsManager
     .getExtensionEnabledCameraSelector(
        CameraSelector.DEFAULT_BACK_CAMERA, ExtensionMode.NIGHT)

val imageCapabilities = ImageCapture.getImageCaptureCapabilities(
               cameraProvider.getCameraInfo(extensionsEnabledCameraSelector)

val imageCapture = ImageCapture.Builder()
     .apply {
       if (imageCapabilities.supportedOutputFormats
                .contains(OUTPUT_FORMAT_JPEG_ULTRA_HDR) {
           setOutputFormat(OUTPUT_FORMAT_JPEG_ULTRA_HDR)

       }

     }.build()

API principal e melhorias de usabilidade

Uma nova maneira de configurar: SessionConfig

Como visto nos exemplos acima, SessionConfig é um novo conceito no CameraX 1.5. Ele centraliza a configuração e simplifica a API de duas maneiras principais:

1. Sem mais chamadas manuais de unbind(): as APIs da CameraX reconhecem o ciclo de vida. Ele vai "desvincular" implicitamente seus casos de uso quando a atividade ou outro LifecycleOwner for destruído. No entanto, para atualizar casos de uso ou trocar de câmera, ainda é necessário chamar unbind() ou unbindAll() antes de fazer a nova vinculação. Agora, com a CameraX 1.5, ao vincular uma nova SessionConfig, a CameraX atualiza a sessão sem problemas, eliminando a necessidade de chamadas de desvinculação.
2. Controle determinístico da taxa de frames:a nova API SessionConfig apresenta uma maneira determinística de gerenciar a taxa de frames. Ao contrário do setTargetFrameRate anterior, que era apenas uma dica, esse novo método garante que o intervalo de taxa de frames especificado será aplicado após a configuração ser concluída. Para garantir a precisão, consulte as taxas de frames compatíveis usando CameraInfo.getSupportedFrameRateRanges(SessionConfig). Ao transmitir o SessionConfig completo, o CameraX pode determinar com precisão os intervalos compatíveis com base nas configurações de fluxo.

O Camera-Compose agora é estável

Sabemos o quanto você gosta do Jetpack Compose e temos o prazer de anunciar que a biblioteca camera-compose agora está estável na versão 1.5.1! Esta versão inclui correções de bugs críticos relacionados ao uso do CameraXViewfinder com recursos do Compose, como moveableContentOf e Pager, além de resolver um problema de extensão da prévia. Vamos continuar adicionando mais recursos ao camera-compose em versões futuras.

Melhorias no ImageAnalysis e no CameraControl

• Ajuste da intensidade da lanterna:tenha controle refinado sobre a lanterna do dispositivo com novas APIs. É possível consultar a intensidade máxima compatível usando CameraInfo.getMaxTorchStrengthLevel() e definir o nível desejado com CameraControl.setTorchStrengthLevel().
• Suporte a NV21 em ImageAnalysis:agora é possível solicitar o formato de imagem NV21 diretamente de ImageAnalysis, simplificando a integração com outras bibliotecas e APIs. Isso é ativado ao invocar ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21).

Começar hoje mesmo

Atualize suas dependências para a CameraX 1.5 hoje mesmo e conheça os novos recursos incríveis. Mal podemos esperar para ver o que você vai criar.

Para usar o CameraX 1.5,  adicione as seguintes dependências ao libs.versions.toml. Recomendamos usar a versão 1.5.1, que contém muitas correções de bugs críticos e melhorias na câmera simultânea. 

  [versions]

camerax = "1.5.1"


[libraries]

..

androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "camerax" }

androidx-camera-compose = { module = "androidx.camera:camera-compose", version.ref = "camerax" }

androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }

androidx-camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "camerax" }

androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax" }

androidx-camera-extensions = { module = "androidx.camera:camera-extensions", version.ref = "camerax" }

Em seguida, adicione estas dependências ao build.gradle.kts do módulo:

  dependencies {

  ..

  implementation(libs.androidx.camera.core)
  implementation(libs.androidx.camera.lifecycle)

  implementation(libs.androidx.camera.camera2)

  implementation(libs.androidx.camera.view) // for PreviewView 
  implementation(libs.androidx.camera.compose) // for compose UI

  implementation(libs.androidx.camera.extensions) // For Extensions 

}

Tem dúvidas ou quer entrar em contato com a equipe do CameraX? Participe do grupo de discussão para desenvolvedores do CameraX ou envie um relatório de bug:

• Grupo de discussão para desenvolvedores do CameraX
• Informar um bug