Zespół CameraX z przyjemnością ogłasza wydanie wersji 1.5. Ta najnowsza aktualizacja koncentruje się na udostępnieniu profesjonalnych funkcji, a jednocześnie na uproszczeniu konfiguracji sesji aparatu.

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.

Jeśli chodzi o robienie zdjęć, zyskujesz maksymalną elastyczność dzięki obsłudze przechwytywania nieprzetworzonych, nieskompresowanych plików DNG (RAW). Dodatkowo możesz teraz korzystać z danych wyjściowych ultra HDR nawet wtedy, gdy używasz zaawansowanych rozszerzeń aparatu.

Te funkcje są oparte na nowym interfejsie SessionConfig API, który upraszcza konfigurację i rekonfigurację aparatu. Przyjrzyjmy się teraz szczegółom tych nowych funkcji.

Zaawansowane nagrywanie filmów: duża szybkość i kombinacje funkcji

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

Filmy w zwolnionym tempie i z dużą liczbą klatek na sekundę

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

Jeśli znasz interfejs VideoCapture API, wdrożenie tej funkcji jest proste.

1. Sprawdź, czy urządzenie obsługuje dużą szybkość: 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 videoCapabilities (który zawiera informacje o obsługiwanej jakości wideo), aby utworzyć HighSpeedVideoSessionConfig. Następnie musisz sprawdzić obsługiwane zakresy liczby klatek na sekundę za pomocą cameraInfo.getSupportedFrameRateRanges() i ustawić żądany zakres. Aby nagrywać filmy w zwolnionym tempie, wywołaj setSlowMotionEnabled(true). W przeciwnym razie będą nagrywane filmy z dużą liczbą klatek na sekundę. Ostatnim krokiem jest użycie zwykłego polecenia 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żą liczbą klatek na sekundę wymaga obsługi konkretnej sesji CameraConstrainedHighSpeedCaptureSession i profilu CamcorderProfile. Aby zapobiec pogorszeniu komfortu użytkownika, zawsze sprawdzaj możliwości urządzenia i włączaj nagrywanie z dużą liczbą klatek na sekundę tylko na obsługiwanych urządzeniach. Obecnie ta funkcja jest obsługiwana przez tylne aparaty prawie wszystkich urządzeń Pixel oraz wybranych modeli innych producentów.

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

Pewne łączenie funkcji: interfejs Feature Group API

CameraX 1.5 wprowadza interfejs Feature Group API, który eliminuje zgadywanie, czy funkcje są ze sobą zgodne. Dzięki interfejsowi API do sprawdzania kombinacji funkcji w Androidzie 15 możesz teraz pewnie włączać kilka 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 możesz jednocześnie włączyć HDR, 60 kl./s i stabilizację podglądu na urządzeniach z serii Pixel 10 i Galaxy S25. W przyszłości planujemy dodać nagrywanie w rozdzielczości 4K i zoom ultraszerokokątny. 

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

Przypadek użycia 1. Priorytetem jest najlepsza jakość

Jeśli chcesz robić zdjęcia przy użyciu najlepszej możliwej kombinacji funkcji, możesz podać listę priorytetów. CameraX spróbuje włączyć je w podanej 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. HDR + stabilizacja podglądu
4. HDR
5. 60 kl./s + stabilizacja podglądu
6. 60 kl./s
7. Stabilizacja podglądu
8. Brak

Przypadek użycia 2. Tworzenie interfejsu ustawień dla użytkownika

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

Aby określić, czy przełącznik ma być wyszarzony, użyj tych kodów, aby sprawdzić, czy kombinacja funkcji jest obsługiwana. Najpierw sprawdź stan każdej funkcji. Gdy funkcja jest włączona, ponownie sprawdź pozostałe funkcje z włączonymi funkcjami, aby zobaczyć, czy ich przełączniki muszą być teraz wyszarzone ze względu na ograniczenia 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 o grupie funkcji . 

Więcej ulepszeń wideo

