CameraX-Architektur

Auf dieser Seite wird die Architektur von CameraX beschrieben, einschließlich ihrer Struktur, der Arbeit mit der API, der Arbeit mit Lebenszyklen und der Kombination von Anwendungsfällen.

KameraX-Struktur

Mit CameraX können Sie über eine Abstraktion, die als Anwendungsfall bezeichnet wird, eine Schnittstelle zur Kamera eines Geräts herstellen. Folgende Anwendungsfälle sind möglich:

• Preview (Vorschau): akzeptiert eine Oberfläche zum Anzeigen einer Vorschau, z. B. PreviewView.
• Bildanalyse: Stellt CPU-zugängliche Zwischenspeicher für Analysen bereit, z. B. für maschinelles Lernen.
• Bildaufnahme: Es wird ein Foto aufgenommen und gespeichert.
• Videoaufnahme: Video- und Audioaufnahme mit VideoCapture

Anwendungsfälle können kombiniert und gleichzeitig aktiv sein. Beispielsweise kann eine App Nutzern die Möglichkeit geben, sich das von der Kamera aufgenommene Bild in einem Anwendungsfall der Vorabversion anzusehen, einen Anwendungsfall für die Bildanalyse haben, mit dem bestimmt wird, ob die Personen auf dem Foto lächeln, und einen Anwendungsfall für eine Bildaufnahme enthalten, bei dem ein Bild aufgenommen werden kann, sobald sie es sind.

API-Modell

Geben Sie Folgendes an, um mit der Bibliothek zu arbeiten:

• Der gewünschte Anwendungsfall mit Konfigurationsoptionen.
• Vorgehensweise bei Ausgabedaten durch Anhängen von Listenern.
• Der vorgesehene Ablauf, z. B. wann Kameras aktiviert und Daten generiert werden, indem der Anwendungsfall an Android-Architekturlebenszyklen gebunden wird.

Es gibt zwei Möglichkeiten, eine CameraX-App zu schreiben: CameraController (ideal, wenn Sie die einfachste Möglichkeit haben möchten, CameraX zu verwenden) oder CameraProvider (ideal, wenn Sie mehr Flexibilität benötigen).

Kamerasteuerung

Ein CameraController bietet die meisten CameraX-Hauptfunktionen in einer einzigen Klasse. Es erfordert wenig Einrichtungscode und übernimmt automatisch die Kamerainitialisierung, die Verwaltung von Anwendungsfällen, die Zieldrehung, das Tippen zum Fokussieren, das Zusammenziehen zum Zoomen und vieles mehr. Die konkrete Klasse, die CameraController erweitert, ist LifecycleCameraController.

Kotlin

val previewView: PreviewView = viewBinding.previewView
var cameraController = LifecycleCameraController(baseContext)
cameraController.bindToLifecycle(this)
cameraController.cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
previewView.controller = cameraController

Java

PreviewView previewView = viewBinding.previewView;
LifecycleCameraController cameraController = new LifecycleCameraController(baseContext);
cameraController.bindToLifecycle(this);
cameraController.setCameraSelector(CameraSelector.DEFAULT_BACK_CAMERA);
previewView.setController(cameraController);

Die Standard-UseCases für CameraController sind Preview, ImageCapture und ImageAnalysis. Verwenden Sie die Methode setEnabledUseCases(), um ImageCapture oder ImageAnalysis zu deaktivieren oder VideoCapture zu aktivieren.

Weitere Verwendungen von CameraController finden Sie im Beispiel zum QR-Code-Scanner oder im Grundlagenvideo zu CameraController.

Kameraanbieter

Ein CameraProvider ist immer noch nutzerfreundlich, aber da der App-Entwickler einen größeren Teil der Einrichtung übernimmt, gibt es mehr Möglichkeiten, die Konfiguration anzupassen, z. B. das Drehen des Ausgabebildes oder das Festlegen des Ausgabebildformats in ImageAnalysis. Du kannst auch ein benutzerdefiniertes Surface für die Kameravorschau verwenden, was mehr Flexibilität bietet, während du bei CameraController ein PreviewView verwenden musst. Die Verwendung des vorhandenen Surface-Codes kann nützlich sein, wenn er bereits als Eingabe für andere Teile der Anwendung dient.

