Das CameraX-Team freut sich, die Veröffentlichung von Version 1.5 bekanntzugeben. Dieses Update bietet Ihnen professionelle Funktionen und macht die Konfiguration der Kamerasitzung einfacher als je zuvor.

Mit der Videoaufzeichnung können Nutzer jetzt ganz einfach beeindruckende Zeitlupen- oder High-Frame-Rate-Videos aufnehmen. Außerdem können Sie mit der neuen Feature Group API komplexe Kombinationen wie 10‑Bit-HDR und 60 FPS zuverlässig aktivieren und so für konsistente Ergebnisse auf allen unterstützten Geräten sorgen.

Bei der Bildaufnahme haben Sie maximale Flexibilität, da die Aufnahme von unverarbeiteten, unkomprimierten DNG-Dateien (RAW) unterstützt wird. Außerdem können Sie jetzt Ultra HDR-Ausgabe auch bei Verwendung leistungsstarker Kameraerweiterungen nutzen.

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

Leistungsstarke Videoaufzeichnung: Hochgeschwindigkeit und Kombination von Funktionen

CameraX 1.5 bietet deutlich mehr Videofunktionen und ermöglicht so kreativere und robustere Aufnahmen.

Zeitlupe 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 umwandeln. Alternativ kannst du auch mit derselben hohen Framerate aufnehmen, um besonders flüssige Videos zu erhalten.

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

1. 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 Frame-Rate-Bereiche über cameraInfo.getSupportedFrameRateRanges() abfragen und den gewünschten Bereich festlegen. Rufen Sie setSlowMotionEnabled(true) auf, um Videos in Zeitlupe aufzunehmen. Andernfalls werden Videos mit hoher Bildrate aufgenommen. Im letzten Schritt können Sie mit der regulären Recorder.prepareRecording().start() die Videoaufnahme 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 High-Speed-Aufnahme 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.

Funktionen mit Zuversicht kombinieren: Die Feature Group API

Mit CameraX 1.5 wird die Feature Group API eingeführt, mit der sich die Kompatibilität von Funktionen leichter ermitteln lässt. Basierend auf der Android 15-Abfragekombination API können Sie jetzt mehrere Funktionen gleichzeitig aktivieren und so eine stabile Kamerasitzung garantieren. Die Funktionsgruppe unterstützt derzeit HDR (HLG), 60 fps, Vorschau-Stabilisierung und Ultra HDR. Auf dem Google Pixel 10 und dem Samsung Galaxy S25 kannst du beispielsweise gleichzeitig HDR, 60 fps und die Vorschau-Stabilisierung aktivieren. Zukünftige Verbesserungen sind geplant, darunter 4K-Aufnahmen und Ultraweitwinkelzoom. 

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

Anwendungsfall 1: Priorisierung der besten Qualität

Wenn Sie die bestmögliche Kombination von Funktionen verwenden möchten, können Sie eine priorisierte Liste angeben. CameraX versucht, sie in der Reihenfolge zu aktivieren, und wählt die erste Kombination aus, die das Gerät vollständig unterstützt.

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 dieser Reihenfolge zu aktivieren:

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

Anwendungsfall 2: Benutzeroberfläche für nutzerorientierte Einstellungen erstellen

Sie können jetzt genau angeben, welche Funktionskombinationen in der Benutzeroberfläche der Einstellungen Ihrer App unterstützt werden. Dazu können Sie Schalter für nicht unterstützte Optionen deaktivieren, wie im Bild unten zu sehen. 

Verwenden Sie die folgenden Codes, um zu prüfen, ob eine bestimmte Kombination von Funktionen unterstützt wird. Fragen Sie zuerst den Status jeder einzelnen Funktion ab. Wenn eine Funktion aktiviert ist, fragen Sie die verbleibenden Funktionen noch einmal mit den aktivierten Funktionen ab, um zu sehen, ob ihre Ein/Aus-Schalter aufgrund von Kompatibilitätsbeschränkungen jetzt 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 in diesem Blogpost . 

Weitere Video-Optimierungen

• Verbesserungen bei der gleichzeitigen Verwendung von Kameras:Mit CameraX 1.5.1 können Sie jetzt die Anwendungsfälle „Vorschau“, „Bildaufnahme“ und „Videoaufnahme“ gleichzeitig für jede SingleCameraConfig im Nicht-Kompositionsmodus binden. Außerdem können Sie im Kompositionsmodus (dieselben Anwendungsfälle wie bei 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) stummgeschaltet starten und dem Nutzer erlauben, die Stummschaltung später mit Recording.mute(boolean muted) aufzuheben.
• Verbesserte Behandlung von unzureichendem Speicherplatz:CameraX löst 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.
• Low Light Boost:Auf unterstützten Geräten wie 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 Verbesserungen 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 DNG-Aufnahme (RAW). So haben Sie Zugriff auf die unbearbeiteten, unkomprimierten Bilddaten direkt vom Kamerasensor und können professionelle Bearbeitungen und Farbkorrekturen vornehmen. Die API unterstützt das Aufnehmen der DNG-Datei allein oder das gleichzeitige Aufnehmen 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

Sie erhalten das Beste aus zwei Welten: die beeindruckende rechengestützte Fotografie von Kameraerweiterungen (z. B. Nachtmodus) in Kombination 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 bei der Core API und der Nutzerfreundlichkeit

Neue Konfigurationsmöglichkeiten: SessionConfig

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

1. Keine manuellen unbind()Aufrufe mehr:CameraX-APIs sind lebenszyklusabhängig. Die Anwendungsfälle werden implizit „entbunden“, wenn die Aktivität oder andere LifecycleOwner zerstört werden. Wenn Sie jedoch Anwendungsfälle aktualisieren oder Kameras wechseln möchten, müssen Sie unbind() oder unbindAll() aufrufen, bevor Sie die Bindung neu herstellen. Mit CameraX 1.5 wird die Sitzung automatisch aktualisiert, wenn Sie ein neues SessionConfig binden. Dadurch sind keine Unbind-Aufrufe mehr erforderlich.
2. Deterministische Steuerung der Framerate: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 die Genauigkeit zu gewährleisten, müssen Sie unterstützte 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 gern Sie Jetpack Compose verwenden. Deshalb freuen wir uns, Ihnen mitteilen zu können, dass die camera-compose-Bibliothek jetzt in der stabilen Version 1.5.1 verfügbar ist. Dieses Release 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 Vorschau behoben, bei dem das Bild gestreckt wurde. Wir werden camera-compose in zukünftigen Releases weitere Funktionen hinzufügen.

Verbesserungen bei Bildanalyse und Kamerasteuerung

• Anpassen der Taschenlampenhelligkeit:Mit neuen APIs können Sie die Taschenlampe des Geräts präzise steuern. Sie können die maximal unterstützte Helligkeit mit CameraInfo.getMaxTorchStrengthLevel() abfragen und dann die gewünschte Helligkeit mit CameraControl.setTorchStrengthLevel() festlegen.
• NV21-Unterstützung in ImageAnalysis:Sie können das NV21-Bildformat jetzt direkt über ImageAnalysis anfordern. Das vereinfacht die Integration mit anderen Bibliotheken und APIs. Dies wird durch Aufrufen von ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21) ermöglicht.

Noch heute loslegen

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

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

}

Haben Sie Fragen oder möchten Sie sich mit dem CameraX-Team in Verbindung setzen? Treten Sie der CameraX-Entwickler-Diskussionsgruppe bei oder reichen Sie einen Fehlerbericht ein:

• CameraX-Entwicklerforum
• Fehler melden