Neu: CameraX 1.5 – leistungsstarke Videoaufzeichnung und Bilderfassung auf Profiniveau

Das CameraX-Team freut sich, die Veröffentlichung von Version 1.5 bekannt zu geben. Mit diesem Update erhältst du Zugriff auf professionelle Funktionen und kannst die Kameraeinstellungen so einfach wie nie zuvor konfigurieren.

Bei Videoaufnahmen können Nutzer jetzt mühelos 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 aktivieren können, um auf allen unterstützten Geräten einheitliche Ergebnisse zu erzielen.

Bei der Bilderfassung profitierst du von maximaler Flexibilität, da du unbearbeitete, unkomprimierte DNG-Dateien (RAW) aufnehmen kannst. Außerdem kannst du die Ultra HDR-Ausgabe jetzt auch mit leistungsstarken Kameraerweiterungen nutzen.

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

Leistungsstarke Videoaufzeichnung: Highspeed- und Funktionskombinationen

Mit CameraX 1.5 werden die Videofunktionen erheblich erweitert, was kreativere und zuverlässigere Aufnahmen ermöglicht.

Videos in Zeitlupe und mit hoher Framerate

Eine unserer am meisten erwarteten Funktionen, Zeitlupenvideos, 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 kannst du mit derselben hohen Framerate aufnehmen, um ein besonders flüssiges Video zu erhalten.

Die Implementierung ist unkompliziert, wenn Sie mit der VideoCapture API vertraut sind.

1. Unterstützung für Highspeed-Videos prüfen: Mit der neuen Methode Recorder.getHighSpeedVideoCapabilities() kannst du 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: Verwende 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 Frameratenbereiche ü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 wird die normale Recorder.prepareRecording().start() verwendet, um die Videoaufnahme 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 Hochgeschwindigkeitsaufnahme ist eine spezielle Unterstützung für CameraConstrainedHighSpeedCaptureSession und CamcorderProfile erforderlich. Führe immer die Funktionsprüfung durch und aktiviere die Hochgeschwindigkeitsaufzeichnung nur auf unterstützten Geräten, um eine schlechte Nutzererfahrung zu vermeiden. Derzeit wird diese Funktion von den Rückkameras fast aller Pixel-Geräte und ausgewählter Modelle anderer Hersteller unterstützt.

Weitere Informationen finden Sie in diesem Blogpost.

Features zuverlässig kombinieren: die Feature Group API

Mit CameraX 1.5 wird die Feature Group API eingeführt, die das Rätselraten bei der Funktionskompatibilität überflüssig macht. Mit der API für die Abfrage von Funktionskombinationen in Android 15 können Sie jetzt mehrere Funktionen gleichzeitig aktivieren und so eine stabile Kamerasitzung gewährleisten. Die Feature Group unterstützt derzeit: HDR (HLG), 60 fps, Stabilisierung der Vorschau und Ultra HDR. Auf Geräten der Pixel 10- und Galaxy S25-Serie können Sie beispielsweise HDR, 60 fps und die Vorschau-Stabilisierung gleichzeitig 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 die bestmögliche Kombination von Funktionen erfassen möchten, können Sie eine priorisierte Liste angeben. CameraX versucht, sie der Reihe nach 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, Funktionen in der folgenden Reihenfolge zu aktivieren:

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

Anwendungsfall 2: Erstellen einer für Nutzer sichtbaren Benutzeroberfläche für Einstellungen

Sie können jetzt in der Benutzeroberfläche für die Einstellungen Ihrer App genau angeben, welche Funktionskombinationen unterstützt werden, und die Schalter für nicht unterstützte Optionen deaktivieren, wie in der Abbildung unten gezeigt. 

Verwenden Sie die folgenden Codes, um zu prüfen, ob die Funktionskombination unterstützt wird, und um festzustellen, ob ein Schalter ausgegraut werden soll. Fragen Sie zuerst den Status jedes einzelnen Features ab. Sobald eine Funktion aktiviert ist, fragen Sie die verbleibenden Funktionen mit den aktivierten Funktionen noch einmal ab, um zu sehen, ob ihre Schalter jetzt aufgrund von Kompatibilitätseinschränkungen ausgegraut sein 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 zu Featuregruppen . 

Weitere Video-Optimierungen