Anwendungsfälle werden mit set()-Methoden konfiguriert und mit der Methode build() abgeschlossen. Jedes Anwendungsfallobjekt stellt eine Reihe von anwendungsspezifischen APIs zur Verfügung. Der Anwendungsfall zur Bilderfassung enthält beispielsweise einen takePicture()-Methodenaufruf.

Anstelle einer Anwendung, die bestimmte Start- und Stoppmethodenaufrufe in onResume() und onPause() platziert, gibt die Anwendung mithilfe von cameraProvider.bindToLifecycle() einen Lebenszyklus an, mit dem die Kamera verknüpft werden soll. Anhand dieses Lebenszyklus wird dann CameraX darüber informiert, wann die Kameraaufnahmesitzung konfiguriert werden soll, und stellt sicher, dass der Kamerastatus entsprechend den Lebenszyklusübergängen angepasst wird.

Implementierungsschritte für die einzelnen Anwendungsfälle finden Sie unter Vorschau implementieren, Bilder analysieren, Bildaufnahme und Videoaufnahme.

Der Anwendungsfall „Vorschau“ interagiert zur Anzeige mit einem Surface. Anwendungen erstellen den Anwendungsfall mit Konfigurationsoptionen und dem folgenden Code:

Kotlin

val preview = Preview.Builder().build()
val viewFinder: PreviewView = findViewById(R.id.previewView)

// The use case is bound to an Android Lifecycle with the following code
val camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview)

// PreviewView creates a surface provider and is the recommended provider
preview.setSurfaceProvider(viewFinder.getSurfaceProvider())

Java

Preview preview = new Preview.Builder().build();
PreviewView viewFinder = findViewById(R.id.view_finder);

// The use case is bound to an Android Lifecycle with the following code
Camera camera = cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview);

// PreviewView creates a surface provider, using a Surface from a different
// kind of view will require you to implement your own surface provider.
preview.previewSurfaceProvider = viewFinder.getSurfaceProvider();

Weiteren Beispielcode finden Sie in der offiziellen CameraX-Beispiel-App.

CameraX-Lebenszyklen

CameraX beobachtet einen Lebenszyklus, um zu bestimmen, wann die Kamera geöffnet, wann eine Aufnahmesitzung erstellt sowie beendet und heruntergefahren werden soll. Anwendungsfall-APIs bieten Methodenaufrufe und Callbacks zur Überwachung des Fortschritts.

Wie unter Anwendungsfälle kombinieren erläutert, können Sie verschiedene Anwendungsfälle an einen einzigen Lebenszyklus binden. Wenn deine App Anwendungsfälle unterstützen muss, die nicht kombiniert werden können, hast du folgende Möglichkeiten:

• Gruppieren Sie kompatible Anwendungsfälle in mehr als ein Fragment und wechseln Sie dann zwischen den Fragmenten
• Benutzerdefinierte Lebenszykluskomponente erstellen und zur manuellen Steuerung des Kameralebenszyklus verwenden

Wenn Sie die Lebenszyklusinhaber Ihrer Ansichten und Kamera-Anwendungsfälle entkoppeln (z. B. wenn Sie einen benutzerdefinierten Lebenszyklus oder ein Aufbewahrungsfragment verwenden), müssen Sie die Verknüpfung aller Anwendungsfälle mit CameraX aufheben. Verwenden Sie dazu ProcessCameraProvider.unbindAll() oder heben Sie die Bindung für jeden Anwendungsfall einzeln auf. Wenn Sie Anwendungsfälle an einen Lebenszyklus binden, können Sie alternativ CameraX das Öffnen und Schließen der Aufnahmesitzung sowie das Aufheben der Bindung der Anwendungsfälle überlassen.

Wenn alle Kamerafunktionen dem Lebenszyklus einer einzelnen lebenszyklusbewussten Komponente entsprechen, z. B. eines AppCompatActivity- oder AppCompat-Fragments, können Sie den Lebenszyklus dieser Komponente beim Binden aller gewünschten Anwendungsfälle verwenden, um sicherzustellen, dass die Kamerafunktionalität bereit ist, wenn die lebenszyklusbewusste Komponente aktiv ist. Andernfalls werden keine Ressourcen verbraucht.

