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 rejestrować 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 rejestrowania nieprzetworzonych i nieskompresowanych plików DNG (RAW). Dodatkowo możesz teraz korzystać z wyjścia 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. Teraz przyjrzyjmy się szczegółom tych nowych funkcji.

Zaawansowane nagrywanie filmów: duża liczba klatek na sekundę 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żą liczbę klatek na sekundę: 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. Zawsze sprawdzaj możliwości urządzenia i włączaj nagrywanie z dużą liczbą klatek na sekundę tylko na obsługiwanych urządzeniach, aby uniknąć negatywnych wrażeń użytkowników. 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 na urządzeniach z serii Pixel 10 i Galaxy S25 możesz jednocześnie włączyć HDR, 60 kl./s i stabilizację podglądu. 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. Priorytetowe traktowanie najlepszej jakości

Jeśli chcesz robić zdjęcia przy użyciu najlepszej możliwej kombinacji funkcji, możesz podać listę priorytetową. 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 dla 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ć obsługę kombinacji funkcji. 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 dotyczące jednoczesnego 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 umożliwia aplikacji 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 rejestrowaniu w formacie DNG (RAW)

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