Diese Seite wurde von der Cloud Translation API übersetzt.

CameraX-Architektur

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

CameraX-Struktur

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

Preview (Vorschau): Hier wird eine Oberfläche zur Vorschau angezeigt, z. B. PreviewView.
Bildanalyse: stellt CPU-zugängliche Zwischenspeicher für Analysen bereit, z. B. für maschinelles Lernen.
Bildaufnahme: Hiermit können Sie ein Foto aufnehmen und speichern.
Videoaufnahme: Mit VideoCapture können Sie Video- und Audioinhalte aufnehmen.

Anwendungsfälle können kombiniert und gleichzeitig aktiv sein. Beispielsweise kann eine App es dem Nutzer ermöglichen, das Bild, das die Kamera sieht, in einem Vorschauanwendungsfall anzusehen, einen Bildanalyse-Anwendungsfall zu haben, der bestimmt, ob die Personen auf dem Foto lächeln, und einen Anwendungsfall zur Bilderfassung hat, um ein Bild aufzunehmen, sobald sie es sind.

API-Modell

Um mit der Bibliothek zu arbeiten, müssen Sie Folgendes angeben:

Der gewünschte Anwendungsfall mit Konfigurationsoptionen.
Was mit Ausgabedaten durch Anhängen von Listenern geschehen soll.
Der vorgesehene Ablauf, z. B. wann Kameras aktiviert und wann Daten erzeugt werden, indem der Anwendungsfall an Android-Architekturlebenszyklus gebunden wird.

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

Kamera-Controller

Ein CameraController bietet die meisten Hauptfunktionen von CameraX in einer einzigen Klasse. Es erfordert wenig Einrichtungscode und übernimmt automatisch die Kamerainitialisierung, die Verwaltung von Anwendungsfällen, die Zielrotation, das Tippen zum Fokussieren, das Zoomen durch Auseinander- und Zusammenziehen und 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 QR-Code-Scanner-Beispiel oder im Video zu den CameraController-Grundlagen.

Kameraanbieter

Ein CameraProvider ist trotzdem einfach zu verwenden, aber da der App-Entwickler sich um einen größeren Teil der Einrichtung kümmert, gibt es mehr Möglichkeiten zur Anpassung der Konfiguration, z. B. um die Ausgabebildrotation zu aktivieren oder das Ausgabebildformat in ImageAnalysis festzulegen. Du kannst auch ein benutzerdefiniertes Surface für die Kameravorschau verwenden, das mehr Flexibilität bietet, während du für CameraController eine PreviewView verwenden musst. Die Verwendung des vorhandenen Surface-Codes kann nützlich sein, wenn er bereits eine Eingabe für andere Teile Ihrer App ist.

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

Anstatt bestimmte Start- und Stoppmethodenaufrufe in onResume() und onPause() zu platzieren, legt die Anwendung mithilfe von cameraProvider.bindToLifecycle() einen Lebenszyklus fest, mit dem die Kamera verknüpft werden soll. Dieser Lebenszyklus informiert dann CameraX darüber, wann die Kameraaufnahmesitzung konfiguriert werden soll, und sorgt dafür, 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 der Vorabversion interagiert mit einem Surface zur Anzeige. Anwendungen erstellen den Anwendungsfall mit Konfigurationsoptionen mithilfe des folgenden Codes:

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 findest du in der offiziellen CameraX-Beispiel-App.

Kamera-Lebenszyklen

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

Wie unter Anwendungsfälle kombinieren erläutert, können Sie verschiedene Kombinationen von Anwendungsfällen an einen einzelnen Lebenszyklus binden. Wenn Ihre Anwendung Anwendungsfälle unterstützen muss, die nicht kombiniert werden können, haben Sie folgende Möglichkeiten:

Kompatible Anwendungsfälle zu mehr als einem Fragment gruppieren und dann zwischen Fragmenten wechseln
Benutzerdefinierte Lebenszykluskomponente erstellen und damit den Kamera-Lebenszyklus manuell steuern

