CameraX 1.5: Leistungsstarke Videoaufzeichnung und Bildaufnahmen auf Profiniveau

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.

Für Videoaufnahmen können Nutzer jetzt ganz einfach beeindruckende Zeitlupen- oder Videos mit hoher Bildrate 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, da auf unterstützten Geräten einheitliche Ergebnisse erzielt werden.

Bei der Bildaufnahme haben Sie maximale Flexibilität, da das Aufnehmen von unbearbeiteten, 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 der Kamera vereinfacht. Sehen wir uns nun die Details dieser spannenden neuen Funktionen an.

Leistungsstarke Videoaufzeichnung: High-Speed und Funktionskombinationen

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 können Sie 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 das zurückgegebene videoCapabilities (das Informationen zur unterstützten Videoqualität enthält), um eine HighSpeedVideoSessionConfig zu erstellen. Anschließend müssen Sie die unterstützten Bildratenbereiche über cameraInfo.getSupportedFrameRateRanges() abfragen und den gewünschten Bereich festlegen. Rufen Sie setSlowMotionEnabled(true) auf, um Zeitlupenvideos aufzunehmen. Andernfalls werden Videos mit hoher Bildrate aufgenommen. Im letzten Schritt können Sie mit dem 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 High-Speed-Aufnahmen 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 Geräten der Pixel 10- und Galaxy S25-Serie können Sie beispielsweise HDR, 60 fps und die Vorschau-Stabilisierung gleichzeitig aktivieren. Es ist geplant, in Zukunft 4K-Aufnahmen und Ultraweitwinkel-Zoom hinzuzufügen. 

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

1. HDR + 60 fps + Vorschau-Stabilisierung
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: Benutzeroberfläche für Einstellungen für Nutzer erstellen

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

Verwenden Sie die folgenden Codes, um zu prüfen, ob eine bestimmte Kombination von Funktionen unterstützt wird, und um zu entscheiden, 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 noch einmal ab, um zu prüfen, ob ihre Ein/Aus-Schalter aufgrund von Kompatibilitätseinschrä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 im Blogpost zur Funktionsgruppe . 

Weitere Video-Optimierungen

• Verbesserungen bei der gleichzeitigen Verwendung der Kamera: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.
• Dynamisches Stummschalten: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 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.
• 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

Das Beste aus zwei Welten: die beeindruckende computergestützte Fotografie von Kameraerweiterungen wie dem Nachtmodus in Kombination 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. 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 an der Core API und der Benutzerfreundlichkeit

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 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üssen Sie vor dem erneuten Binden weiterhin unbind() oder unbindAll() aufrufen. 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 Frame-Rate:Die neue SessionConfig-API bietet eine deterministische Möglichkeit zur Verwaltung der Frame-Rate. Im Gegensatz zum vorherigen setTargetFrameRate, der nur ein Hinweis war, garantiert diese neue Methode, dass der angegebene Bereich für die Bildrate nach erfolgreicher Konfiguration angewendet wird. Um eine hohe Genauigkeit zu erzielen, müssen Sie unterstützte Framerates 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, und freuen uns, Ihnen mitteilen zu können, dass die camera-compose-Bibliothek jetzt in der stabilen Version 1.5.1 verfügbar 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 camera-compose in zukünftigen Versionen um weitere Funktionen ergänzen.

Verbesserungen bei der 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 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. Das vereinfacht die Integration mit anderen Bibliotheken und APIs. Das wird durch den Aufruf 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 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 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 senden Sie einen Fehlerbericht:

• CameraX-Entwickler-Diskussionsgruppe
• Fehler melden