Benutzerdefinierte Lebenszyklusinhaber

In erweiterten Fällen kannst du ein benutzerdefiniertes LifecycleOwner erstellen, damit deine App den Lebenszyklus der CameraX-Sitzung explizit steuern kann, anstatt sie mit einer standardmäßigen Android-LifecycleOwner zu verknüpfen.

Das folgende Codebeispiel zeigt, wie Sie einen einfachen benutzerdefinierten LifecycleOwner erstellen:

Kotlin

class CustomLifecycle : LifecycleOwner {
    private val lifecycleRegistry: LifecycleRegistry

    init {
        lifecycleRegistry = LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }
    ...
    fun doOnResume() {
        lifecycleRegistry.markState(State.RESUMED)
    }
    ...
    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class CustomLifecycle implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;
    public CustomLifecycle() {
        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }
   ...
   public void doOnResume() {
        lifecycleRegistry.markState(State.RESUMED);
    }
   ...
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

Mit diesem LifecycleOwner kann Ihre Anwendung Zustandsübergänge an gewünschten Punkten im Code platzieren. Weitere Informationen zur Implementierung dieser Funktion in Ihrer Anwendung finden Sie unter Benutzerdefinierten LifecycleOwner implementieren.

Gleichzeitige Anwendungsfälle

Anwendungsfälle können gleichzeitig ausgeführt werden. Anwendungsfälle können zwar sequenziell an einen Lebenszyklus gebunden werden, es ist jedoch besser, alle Anwendungsfälle mit einem einzigen Aufruf an CameraProcessProvider.bindToLifecycle() zu binden. Weitere Informationen zu Best Practices für Konfigurationsänderungen finden Sie unter Konfigurationsänderungen verarbeiten.

Im folgenden Codebeispiel gibt die Anwendung die beiden Anwendungsfälle an, die gleichzeitig erstellt und ausgeführt werden sollen. Außerdem wird der Lebenszyklus angegeben, der für beide Anwendungsfälle verwendet werden soll, sodass beide gemäß dem Lebenszyklus starten und stoppen.

Kotlin

private lateinit var imageCapture: ImageCapture

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

    cameraProviderFuture.addListener(Runnable {
        // Camera provider is now guaranteed to be available
        val cameraProvider = cameraProviderFuture.get()

        // Set up the preview use case to display camera preview.
        val preview = Preview.Builder().build()

        // Set up the capture use case to allow users to take photos.
        imageCapture = ImageCapture.Builder()
                .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
                .build()

        // Choose the camera by requiring a lens facing
        val cameraSelector = CameraSelector.Builder()
                .requireLensFacing(CameraSelector.LENS_FACING_FRONT)
                .build()

        // Attach use cases to the camera with the same lifecycle owner
        val camera = cameraProvider.bindToLifecycle(
                this as LifecycleOwner, cameraSelector, preview, imageCapture)

        // Connect the preview use case to the previewView
        preview.setSurfaceProvider(
                previewView.getSurfaceProvider())
    }, ContextCompat.getMainExecutor(this))
}

Java

private ImageCapture imageCapture;

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    PreviewView previewView = findViewById(R.id.previewView);

    ListenableFuture<ProcessCameraProvider> cameraProviderFuture =
            ProcessCameraProvider.getInstance(this);

    cameraProviderFuture.addListener(() -> {
        try {
            // Camera provider is now guaranteed to be available
            ProcessCameraProvider cameraProvider = cameraProviderFuture.get();

            // Set up the view finder use case to display camera preview
            Preview preview = new Preview.Builder().build();

            // Set up the capture use case to allow users to take photos
            imageCapture = new ImageCapture.Builder()
                    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
                    .build();

            // Choose the camera by requiring a lens facing
            CameraSelector cameraSelector = new CameraSelector.Builder()
                    .requireLensFacing(lensFacing)
                    .build();

            // Attach use cases to the camera with the same lifecycle owner
            Camera camera = cameraProvider.bindToLifecycle(
                    ((LifecycleOwner) this),
                    cameraSelector,
                    preview,
                    imageCapture);

            // Connect the preview use case to the previewView
            preview.setSurfaceProvider(
                    previewView.getSurfaceProvider());
        } catch (InterruptedException | ExecutionException e) {
            // Currently no exceptions thrown. cameraProviderFuture.get()
            // shouldn't block since the listener is being called, so no need to
            // handle InterruptedException.
        }
    }, ContextCompat.getMainExecutor(this));
}