Wenn Sie die Lebenszyklusinhaber Ihrer Ansichts- und Kameraanwendungsfälle entkoppeln (z. B. wenn Sie einen benutzerdefinierten Lebenszyklus oder ein Beibehaltungsfragment 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 das Öffnen und Schließen der Erfassungssitzung von CameraX übernehmen und die Bindung der Anwendungsfälle aufheben.

Wenn die gesamte Kamerafunktionalität dem Lebenszyklus einer einzelnen Komponente mit Blick auf den Lebenszyklus entspricht, z. B. eines AppCompatActivity- oder AppCompat-Fragments, wird durch die Verwendung des Lebenszyklus dieser Komponente beim Binden aller gewünschten Anwendungsfälle sichergestellt, dass die Kamerafunktion einsatzbereit ist, wenn die Komponente aktiv ist, und sicher entsorgt wird, ohne andere Ressourcen zu verbrauchen.

Benutzerdefinierte Lebenszyklusinhaber

In komplexeren Fällen kannst du eine benutzerdefinierte LifecycleOwner erstellen, damit deine App den Kamera-Sitzungslebenszyklus explizit steuern kann, anstatt sie mit einem 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 Statusübergänge an gewünschten Stellen 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 sein, 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 Umgang mit Konfigurationsänderungen.

Im folgenden Codebeispiel werden für die Anwendung die beiden Anwendungsfälle angegeben, die gleichzeitig erstellt und ausgeführt werden sollen. Außerdem wird der Lebenszyklus für beide Anwendungsfälle angegeben, sodass sie je nach Lebenszyklus gestartet und beendet werden.

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 Vorschau oder Videoaufnahme erforderlich sind, aber nicht beide gleichzeitig):

Vorschau oder VideoCapture	Bildaufnahme	Analyse	Beschreibungen
			Sie können Nutzern eine Vorschau bereitstellen oder ein Video aufnehmen, ein Foto aufnehmen und den Bildstream analysieren.
			Machen Sie ein Foto und analysieren Sie den Bildstream.
			Zeigen Sie dem Nutzer eine Vorschau oder nehmen Sie ein Video auf und machen Sie ein Foto.
			Sie können Nutzern eine Vorschau bereitstellen oder ein Video aufnehmen und den Bildstream analysieren.

Wenn sowohl „Preview“ als auch „Video Capture“ erforderlich sind, werden die folgenden Kombinationen von Anwendungsfällen bedingt unterstützt:

Vorschau	Videoaufnahme	Bildaufnahme	Analyse	Besondere Anforderung
				Für alle Kameras garantiert
				LIMITED (oder besser) Kameragerät.
				Kameragerät der Stufe LEVEL_3 (oder besser).

Außerdem

Jeder Anwendungsfall kann eigenständig funktionieren. Eine App kann z. B. ein Video ohne Vorschau aufnehmen.
Wenn Erweiterungen aktiviert sind, funktioniert nur die Kombination aus ImageCapture und Preview garantiert. Je nach OEM-Implementierung ist es eventuell nicht möglich, ImageAnalysis ebenfalls hinzuzufügen. Für den Anwendungsfall VideoCapture können keine Erweiterungen aktiviert werden. Weitere Informationen finden Sie in der Referenzdokumentation zu Erweiterungen.
Je nach Kameraleistung unterstützen einige Kameras die Kombination bei Modi mit niedrigerer Auflösung, aber nicht dieselbe Kombination bei höheren Auflösungen.

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;
}

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 deine App findest du unter App-Berechtigungen anfordern.

Voraussetzungen

Für CameraX gelten die folgenden Mindestversionsanforderungen:

Android API-Level 21
Android-Architekturkomponenten 1.1.1

Verwenden Sie für Lebenszyklusaktivitäten FragmentActivity oder AppCompatActivity.

Abhängigkeiten deklarieren

Wenn Sie eine Abhängigkeit von CameraX hinzufügen möchten, müssen Sie Ihrem Projekt das Maven-Repository von Google hinzufügen.

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

Cool

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 ein:

Cool

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ügen Sie der build.gradle-Datei jedes Moduls für eine App Folgendes hinzu:

Groovig

dependencies {
  // CameraX core library using the camera2 implementation
  def camerax_version = "1.4.0-beta02"
  // 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-beta02"
    // 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 dazu, wie Sie Ihre Anwendung so konfigurieren, dass sie diesen Anforderungen entspricht, finden Sie unter Abhängigkeiten angeben.

Interoperabilität von CameraX mit Camera2

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

Weitere Informationen zur Konfiguration von Kamera2-Eigenschaften in CameraX findest du in der zugrunde liegenden CameraCharacteristics-Datei mit Camera2CameraInfo. Du kannst die zugrunde liegenden Camera2-Eigenschaften auch auf einen der beiden folgenden Wege schreiben:

Mit Camera2CameraControl können Sie Attribute für das zugrunde liegende CaptureRequest festlegen, z. B. den Autofokusmodus.
Erweitere eine CameraX-UseCase um eine Camera2Interop.Extender. So können Sie Attribute für CaptureRequest wie Camera2CameraControl festlegen. Außerdem stehen Ihnen zusätzliche Steuerelemente 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 verwenden.

Im folgenden Codebeispiel werden Stream-Anwendungsfälle für die 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)

Zusätzliche Ressourcen

Weitere Informationen zu CameraX finden Sie in den folgenden Ressourcen.

Codelab

Erste Schritte mit CameraX

Codebeispiel

Beispiel-Apps für CameraX