CameraX 1.5: Leistungsstarke Videoaufzeichnung und professionelle Bilderfassung

Das CameraX-Team freut sich, die Veröffentlichung von Version 1.5 bekanntzugeben. Mit diesem neuesten Update stehen Ihnen professionelle Funktionen zur Verfügung und die Kamerasitzung lässt sich einfacher als je zuvor konfigurieren.

Bei der Videoaufzeichnung können Nutzer jetzt ganz einfach beeindruckende Zeitlupenvideos oder Videos mit hoher Framerate aufnehmen. Noch wichtiger ist, dass Sie mit der neuen Feature Group API komplexe Kombinationen wie 10-Bit-HDR und 60 fps problemlos aktivieren können, um auf allen unterstützten Geräten konsistente Ergebnisse zu erzielen.

Bei der Bildaufnahme haben Sie maximale Flexibilität, da Sie nicht verarbeitete, nicht komprimierte DNG-Dateien (RAW) aufnehmen können. Außerdem können Sie jetzt die Ultra HDR-Ausgabe nutzen, auch wenn Sie leistungsstarke Kameraerweiterungen verwenden.

Die Grundlage für diese Funktionen ist die neue SessionConfig API, die die Einrichtung und Neukonfiguration der Kamera vereinfacht. Sehen wir uns die Details dieser spannenden neuen Funktionen an.

Leistungsstarke Videoaufzeichnung: Hohe Geschwindigkeit und Feature-Kombinationen

CameraX 1.5 erweitert die Videofunktionen erheblich und ermöglicht kreativere und robustere Aufnahmen.

Zeitlupenvideos und Videos mit hoher Framerate

Eine unserer am meisten erwarteten Funktionen, die Zeitlupenvideo-Funktion, ist jetzt verfügbar. Sie können jetzt Videos mit hoher Geschwindigkeit (z.B. 120 oder 240 fps) aufnehmen und direkt in ein dramatisches Zeitlupenvideo codieren. Alternativ können Sie mit derselben hohen Framerate aufnehmen, um ein besonders flüssiges Video zu erstellen.

Wenn Sie mit der VideoCapture API vertraut sind, ist die Implementierung ganz einfach.

1. Auf Unterstützung für hohe Geschwindigkeiten prüfen: Mit der neuen Methode Recorder.getHighSpeedVideoCapabilities() können Sie abfragen, ob das Gerät diese Funktion unterstützt.

val cameraInfo = cameraProvider.getCameraInfo(cameraSelector)

val highSpeedCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

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

2. Anwendungsfall konfigurieren und binden: Verwenden Sie die zurückgegebene videoCapabilities (die Informationen zur unterstützten Videoqualität enthält), um eine HighSpeedVideoSessionConfig zu erstellen. Anschließend müssen Sie die unterstützten Frameratebereiche über cameraInfo.getSupportedFrameRateRanges() abfragen und den gewünschten Bereich festlegen. Rufen Sie setSlowMotionEnabled(true) auf, um Zeitlupenvideos aufzunehmen. Andernfalls werden Videos mit hoher Framerate aufgenommen. Im letzten Schritt verwenden Sie das reguläre Recorder.prepareRecording().start(), um die Videoaufzeichnung zu starten.

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

Kompatibilität und Einschränkungen

Für die Hochgeschwindigkeitsaufzeichnung sind bestimmte CameraConstrainedHighSpeedCaptureSession- und CamcorderProfile-Unterstützung erforderlich. Führen Sie immer die Funktionsprüfung durch und aktivieren Sie die Hochgeschwindigkeitsaufzeichnung nur auf unterstützten Geräten, um eine schlechte Nutzererfahrung zu vermeiden. Derzeit wird diese Funktion auf den Rückkameras fast aller Pixel-Geräte und ausgewählter Modelle anderer Hersteller unterstützt.

Weitere Informationen finden Sie im Blogpost.

Funktionen sicher kombinieren: Die Feature Group API

Mit CameraX 1.5 wird die Feature Group API eingeführt, mit der Sie nicht mehr raten müssen, ob Funktionen kompatibel sind. Basierend auf der API für die Abfrage von Feature-Kombinationen von Android 15 können Sie jetzt mehrere Funktionen zusammen aktivieren und so eine stabile Kamerasitzung garantieren. Die Feature Group unterstützt derzeit: HDR (HLG), 60 fps, Vorschau-Stabilisierung und Ultra HDR. So können Sie beispielsweise HDR, 60 fps und die Vorschau-Stabilisierung gleichzeitig auf Geräten der Pixel 10- und Galaxy S25-Serie aktivieren. Zukünftige Verbesserungen umfassen 4K-Aufnahmen und Ultraweitwinkel-Zoom. 