• Ulepszenia równoczesnego korzystania z aparatu: w CameraX 1.5.1 możesz teraz powiązać przypadki użycia Preview + ImageCapture + VideoCapture jednocześnie dla każdej konfiguracji SingleCameraConfig w trybie bez kompozycji. Dodatkowo w trybie kompozycji (te same przypadki użycia z 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 pozwolić użytkownikowi na wyłączenie wyciszenia później za pomocą Recording.mute(boolean muted).
• Ulepszona obsługa niewystarczającej ilości miejsca: CameraX niezawodnie wysyła teraz błąd VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE, co pozwala aplikacji na prawidłowe obsługiwanie sytuacji, w których brakuje miejsca, i informowanie o tym użytkownika.
• Wzmocnienie przy słabym oświetleniu: na obsługiwanych urządzeniach (takich jak seria Pixel 10) możesz włączyć CameraControl.enableLowLightBoostAsync, aby automatycznie rozjaśniać podgląd i strumienie wideo w ciemnych pomieszczeniach.

Profesjonalne robienie zdjęć

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

Uwolnij kreatywność dzięki przechwytywaniu DNG (RAW)

Aby zapewnić pełną kontrolę nad przetwarzaniem końcowym, CameraX obsługuje teraz przechwytywanie DNG (RAW). Dzięki temu masz dostęp do nieprzetworzonych, nieskompresowanych danych obrazu bezpośrednio z czujnika aparatu, co umożliwia profesjonalną edycję i gradację kolorów. Interfejs API obsługuje przechwytywanie samego pliku DNG lub jednoczesne przechwytywanie danych wyjściowych JPEG i DNG. Poniżej znajdziesz przykładowy kod, który pokazuje, jak jednocześnie przechwytywać 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 przypadku rozszerzeń aparatu

Połącz to, co najlepsze: wspaniałą fotografię cyfrową rozszerzeń aparatu (np. tryb nocny) z doskonałymi kolorami i zakresem dynamicznym Ultra HDR. Ta funkcja jest teraz obsługiwana na wielu najnowszych telefonach premium z Androidem, takich jak seria 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 sposoby:

1. Nie trzeba już ręcznie wywoływać unbind() wywołań: interfejsy CameraX API są świadome cyklu życia. Gdy aktywność lub inny LifecycleOwner zostanie zniszczony, interfejs API niejawnie „odwiąże” przypadki użycia. Jednak aktualizowanie przypadków użycia lub przełączanie aparatów nadal wymaga wywołania unbind() lub unbindAll() przed ponownym powiązaniem. Teraz, gdy w CameraX 1.5 powiążesz nową konfigurację SessionConfig, CameraX bezproblemowo zaktualizuje sesję, eliminując konieczność wywoływania funkcji unbind.
2. Deterministyczna kontrola liczby klatek na sekundę: nowy interfejs SessionConfig API wprowadza deterministyczny sposób zarządzania liczbą klatek na sekundę. W przeciwieństwie do poprzedniej funkcji setTargetFrameRate, która była tylko wskazówką, ta nowa metoda gwarantuje zastosowanie określonego zakresu liczby klatek na sekundę po pomyślnej konfiguracji. Aby zapewnić dokładność, musisz sprawdzić obsługiwane liczby klatek na sekundę za pomocą CameraInfo.getSupportedFrameRateRanges(SessionConfig). Przekazując pełną konfigurację SessionConfig, CameraX może dokładnie określić obsługiwane zakresy na podstawie konfiguracji strumienia.

Camera-Compose jest już stabilny

Wiemy, jak bardzo lubisz Jetpack Compose, dlatego 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ć kolejne funkcje do camera-compose.

Ulepszenia ImageAnalysis i CameraControl

• Dostosowywanie siły latarki: dzięki nowym interfejsom API możesz precyzyjnie sterować latarką urządzenia. Maksymalną obsługiwaną siłę możesz sprawdzić za pomocą CameraInfo.getMaxTorchStrengthLevel(), a następnie ustawić żądany poziom za pomocą CameraControl.setTorchStrengthLevel().
• Obsługa NV21 w ImageAnalysis: możesz teraz poprosić o format obrazu NV21 bezpośrednio z ImageAnalysis, co upraszcza integrację z innymi bibliotekami i interfejsami API. Aby to zrobić, wywołaj ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21).

Rozpocznij już dziś

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

Aby używać CameraX 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ń równoczesnego korzystania z aparatu).

[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 je do zależności modułu build.gradle.kts:

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