• Verbesserungen bei der gleichzeitigen Kameranutzung: Mit CameraX 1.5.1 können Sie jetzt die Anwendungsfälle „Preview“, „ImageCapture“ und „VideoCapture“ gleichzeitig für jede SingleCameraConfig im Nicht-Kompositionsmodus binden. Außerdem können Sie im Erstellungsmodus (dieselben Anwendungsfälle mit CompositionSettings) jetzt die CameraEffect festlegen, die auf das endgültige Kompositionsergebnis angewendet wird.
• Dynamische Stummschaltung: Sie können jetzt eine Aufnahme mit PendingRecording.withAudioEnabled(boolean initialMuted) im stummgeschalteten Zustand starten und dem Nutzer erlauben, die Stummschaltung später mit Recording.mute(boolean muted) aufzuheben.
• Verbesserte Handhabung von unzureichendem Speicherplatz:CameraX gibt jetzt zuverlässig den Fehler VideoRecordEvent.Finalize.ERROR_INSUFFICIENT_STORAGE aus, sodass Ihre App Situationen mit wenig Speicherplatz ordnungsgemäß verarbeiten und den Nutzer informieren kann.
• Optimierung bei wenig Licht:Auf unterstützten Geräten (z. B. der Pixel 10-Serie) können Sie CameraControl.enableLowLightBoostAsync aktivieren, um die Vorschau und 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 die Aufnahme im DNG-Format (RAW). So erhältst du Zugriff auf die unverarbeiteten, unkomprimierten Bilddaten direkt vom Kamerasensor und kannst 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 Kamera-Erweiterungen

Das Beste aus zwei Welten: die beeindruckende computergestützte Fotografie von Kameraerweiterungen (wie dem Nachtmodus) kombiniert mit den brillanten Farben und dem Dynamikumfang von Ultra HDR. Diese Funktion wird jetzt auf vielen aktuellen Premium-Android-Smartphones unterstützt, z. B. auf 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

Eine neue Art der Konfiguration: SessionConfig

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

1. Keine manuellen unbind()-Aufrufe mehr:CameraX APIs sind lebenszyklusbewusst. Ihre Anwendungsfälle werden implizit „getrennt“, wenn die Aktivität oder ein anderes LifecycleOwner-Element gelöscht wird. Wenn Sie jedoch Anwendungsfälle aktualisieren oder Kameras wechseln, müssen Sie vor der erneuten Bindung unbind() oder unbindAll() aufrufen. Wenn Sie jetzt mit CameraX 1.5 einen neuen SessionConfig binden, aktualisiert CameraX die Sitzung nahtlos für Sie, sodass keine Aufrufe zum Aufheben der Bindung mehr 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 Frameratenbereich nach erfolgreicher Konfiguration angewendet wird. Um die Genauigkeit zu gewährleisten, 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 sehr ihr Jetpack Compose schätzt, und freuen uns, euch mitteilen zu können, dass die camera-compose-Bibliothek jetzt in Version 1.5.1 stabil ist. Diese Version enthält wichtige Fehlerkorrekturen im Zusammenhang mit der Verwendung von CameraXViewfinder mit Compose-Funktionen wie moveableContentOf und Pager. Außerdem wurde ein Problem mit der Streckung der Vorschau behoben. Wir werden camera-compose in zukünftigen Versionen weitere Funktionen hinzufügen.

Verbesserungen bei ImageAnalysis und CameraControl

• Anpassung der Taschenlampenhelligkeit:Mit neuen APIs lässt sich die Helligkeit der Taschenlampe des Geräts genau einstellen. 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 das NV21-Bildformat jetzt direkt von ImageAnalysis anfordern, was die Integration mit anderen Bibliotheken und APIs vereinfacht. Diese Funktion wird durch Aufrufen von ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21) aktiviert.

Noch heute loslegen

Aktualisieren Sie Ihre Abhängigkeiten noch heute auf CameraX 1.5 und entdecken Sie die spannenden neuen Funktionen. Wir sind schon gespannt, was Sie damit entwickeln werden.

Wenn Sie CameraX 1.5 verwenden möchten,  fügen Sie Ihrer libs.versions.toml die folgenden Abhängigkeiten hinzu. Wir empfehlen die Verwendung von Version 1.5.1, die viele wichtige Fehlerkorrekturen und Verbesserungen für die gleichzeitige Verwendung von Kameras 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 „build.gradle.kts“-Abhängigkeiten Ihres Moduls 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 

}

Du hast Fragen oder möchtest das CameraX-Team kontaktieren? Trete der CameraX-Entwickler-Diskussionsgruppe bei oder reiche einen Fehlerbericht ein:

• Diskussionsgruppe für CameraX-Entwickler
• Fehler melden