Die folgenden Konfigurationskombinationen werden garantiert unterstützt (wenn eine Vorschau oder Videoaufnahme erforderlich ist, aber nicht beide gleichzeitig):

Vorschau oder Videoaufnahme	Bildaufnahme	Analyse	Beschreibungen
			Sie können Nutzern eine Vorschau anzeigen oder ein Video aufnehmen, ein Foto aufnehmen und den Bildstream analysieren.
			Machen Sie ein Foto und analysieren Sie den Bildstream.
			Bieten Sie dem Nutzer eine Vorschau oder nehmen Sie ein Video auf und machen Sie ein Foto.
			Sie können Nutzern eine Vorschau bieten oder ein Video aufnehmen und den Bildstream analysieren.

Wenn sowohl die Vorschau als auch die Videoaufnahme erforderlich sind, werden die folgenden Kombinationen von Anwendungsfällen bedingt unterstützt:

Vorschau	Videoaufnahme	Bildaufnahme	Analyse	Besondere Anforderungen
				Garantiert für alle Kameras
				LIMITED (oder besser) Kameragerät.
				Kameragerät LEVEL_3 (oder höher).

Außerdem

• Jeder Anwendungsfall kann für sich allein funktionieren. Beispielsweise kann eine App ein Video ohne Vorschau aufnehmen.
• Wenn Erweiterungen aktiviert sind, funktioniert garantiert nur die Kombination ImageCapture und Preview. Je nach OEM-Implementierung ist es möglicherweise nicht möglich, auch ImageAnalysis hinzuzufügen. Für den Anwendungsfall VideoCapture können keine Erweiterungen aktiviert werden. Weitere Informationen finden Sie in der Referenzdokumentation zu Erweiterungen.
• Je nach Kamerafähigkeit unterstützen einige Kameras die Kombination unter Umständen auch bei niedrigeren Auflösungen. Bei höheren Auflösungen ist dies nicht möglich.

Die unterstützte Hardwareebene kann aus Camera2CameraInfo abgerufen werden. Mit dem folgenden Code wird beispielsweise geprüft, ob die Standardkamera auf der Rückseite ein LEVEL_3-Gerät ist:

Kotlin

@androidx.annotation.OptIn(ExperimentalCamera2Interop::class)
fun isBackCameraLevel3Device(cameraProvider: ProcessCameraProvider) : Boolean {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        return CameraSelector.DEFAULT_BACK_CAMERA
            .filter(cameraProvider.availableCameraInfos)
            .firstOrNull()
            ?.let { Camera2CameraInfo.from(it) }
            ?.getCameraCharacteristic(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) ==
            CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3
    }
    return false
}

Java

@androidx.annotation.OptIn(markerClass = ExperimentalCamera2Interop.class)
Boolean isBackCameraLevel3Device(ProcessCameraProvider cameraProvider) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        List\ filteredCameraInfos = CameraSelector.DEFAULT_BACK_CAMERA
                .filter(cameraProvider.getAvailableCameraInfos());
        if (!filteredCameraInfos.isEmpty()) {
            return Objects.equals(
                Camera2CameraInfo.from(filteredCameraInfos.get(0)).getCameraCharacteristic(
                        CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL),
                CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_3);
        }
    }
    return false;
}

Hinweis: Wird eine inkompatible Kombination von Anwendungsfällen erstellt, wird beim ersten Aufruf von createCaptureSession() ein Laufzeitfehler ausgegeben. Wenn der laufenden Sitzung weitere Anwendungsfälle hinzugefügt werden, ist möglicherweise eine Neukonfiguration erforderlich, was zu einer sichtbaren Störung führen kann.

Berechtigungen

