Przedstawiamy CameraX 1.5: zaawansowane nagrywanie filmów i profesjonalne robienie zdjęć

Zespół CameraX z przyjemnością ogłasza wprowadzenie wersji 1.5. Ta najnowsza aktualizacja zapewnia dostęp do funkcji na poziomie profesjonalnym i ułatwia konfigurowanie sesji nagrywania.

W przypadku nagrywania filmów użytkownicy mogą teraz bez trudu nagrywać wspaniałe filmy w zwolnionym tempie lub z dużą liczbą klatek na sekundę. Co ważniejsze, nowy interfejs Feature Group API umożliwia pewne włączanie złożonych kombinacji, takich jak 10-bitowy HDR i 60 kl./s, co zapewnia spójne wyniki na obsługiwanych urządzeniach.

W przypadku robienia zdjęć masz maksymalną elastyczność dzięki możliwości przechwytywania nieprzetworzonych i nieskompresowanych plików DNG (RAW). Dodatkowo możesz teraz korzystać z Ultra HDR nawet podczas używania zaawansowanych rozszerzeń aparatu.

Podstawą tych funkcji jest nowy interfejs SessionConfig API, który upraszcza konfigurację i rekonfigurację kamery. Przyjrzyjmy się teraz szczegółom tych nowych funkcji.

Zaawansowane nagrywanie wideo: duża szybkość i kombinacje funkcji

CameraX 1.5 znacznie rozszerza możliwości wideo, umożliwiając bardziej kreatywne i zaawansowane nagrywanie.

Filmy w zwolnionym tempie i z dużą liczbą klatek

Jedna z najbardziej wyczekiwanych funkcji, czyli nagrywanie filmów w zwolnionym tempie, jest już dostępna. Możesz teraz nagrywać filmy w dużej szybkości (np.120 lub 240 kl./s) i kodować je bezpośrednio w dramatyczne filmy w zwolnionym tempie. Możesz też nagrywać z tą samą wysoką liczbą klatek na sekundę, aby uzyskać wyjątkowo płynny film.

Jeśli znasz interfejs VideoCapture API, wdrożenie tej funkcji nie powinno sprawić Ci problemu.

1. Sprawdź obsługę dużej szybkości: użyj nowej metody Recorder.getHighSpeedVideoCapabilities() , aby sprawdzić, czy urządzenie obsługuje tę funkcję.

val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

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

2. Skonfiguruj i powiąż przypadek użycia: użyj zwróconego obiektu videoCapabilities (który zawiera informacje o obsługiwanej jakości wideo), aby utworzyć obiekt HighSpeedVideoSessionConfig. Następnie musisz wysłać zapytanie o obsługiwane zakresy liczby klatek za pomocą funkcji cameraInfo.getSupportedFrameRateRanges() i ustawić żądany zakres. Aby nagrywać filmy w zwolnionym tempie, wywołaj funkcję setSlowMotionEnabled(true). W przeciwnym razie będą nagrywane filmy z dużą liczbą klatek na sekundę. Ostatnim krokiem jest kliknięcie zwykłego przycisku Recorder.prepareRecording().start(), aby rozpocząć nagrywanie filmu.

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, {})

Zgodność i ograniczenia

Nagrywanie z dużą szybkością wymaga obsługi konkretnych funkcji CameraConstrainedHighSpeedCaptureSession i CamcorderProfile. Zawsze przeprowadzaj sprawdzanie możliwości i włączaj nagrywanie z dużą szybkością tylko na obsługiwanych urządzeniach, aby zapobiec negatywnym wrażeniom użytkowników. Obecnie ta funkcja jest obsługiwana przez tylne aparaty niemal wszystkich urządzeń Pixel i wybranych modeli innych producentów.

Więcej informacji znajdziesz w tym poście na blogu.

Łączenie funkcji z pewnością: interfejs Feature Group API