Die Feature Group API ermöglicht zwei wichtige Anwendungsfälle:

Anwendungsfall 1: Beste Qualität priorisieren

Wenn Sie mit der bestmöglichen Kombination von Funktionen aufnehmen möchten, können Sie eine priorisierte Liste angeben. CameraX versucht, die Funktionen in der angegebenen Reihenfolge zu aktivieren und wählt die erste Kombination aus, die vom Gerät vollständig unterstützt wird.

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)

In diesem Beispiel versucht CameraX, die Funktionen in dieser Reihenfolge zu aktivieren:

1. HDR + 60 fps + Vorschau-Stabilisierung
2. HDR + 60 fps
3. HDR + Vorschau-Stabilisierung
4. HDR
5. 60 fps + Vorschau-Stabilisierung
6. 60 fps
7. Vorschau-Stabilisierung
8. Keine

Anwendungsfall 2: UI für nutzerorientierte Einstellungen erstellen

Sie können jetzt genau angeben, welche Feature-Kombinationen in der UI für die Einstellungen Ihrer App unterstützt werden, und die Schalter für nicht unterstützte Optionen wie im Bild unten deaktivieren. 

Verwenden Sie die folgenden Codes, um zu prüfen, ob eine Feature-Kombination unterstützt wird, und um einen Schalter auszugrauen. Fragen Sie zuerst den Status jeder einzelnen Funktion ab. Sobald eine Funktion aktiviert ist, fragen Sie die verbleibenden Funktionen mit den aktivierten Funktionen ab, um zu sehen, ob ihre Schalter aufgrund von Kompatibilitätseinschränkungen ausgegraut werden müssen.

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

Weitere Informationen finden Sie im Blogpost zur Feature Group . 

Weitere Video-Optimierungen

• Gleichzeitige Kamera-Verbesserungen: Mit CameraX 1.5.1 können Sie jetzt die Anwendungsfälle „Vorschau“ + „ImageCapture“ + „VideoCapture“ gleichzeitig für jede SingleCameraConfig im Nicht-Kompositionsmodus binden. Außerdem können Sie im Kompositionsmodus (dieselben Anwendungsfälle mit CompositionSettings) jetzt den CameraEffect festlegen, der auf das endgültige Kompositionsergebnis angewendet wird.
• Dynamische Stummschaltung:Sie können jetzt eine Aufnahme im stummgeschalteten Zustand mit PendingRecording.withAudioEnabled(boolean initialMuted) starten und dem Nutzer erlauben, die Stummschaltung später mit Recording.mute(boolean muted) aufzuheben.
• Verbesserte Verarbeitung bei unzureichendem Speicherplatz:CameraX sendet jetzt zuverlässig den Fehler VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE, sodass Ihre App Situationen mit wenig Speicherplatz ordnungsgemäß verarbeiten und den Nutzer informieren kann.
• Low Light Boost: Auf unterstützten Geräten (z. B. der Pixel 10-Serie) können Sie CameraControl.enableLowLightBoostAsync aktivieren, um die Vorschau und die Videostreams in dunklen Umgebungen automatisch aufzuhellen.

Professionelle Bilderfassung

CameraX 1.5 bietet wichtige Upgrades für ImageCapture für Entwickler, die maximale Qualität und Flexibilität benötigen.

Kreative Kontrolle mit DNG-Aufnahmen (RAW)

Für die vollständige Kontrolle über die Nachbearbeitung unterstützt CameraX jetzt DNG-Aufnahmen (RAW). So haben Sie Zugriff auf die nicht verarbeiteten, nicht komprimierten Bilddaten direkt vom Kamerasensor und können professionelle Bearbeitungen und Farbkorrekturen vornehmen. Die API unterstützt die Aufnahme der DNG-Datei allein oder die gleichzeitige Aufnahme von JPEG- und DNG-Ausgaben. Im Beispielcode unten sehen Sie, wie Sie JPEG- und DNG-Dateien gleichzeitig aufnehmen.

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 für Kameraerweiterungen

