Przedstawiamy CameraX 1.5: zaawansowane nagrywanie filmów i robienie zdjęć na poziomie profesjonalnym

Zespół CameraX z przyjemnością ogłasza wprowadzenie wersji 1.5. Ta najnowsza aktualizacja ma na celu udostępnienie Ci profesjonalnych funkcji i ułatwienie konfigurowania 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 robienia 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. 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 nagrywania filmów, 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 nagrywanie filmów 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 elementu videoCapabilities (który zawiera informacje o obsługiwanej jakości wideo), aby utworzyć element HighSpeedVideoSessionConfig. Następnie musisz wysłać zapytanie o obsługiwane zakresy liczby klatek na sekundę za pomocą metody cameraInfo.getSupportedFrameRateRanges() i ustawić żądany zakres. Aby nagrywać filmy w zwolnionym tempie, wywołaj metodę setSlowMotionEnabled(true). W przeciwnym razie będą nagrywane filmy z dużą liczbą klatek na sekundę. Ostatnim krokiem jest użycie zwykłej metody 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 konkretnej sesji CameraConstrainedHighSpeedCaptureSession i profilu CamcorderProfile. Aby zapobiec pogorszeniu komfortu użytkowania, zawsze sprawdzaj możliwości urządzenia i włączaj nagrywanie z dużą szybkością 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 tym 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 wysyłania zapytań o kombinacje 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ę priorytetów. CameraX będzie próbować 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ń filmów

• Ulepszenia równoczesnego działania 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ć element CameraEffect, który jest stosowany do końcowego wyniku kompozycji.
• Dynamiczne wyciszanie: możesz teraz rozpocząć nagrywanie w stanie wyciszenia za pomocą metody PendingRecording.withAudioEnabled(boolean initialMuted) i pozwolić użytkownikowi na wyłączenie wyciszenia później za pomocą metody 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 na prawidłowe obsługiwanie sytuacji, w których brakuje miejsca na dane, i informowanie o tym użytkownika.
• Wzmocnienie w słabym oświetleniu: na obsługiwanych urządzeniach (takich jak seria Pixel 10) możesz włączyć metodę CameraControl.enableLowLightBoostAsync, aby automatycznie rozjaśniać podgląd i strumienie wideo w ciemnych pomieszczeniach.

Robienie zdjęć na poziomie profesjonalnym

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 robieniu zdjęć w formacie DNG (RAW)

Aby zapewnić pełną kontrolę nad przetwarzaniem końcowym, CameraX obsługuje teraz robienie zdjęć 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 robienie zdjęć tylko w formacie DNG lub jednoczesne robienie zdjęć w formatach JPEG i DNG. Poniżej znajdziesz przykładowy kod, który pokazuje, jak jednocześnie robić zdjęcia w formatach 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

Ciesz się najlepszymi rozwiązaniami: wspaniałą fotografią cyfrową rozszerzeń aparatu (takich jak tryb nocny) w połączeniu z doskonałymi kolorami i zakresem dynamicznym ultra HDR. Ta funkcja jest teraz obsługiwana na wielu najnowszych telefonach 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ć metody unbind() Calls: interfejsy CameraX API są zgodne z cyklem życia. Gdy aktywność lub inny element LifecycleOwner zostanie zniszczony, interfejs API niejawnie „odwiąże” Twoje przypadki użycia. Jednak aktualizowanie przypadków użycia lub przełączanie aparatów nadal wymaga wywołania metody unbind() lub unbindAll() przed ponownym powiązaniem. Teraz, gdy w CameraX 1.5 powiążesz nowy element SessionConfig, CameraX bezproblemowo zaktualizuje sesję, eliminując konieczność wywoływania metody 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 metody 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 wysłać zapytanie o obsługiwane liczby klatek na sekundę za pomocą metody CameraInfo.getSupportedFrameRateRanges(SessionConfig). Przekazując pełny element 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, 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 elementu 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 biblioteki 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ą metody CameraInfo.getMaxTorchStrengthLevel(), a następnie ustawić żądany poziom za pomocą metody 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 metodę ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21).

Rozpocznij już dziś

Zaktualizuj zależności do CameraX 1.5 i wypróbuj 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 działania 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