Produktneuheiten

CameraX 1.5: Leistungsstarke Videoaufzeichnung und Bildaufnahmen auf Profiniveau

Lesezeit: 7 Minuten
Scott Nien
Softwaretechniker

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 aktivieren und so für konsistente Ergebnisse auf allen unterstützten Geräten sorgen.

Bei der Bildaufnahme bietet das Pixel 8 Pro maximale Flexibilität, da es die Aufnahme von unverarbeiteten, unkomprimierten DNG-Dateien (RAW) unterstützt. Außerdem können Sie jetzt Ultra HDR 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 können Sie 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 High-Speed 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 wird die reguläre 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 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 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 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 gleichzeitig HDR, 60 fps und die Vorschau-Stabilisierung aktivieren. Es ist geplant, in Zukunft 4K-Aufnahmen und Ultraweitwinkelzoom 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 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 Stabilisierung der Vorschau
  4. HDR
  5. 60 fps + Stabilisierung der Vorschau
  6. 60 fps
  7. Vorschau der Stabilisierung
  8. Keine

Anwendungsfall 2: Erstellen einer nutzerorientierten Einstellungs-UI

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 ist. 

unsupported-features-disabled.gif

Mit den folgenden Codes können Sie prüfen, ob eine bestimmte Kombination von Funktionen unterstützt wird, um zu entscheiden, ob ein Schalter ausgegraut werden soll. Fragen Sie zuerst den Status jeder einzelnen Funktion 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 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 Verarbeitung 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 (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 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 computergestü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 lebenszyklusbezogen. 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() anrufen, bevor Sie die Geräte neu verknüpfen. Wenn Sie jetzt mit CameraX 1.5 ein neues SessionConfig binden, wird die Sitzung von CameraX nahtlos aktualisiert. Aufrufe zum Aufheben der Bindung sind nicht mehr erforderlich.
  2. Deterministische Steuerung der Framerate:Die neue SessionConfig-API bietet eine deterministische Möglichkeit zur Verwaltung der Framerate. Im Gegensatz zur vorherigen setTargetFrameRate, die nur ein Hinweis war, garantiert diese neue Methode, dass der angegebene Bereich für die Bildrate bei erfolgreicher Konfiguration angewendet wird. Um die Genauigkeit zu gewährleisten, 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. 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. 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 Helligkeit der Taschenlampe des Geräts genau anpassen. 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 über ImageAnalysis anfordern. Dadurch wird die Integration mit anderen Bibliotheken und APIs vereinfacht. Dies wird durch Aufrufen von ImageAnalysis.Builder.setOutputImageFormat(OUTPUT_IMAGE_FORMAT_NV21) ermöglicht.

Jetzt loslegen

Aktualisieren Sie Ihre Abhängigkeiten noch heute auf CameraX 1.5 und probieren Sie die neuen Funktionen aus. Wir sind gespannt darauf, was Sie damit alles 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 dem CameraX-Entwicklerforum bei oder reichen Sie einen Fehlerbericht ein:

Verfasst von:

Weiterlesen