Ihre App benötigt die Berechtigung CAMERA. Zum Speichern von Bildern in Dateien ist außerdem die Berechtigung WRITE_EXTERNAL_STORAGE erforderlich, außer auf Geräten mit Android 10 oder höher.

Weitere Informationen zum Konfigurieren von Berechtigungen für Ihre App finden Sie unter App-Berechtigungen anfordern.

Voraussetzungen

CameraX hat die folgenden Mindestversionsanforderungen:

• Android API-Level 21
• Android-Architekturkomponenten 1.1.1

Verwenden Sie für Aktivitäten, die den Lebenszyklus berücksichtigen, FragmentActivity oder AppCompatActivity.

Abhängigkeiten deklarieren

Zum Hinzufügen einer Abhängigkeit von CameraX müssen Sie Ihrem Projekt das Google Maven-Repository hinzufügen.

Öffnen Sie die Datei settings.gradle für Ihr Projekt und fügen Sie das Repository google() hinzu, wie hier gezeigt:

Groovig

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

Kotlin

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

Fügen Sie am Ende des Android-Blocks Folgendes hinzu:

Groovig

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    // For Kotlin projects
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Kotlin

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    // For Kotlin projects
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Füge der build.gradle-Datei jedes Moduls für eine App Folgendes hinzu:

Groovy

dependencies {
  // CameraX core library using the camera2 implementation
  def camerax_version = "1.4.0-alpha05"
  // The following line is optional, as the core library is included indirectly by camera-camera2
  implementation "androidx.camera:camera-core:${camerax_version}"
  implementation "androidx.camera:camera-camera2:${camerax_version}"
  // If you want to additionally use the CameraX Lifecycle library
  implementation "androidx.camera:camera-lifecycle:${camerax_version}"
  // If you want to additionally use the CameraX VideoCapture library
  implementation "androidx.camera:camera-video:${camerax_version}"
  // If you want to additionally use the CameraX View class
  implementation "androidx.camera:camera-view:${camerax_version}"
  // If you want to additionally add CameraX ML Kit Vision Integration
  implementation "androidx.camera:camera-mlkit-vision:${camerax_version}"
  // If you want to additionally use the CameraX Extensions library
  implementation "androidx.camera:camera-extensions:${camerax_version}"
}

Kotlin

dependencies {
    // CameraX core library using the camera2 implementation
    val camerax_version = "1.4.0-alpha05"
    // The following line is optional, as the core library is included indirectly by camera-camera2
    implementation("androidx.camera:camera-core:${camerax_version}")
    implementation("androidx.camera:camera-camera2:${camerax_version}")
    // If you want to additionally use the CameraX Lifecycle library
    implementation("androidx.camera:camera-lifecycle:${camerax_version}")
    // If you want to additionally use the CameraX VideoCapture library
    implementation("androidx.camera:camera-video:${camerax_version}")
    // If you want to additionally use the CameraX View class
    implementation("androidx.camera:camera-view:${camerax_version}")
    // If you want to additionally add CameraX ML Kit Vision Integration
    implementation("androidx.camera:camera-mlkit-vision:${camerax_version}")
    // If you want to additionally use the CameraX Extensions library
    implementation("androidx.camera:camera-extensions:${camerax_version}")
}

Weitere Informationen zum Konfigurieren der Anwendung, um diese Anforderungen zu erfüllen, finden Sie unter Abhängigkeiten deklarieren.

CameraX-Interoperabilität mit Camera2

CameraX basiert auf Camera2 und CameraX bietet Möglichkeiten zum Lesen und Schreiben von Eigenschaften in der Camera2-Implementierung. Ausführliche Informationen finden Sie im Interop-Paket.

Wenn Sie weitere Informationen dazu erhalten möchten, wie CameraX die Camera2-Eigenschaften konfiguriert hat, können Sie mit Camera2CameraInfo den zugrunde liegenden CameraCharacteristics lesen. Sie können die zugrunde liegenden Camera2-Eigenschaften auch in einen der folgenden zwei Pfade schreiben:

• Verwenden Sie Camera2CameraControl, um Eigenschaften für den zugrunde liegenden CaptureRequest festzulegen, z. B. den Autofokusmodus.