W wersji 1.5 biblioteki CameraX wprowadziliśmy interfejs Feature Group API, który eliminuje zgadywanie, czy dana funkcja jest zgodna z urządzeniem. Dzięki interfejsowi API z Androida 15, który umożliwia wysyłanie zapytań o kombinacje funkcji, możesz teraz bez obaw włączać wiele funkcji jednocześnie, co gwarantuje stabilną sesję aparatu. Grupa funkcji obsługuje obecnie: HDR (HLG), 60 kl./s, stabilizację podglądu i Ultra HDR. Na przykład na telefonach Pixel 10 i Galaxy S25 możesz jednocześnie włączyć HDR, 60 kl./s i stabilizację podglądu. W przyszłości planujemy wprowadzić ulepszenia, takie jak nagrywanie w 4K i ultraszeroki zoom. 

Interfejs Feature Group API umożliwia 2 podstawowe przypadki użycia:

Przypadek użycia 1. Nadawanie priorytetu najwyższej jakości

Jeśli chcesz rejestrować dane za pomocą najlepszej możliwej kombinacji funkcji, możesz podać listę priorytetów. CameraX spróbuje włączyć je w kolejności, wybierając pierwszą kombinację, którą urządzenie w pełni obsługuje.

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)

W tym przykładzie CameraX próbuje włączyć funkcje w tej kolejności:

1. HDR + 60 kl./s + stabilizacja podglądu
2. HDR + 60 kl./s
3. Stabilizacja podglądu HDR+
4. HDR
5. 60 kl./s + stabilizacja podglądu
6. 60 kl./s
7. Podgląd stabilizacji
8. Brak

Przypadek użycia 2. Tworzenie interfejsu ustawień dla użytkowników

Możesz teraz dokładnie odzwierciedlać, które kombinacje funkcji są obsługiwane w interfejsie ustawień aplikacji, wyłączając przełączniki dla nieobsługiwanych opcji, takich jak na poniższym obrazie. 

Aby określić, czy przełącznik ma być wyszarzony, użyj tych kodów, aby sprawdzić obsługę kombinacji funkcji. Najpierw sprawdź stan każdej funkcji. Po włączeniu funkcji ponownie wyślij zapytanie o pozostałe funkcje, aby sprawdzić, czy ich przełączniki muszą być teraz wyszarzone ze względu na ograniczenia dotyczące zgodności.

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

Więcej informacji znajdziesz w poście na blogu zespołu ds. funkcji .

Więcej ulepszeń filmów

• Ulepszenia dotyczące jednoczesnego korzystania z kamery: w CameraX 1.5.1 możesz teraz wiązać przypadki użycia Preview, ImageCapture i VideoCapture jednocześnie dla każdej konfiguracji SingleCameraConfig w trybie innym niż kompozycyjny. Dodatkowo w trybie kompozycji (te same przypadki użycia co w przypadku CompositionSettings) możesz teraz ustawić CameraEffect, który jest stosowany do końcowego wyniku kompozycji.
• Dynamiczne wyciszanie: możesz teraz rozpocząć nagrywanie w stanie wyciszenia za pomocą PendingRecording.withAudioEnabled(boolean initialMuted) i umożliwić użytkownikowi wyłączenie wyciszenia później za pomocą Recording.mute(boolean muted).
• Ulepszona obsługa niewystarczającej ilości miejsca na dane: CameraX niezawodnie wysyła teraz błąd VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE, co pozwala aplikacji prawidłowo obsługiwać sytuacje, w których jest mało miejsca na dane, i informować o tym użytkownika.
• Wzmocnienie w słabym oświetleniu: na obsługiwanych urządzeniach (np. z serii Pixel 10) możesz włączyć funkcję CameraControl.enableLowLightBoostAsync, aby automatycznie rozjaśniać podgląd i strumienie wideo w ciemnym otoczeniu.

Profesjonalne robienie zdjęć

CameraX 1.5 wprowadza istotne ulepszenia ImageCapture dla deweloperów, którzy wymagają maksymalnej jakości i elastyczności.

Uwolnij kreatywność dzięki zapisywaniu zdjęć w formacie DNG (RAW)

Aby zapewnić pełną kontrolę nad przetwarzaniem końcowym, CameraX obsługuje teraz przechwytywanie w formacie DNG (RAW). Dzięki temu masz dostęp do nieprzetworzonych i nieskompresowanych danych obrazu bezpośrednio z matrycy aparatu, co umożliwia profesjonalną edycję i korekcję kolorów. Interfejs API umożliwia zapisywanie samego pliku DNG lub jednoczesne zapisywanie plików JPEG i DNG. Poniżej znajdziesz przykładowy kod, który pokazuje, jak jednocześnie zapisywać pliki JPEG i DNG.

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 w rozszerzeniach aparatu