Das Beste aus beiden Welten: die beeindruckende computergestützte Fotografie von Kameraerweiterungen (z. B. Nachtmodus) kombiniert mit den brillanten Farben und dem dynamischen Bereich von Ultra HDR. Diese Funktion wird jetzt auf vielen aktuellen Premium-Android-Smartphones unterstützt, z. B. der Pixel 9/10-Serie und der Samsung S24/S25-Serie.

// 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()

Verbesserungen der Core API und der Nutzerfreundlichkeit

Neue Konfigurationsmethode: SessionConfig

Wie in den obigen Beispielen zu sehen ist, ist SessionConfig ein neues Konzept in CameraX 1.5. Es zentralisiert die Konfiguration und vereinfacht die API auf zwei wichtige Arten:

1. Keine manuellen unbind()-Aufrufe mehr: CameraX APIs sind lebenszyklusabhängig. Die Anwendungsfälle werden implizit „entbunden“, wenn die Aktivität oder ein anderer LifecycleOwner zerstört wird. Wenn Sie jedoch Anwendungsfälle aktualisieren oder die Kamera wechseln möchten, müssen Sie vor dem erneuten Binden unbind() oder unbindAll() aufrufen. Wenn Sie jetzt mit CameraX 1.5 eine neue SessionConfig binden, aktualisiert CameraX die Sitzung nahtlos für Sie, sodass keine Aufrufe zum Entbinden erforderlich sind.
2. Deterministische Framerate-Steuerung:Die neue SessionConfig API bietet eine deterministische Möglichkeit, die Framerate zu verwalten. Im Gegensatz zur vorherigen setTargetFrameRate, die nur ein Hinweis war, garantiert diese neue Methode, dass der angegebene Frameratebereich nach erfolgreicher Konfiguration angewendet wird. Um eine hohe Genauigkeit zu erzielen, müssen Sie die unterstützten Frameraten mit CameraInfo.getSupportedFrameRateRanges(SessionConfig) abfragen. Wenn Sie die vollständige SessionConfig übergeben, kann CameraX die unterstützten Bereiche anhand der Streamkonfigurationen genau bestimmen.

Camera-Compose ist jetzt stabil

Wir wissen, wie beliebt Jetpack Compose ist, und wir freuen uns, Ihnen mitteilen zu können, dass die camera-compose-Bibliothek jetzt in Version 1.5.1stabil ist! Diese Version enthält wichtige Fehlerkorrekturen im Zusammenhang mit der Verwendung von CameraXViewfinder mit Compose-Funktionen wie moveableContentOf und Pager sowie die Behebung eines Problems mit der Vorschau. Wir werden in zukünftigen Versionen weitere Funktionen zu camera-compose hinzufügen.

Verbesserungen bei ImageAnalysis und CameraControl

• Anpassung der Taschenlampenstärke:Mit neuen APIs haben Sie eine detaillierte Kontrolle über die Taschenlampe des Geräts. Sie können die maximal unterstützte Stärke mit CameraInfo.getMaxTorchStrengthLevel() abfragen und dann die gewünschte Stärke mit CameraControl.setTorchStrengthLevel() festlegen.
• NV21-Unterstützung in ImageAnalysis: Sie können jetzt das NV21-Bildformat direkt von ImageAnalysis anfordern, um die Integration mit anderen Bibliotheken und APIs zu vereinfachen. Dazu rufen Sie ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21) auf.

Noch heute loslegen

Aktualisieren Sie noch heute Ihre Abhängigkeiten auf CameraX 1.5 und probieren Sie die neuen Funktionen aus. Wir sind gespannt, was Sie damit entwickeln.

Wenn Sie CameraX 1.5 verwenden möchten,  fügen Sie die folgenden Abhängigkeiten zu Ihrer Datei libs.versions.toml hinzu. Wir empfehlen die Verwendung von Version 1.5.1, die viele wichtige Fehlerkorrekturen und gleichzeitige Kamera-Verbesserungen enthält.

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

Fügen Sie diese dann den Abhängigkeiten Ihrer Moduldatei build.gradle.kts hinzu:

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 

}

Haben Sie Fragen oder möchten Sie mit dem CameraX-Team in Kontakt treten? Treten Sie der CameraX-Entwickler-Diskussionsgruppe bei oder senden Sie einen Fehlerbericht:

• CameraX-Entwickler-Diskussionsgruppe
• Fehler melden