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-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 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
undPreview
. Je nach OEM-Implementierung ist es möglicherweise nicht möglich, auchImageAnalysis
hinzuzufügen. Für den AnwendungsfallVideoCapture
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; }
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:
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 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 liegendenCaptureRequest
festzulegen, z. B. den Autofokusmodus.Erweitern Sie CameraX
UseCase
mit einemCamera2Interop.Extender
. Damit können Sie Attribute für die CaptureRequest festlegen, genau wie beiCamera2CameraControl
. 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.
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)
Zusätzliche Ressourcen
Weitere Informationen zu CameraX finden Sie in den folgenden zusätzlichen Ressourcen.
Codelab
Codebeispiel