Połączenie najlepszych cech obu technologii: niesamowitej fotografii cyfrowej rozszerzeń aparatu (takich jak tryb nocny) oraz doskonałych kolorów i zakresu dynamicznego ultra HDR. Ta funkcja jest obecnie obsługiwana na wielu najnowszych telefonach z Androidem z wyższej półki, takich jak Pixel 9/10 i 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()

Ulepszenia podstawowego interfejsu API i łatwości obsługi

Nowy sposób konfiguracji: SessionConfig

Jak widać w przykładach powyżej, SessionConfig to nowa koncepcja w CameraX 1.5. Centralizuje konfigurację i upraszcza interfejs API na 2 główne sposoby:

1. Koniec z ręcznymi wywołaniami:unbind() interfejsy API CameraX są dostosowane do cyklu życia. Gdy aktywność lub inny LifecycleOwner zostanie zniszczony, przypadki użycia zostaną niejawnie „odłączone”. Aktualizacja przypadków użycia lub przełączanie kamer nadal wymaga jednak zadzwonienia do unbind() lub unbindAll() przed ponownym powiązaniem. W CameraX 1.5, gdy powiążesz nowy SessionConfig, CameraX automatycznie zaktualizuje sesję, eliminując konieczność wywoływania funkcji odłączania.
2. Deterministyczne sterowanie liczbą klatek na sekundę: nowy interfejs SessionConfig API wprowadza deterministyczny sposób zarządzania liczbą klatek na sekundę. W odróżnieniu od poprzedniej metody setTargetFrameRate, która była tylko wskazówką, ta nowa metoda gwarantuje, że po pomyślnej konfiguracji zostanie zastosowany określony zakres liczby klatek na sekundę. Aby zapewnić dokładność, musisz wysyłać zapytania o obsługiwane liczby klatek na sekundę za pomocą funkcji CameraInfo.getSupportedFrameRateRanges(SessionConfig). Przekazując pełny obiekt SessionConfig, CameraX może dokładnie określić obsługiwane zakresy na podstawie konfiguracji strumienia.

Camera-Compose jest już stabilna

Wiemy, jak bardzo lubisz Jetpack Compose, i z przyjemnością informujemy, że biblioteka camera-compose jest już stabilna w wersji 1.5.1! Ta wersja zawiera ważne poprawki błędów związanych z używaniem CameraXViewfinder z funkcjami Compose, takimi jak moveableContentOf i Pager, a także rozwiązuje problem z rozciąganiem podglądu. W przyszłych wersjach będziemy dodawać do camera-compose kolejne funkcje.

Ulepszenia w zakresie analizy obrazu i sterowania kamerą

• Regulacja siły latarki: nowe interfejsy API umożliwiają precyzyjne sterowanie latarką urządzenia. Maksymalną obsługiwaną siłę możesz sprawdzić za pomocą funkcji CameraInfo.getMaxTorchStrengthLevel(), a potem ustawić żądany poziom za pomocą funkcji CameraControl.setTorchStrengthLevel().
• Obsługa NV21 w ImageAnalysis: możesz teraz wysyłać prośby o format obrazu NV21 bezpośrednio z ImageAnalysis, co upraszcza integrację z innymi bibliotekami i interfejsami API. Możesz to zrobić, wywołując funkcję ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21).

Rozpocznij już dziś

Zaktualizuj zależności do CameraX 1.5 już dziś i poznaj nowe, ciekawe funkcje. Nie możemy się doczekać, co stworzysz.

Aby używać CameraX w wersji 1.5,  dodaj te zależności do pliku libs.versions.toml. (Zalecamy używanie wersji 1.5.1, która zawiera wiele ważnych poprawek błędów i ulepszeń dotyczących jednoczesnego korzystania z kamery).

[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" }

Następnie dodaj te zależności do pliku build.gradle.kts modułu:

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 

}

Masz pytania lub chcesz skontaktować się z zespołem CameraX? Dołącz do grupy dyskusyjnej dla deweloperów CameraX lub zgłoś błąd:

• Grupa dyskusyjna dla deweloperów CameraX
• Zgłoś błąd