• Erweitern Sie CameraX UseCase mit einem Camera2Interop.Extender. Damit können Sie Attribute für die CaptureRequest festlegen, genau wie bei Camera2CameraControl. Außerdem stehen Ihnen einige zusätzliche Einstellungen zur Verfügung, z. B. können Sie den Anwendungsfall für den Stream festlegen, um die Kamera für Ihr Nutzungsszenario zu optimieren. Weitere Informationen finden Sie unter Anwendungsfälle für Streams zur Leistungsverbesserung.

Hinweis :Das Festlegen der zugrunde liegenden Camera2-Eigenschaften in CameraX wird als „Experimentell“ gekennzeichnet, da Google erwartet, dass Entwickler die Verwendung verstehen. Die von Ihnen festgelegten Werte überschreiben alle von CameraX festgelegten Werte. Wir empfehlen, dies nur zu tun, wenn es unbedingt erforderlich ist, und empfehlen weitere Tests von Ihrer Seite.

Im folgenden Codebeispiel werden Anwendungsfälle für Streams zur Optimierung für Videoanrufe verwendet. Rufen Sie mit Camera2CameraInfo ab, ob der Anwendungsfall für den Videoanruf-Stream verfügbar ist. Verwenden Sie dann Camera2Interop.Extender, um den Anwendungsfall des zugrunde liegenden Streams festzulegen.

Kotlin

// Set underlying Camera2 stream use case to optimize for video calls.

val videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong()

// Check available CameraInfos to find the first one that supports
// the video call stream use case.
val frontCameraInfo = cameraProvider.getAvailableCameraInfos()
    .first { cameraInfo ->
        val isVideoCallStreamingSupported = Camera2CameraInfo.from(cameraInfo)
            .getCameraCharacteristic(
                CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES
            )?.contains(videoCallStreamId)
        val isFrontFacing = (cameraInfo.getLensFacing() == 
                             CameraSelector.LENS_FACING_FRONT)
        (isVideoCallStreamingSupported == true) && isFrontFacing
    }

val cameraSelector = frontCameraInfo.cameraSelector

// Start with a Preview Builder.
val previewBuilder = Preview.Builder()
    .setTargetAspectRatio(screenAspectRatio)
    .setTargetRotation(rotation)

// Use Camera2Interop.Extender to set the video call stream use case.
Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId)

// Bind the Preview UseCase and the corresponding CameraSelector.
val preview = previewBuilder.build()
camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)

Java

// Set underlying Camera2 stream use case to optimize for video calls.

Long videoCallStreamId =
    CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL.toLong();

// Check available CameraInfos to find the first one that supports
// the video call stream use case.
List<CameraInfo> cameraInfos = cameraProvider.getAvailableCameraInfos();
CameraInfo frontCameraInfo = null;
for (cameraInfo in cameraInfos) {
    Long[] availableStreamUseCases = Camera2CameraInfo.from(cameraInfo)
        .getCameraCharacteristic(
            CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES
        );
    boolean isVideoCallStreamingSupported = Arrays.List(availableStreamUseCases)
                .contains(videoCallStreamId);
    boolean isFrontFacing = (cameraInfo.getLensFacing() ==
                             CameraSelector.LENS_FACING_FRONT);

    if (isVideoCallStreamingSupported && isFrontFacing) {
        frontCameraInfo = cameraInfo;
    }
}

if (frontCameraInfo == null) {
    // Handle case where video call streaming is not supported.
}

CameraSelector cameraSelector = frontCameraInfo.getCameraSelector();

// Start with a Preview Builder.
Preview.Builder previewBuilder = Preview.Builder()
    .setTargetAspectRatio(screenAspectRatio)
    .setTargetRotation(rotation);

// Use Camera2Interop.Extender to set the video call stream use case.
Camera2Interop.Extender(previewBuilder).setStreamUseCase(videoCallStreamId);

// Bind the Preview UseCase and the corresponding CameraSelector.
Preview preview = previewBuilder.build()
Camera camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)

Weitere Informationen

Weitere Informationen zu CameraX finden Sie in den folgenden zusätzlichen Ressourcen.

Codelab

Erste Schritte mit CameraX

Codebeispiel

CameraX-Beispiel-Apps