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-UseCase
s 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
undPreview
garantiert. Je nach OEM-Implementierung ist es eventuell nicht möglich,ImageAnalysis
ebenfalls hinzuzufügen. Für den AnwendungsfallVideoCapture
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-rc01" // 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-rc01" // 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 liegendeCaptureRequest
festlegen, z. B. den Autofokusmodus.Erweitere eine CameraX-
UseCase
um eineCamera2Interop.Extender
. So können Sie Attribute für CaptureRequest wieCamera2CameraControl
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
Codebeispiel