CameraX mimarisi

Bu sayfada, yapısı, API ile çalışma, yaşam döngüleriyle çalışma ve kullanım alanlarının nasıl birleştirileceği de dahil olmak üzere CameraX mimarisi ele alınmaktadır.

CameraX yapısı

KameraX'i kullanarak bir cihazın kamerasıyla arayüz oluşturabilirsiniz: kullanım alanı adı verilen soyutlama. Aşağıdaki kullanım alanları mevcuttur:

  • Önizleme: Önizleme görüntülemek için bir yüzeyi kabul eder (örneğin, PreviewView.
  • Görüntü analizi: Analiz için CPU tarafından erişilebilen arabellekler sağlar. Örneğin, bir ekiple çalışıyorum.
  • Resim çekme: Fotoğraf çeker ve kaydeder.
  • Video çekimi: VideoCapture ile video ve ses kaydedin

Kullanım alanları eşzamanlı olarak birleştirilebilir ve etkin olabilir. Örneğin, bir uygulama önizleme kullanım alanı kullanarak kameranın gördüğü resmi görüntüler, fotoğraftaki kişilerin başarılı olup olmadığını belirleyen bir görüntü analizi kullanım alanı gülümseyen bir grup insanın yer aldığı bir fotoğraf ekleyin.

API modeli

Kitaplıkta çalışmak için şunları belirtirsiniz:

  • Yapılandırma seçenekleriyle istenen kullanım alanı.
  • Dinleyici ekleyerek çıkış verileriyle ne yapmalı?
  • Kameraların ne zaman etkinleştirileceği ve verilerin ne zaman üretileceği gibi istenen akış kullanım alanını Android Mimarisi'ne Yaşam döngüleri.

CameraX uygulaması yazmanın 2 yolu vardır: CameraController (şu durumlarda idealdir: CameraX'ı kullanmanın en basit yolunu istiyorsanız) veya CameraProvider (şu durumda harikadır: daha fazla esnekliğe ihtiyaç duyar).

Kamera Kumandası

CameraController, CameraX temel işlevlerinin çoğunu tek bir uygulamada sunar. sınıfını kullanır. Az kurulum kodu gerektirir ve kamerayı otomatik olarak işler başlatma, kullanım alanı yönetimi, hedef döndürme, dokunarak odaklama, yakınlaştırma ve uzaklaştırma gibi özellikler sunar. CameraController öğesini genişleten beton sınıf: 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);

CameraController için varsayılan UseCase'ler Preview, ImageCapture ve ImageAnalysis. ImageCapture veya ImageAnalysis özelliğini kapatmak ya da kapatmak için: VideoCapture açık, setEnabledUseCases() yöntemidir.

CameraController işlevinin diğer kullanım şekilleri için bkz. QR Kodu tarayıcı örneği veya CameraController ile ilgili temel bilgiler videosu.

Kamera Sağlayıcısı

CameraProvider kullanımı yine de kolaydır, ancak uygulama geliştirici tarafından halledildiğinden yapılandırmayı özelleştirmek için daha çok fırsat ortaya çıktığında, Örneğin çıkış resmi döndürmesini etkinleştirme veya çıkış resmi biçimini ImageAnalysis. Ayrıca kamera önizlemesi için özel bir Surface kullanabilirsiniz. için kamera Denetleyicisi'ni kullanmanız gerekir. CameraController'da PreviewView. Şu durumda mevcut Surface kodunuzu kullanmak yararlı olabilir: uygulamanızın diğer kısımlarına zaten giriş niteliğindedir.

Kullanım alanlarını set() yöntemleriyle yapılandırır ve build() ile sonlandırırsınız. yöntemidir. Her kullanım alanı nesnesi, kullanım alanına özel bir dizi API sağlar. Örneğin, Örneğin, görüntü yakalama kullanım alanı bir takePicture() yöntem çağrısı sağlar.

Bir uygulama tarafından belirli bir başlatma ve durdurma yöntemi onResume() ve onPause(); uygulama, ilişkilendirilecek bir yaşam döngüsü belirler kullanarak, cameraProvider.bindToLifecycle(). Bu yaşam döngüsü daha sonra CameraX'e, kamera çekimi oturumunun ne zaman yapılandırılacağını bildirir ve kamera durumunun yaşam döngüsü geçişlerine uygun şekilde değişmesini sağlar.

Her bir kullanım alanına yönelik uygulama adımları için Uygulama önizleme, Analiz etme resimler, Resim yakalama ve video çekimi

Önizleme kullanım alanı, Görüntülü reklam için Surface. Uygulamalar aşağıdaki kodu kullanarak yapılandırma seçenekleriyle kullanım alanını oluşturun:

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();

Daha fazla örnek kod için resmi CameraX örneğine bakın. uygulamasında gösterilir.

CameraX Yaşam Döngüleri

CameraX, kameranın ne zaman açılacağını ve ne zaman açılacağını belirlemek için bir yaşam döngüsü gözlemler yakalama oturumu oluşturabileceğinizi ve ne zaman durdurulup kapatılacağını öğreneceksiniz. Kullanım alanı API'lerinin sağladığı yöntem çağrıları ve geri çağırmalar içerir.

Kullanım alanlarını birleştirme konusunda açıklandığı gibi, tek bir yaşam döngüsüne dönüşmesini sağlar. Uygulamanızın aşağıdaki kullanım alanlarını desteklemesi gerektiğinde birleştirilemediğinde aşağıdakilerden birini yapabilirsiniz:

  • Uyumlu kullanım alanlarını birden fazla olacak şekilde gruplandırın parça ve ardından parçalar
  • Özel yaşam döngüsü bileşeni oluşturma ve kamerayı manuel olarak kontrol etme yaşam döngüsü

Görüş ve kamera kullanım alanlarınızı ayırırsanız Yaşam döngüsü sahipleri (örneğin, özel bir yaşam döngüsü veya fragman), ardından ProcessCameraProvider.unbindAll() her kullanım alanının bağlantısını tek tek kaldırarak yapabilirsiniz. Alternatif olarak, bir Yaşam Döngüsü olarak kullanabilirsiniz, CameraX'ın yakalama oturumunun açılıp kapatılmasını ve kullanım alanlarının bağlantısını kaldırmayı yönetebilir.

Kameranızın tüm işlevleri tek bir cihazın yaşam döngüsüne karşılık geliyorsa yaşam döngüsüne duyarlı bileşen AppCompatActivity veya bir AppCompat parçası, daha sonra bağlama sırasında o bileşenin yaşam döngüsü kullanılıyor tüm kullanım alanları, kamera işlevselliğinin hazır olmasını sağlar. akıllı bileşen etkin olduğunda ve güvenli bir şekilde imha edildiğinde gerektiğini unutmayın.

Özel Yaşam Döngüsü Sahipleri

İleri düzey destek kayıtları için özel LifecycleOwner bağlamak yerine CameraX oturum yaşam döngüsünü açıkça denetlemesini standart Android LifecycleOwner.

Aşağıdaki kod örneğinde basit bir özel LifecycleOwner'ın nasıl oluşturulacağı gösterilmektedir:

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

Uygulamanız bu LifecycleOwner cihazını kullanarak istediğiniz zaman durum geçişleri yapabilir kodunu ekleyin. Bu işlevi uygulamanızda kullanma hakkında daha fazla bilgi için bkz. Özel LifecycleOwner (İş Döngüsü Sahibi) gibi adımları inceleyin.

Eş zamanlı kullanım alanları

Kullanım alanları eş zamanlı olarak çalışabilir. Kullanım alanları sıralı olarak bir yaşam döngüsü boyunca, tek bir çağrı ile tüm kullanım alanlarını CameraProcessProvider.bindToLifecycle() En iyi uygulamalar hakkında daha fazla bilgi için daha fazla bilgi için Herkese açık kullanıcı adı yapılandırması değişiklikler başlıklı makaleyi inceleyin.

Aşağıdaki kod örneğinde uygulama, oluşturulacak iki kullanım alanını belirtir aynı anda çalışır. Ayrıca bu iki kullanım için kullanılacak yaşam döngüsünü bu süreçlerin yaşam döngüsüne göre başlamasını ve durmasını sağlar.

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

Aşağıdaki yapılandırma kombinasyonlarının destekleneceği garanti edilir ( Önizleme veya Video Yakalama gereklidir, ancak aynı anda ikisi birden kullanılamaz):

Önizleme veya Video Yakalama Görüntü yakalama Analiz Açıklamalar
Kullanıcıya bir önizleme veya video kaydı sağlama, fotoğraf çekme ve analiz etme resim akışını takip eder.
  Bir fotoğraf çekin ve görüntü akışını analiz edin.
  Kullanıcıya bir önizleme veya video kaydı sağlayın ve fotoğraf çekin.
  Kullanıcıya bir önizleme veya video kaydı sunma ve resmi analiz etme akış şeklinde gösterilir.

Hem Önizleme hem de Video Yakalama gerekli olduğunda aşağıdaki kullanım alanı kombinasyonlar koşullu olarak desteklenir:

Önizle Video çekimi Görüntü yakalama Analiz Özel koşul
    Tüm kameralar için garantili
  LIMITED (veya daha iyi) kameralı cihaz.
  LEVEL_3 (veya daha iyi) kamera cihazı.

Ayrıca,

  • Her kullanım alanı kendi başına işe yarayabilir. Örneğin, bir uygulama video kaydedebilir önizleme özelliğini kullanabilirsiniz.
  • Uzantılar etkinleştirildiğinde yalnızca ImageCapture ve Preview kombinasyonun çalışacağı garanti edilir. OEM uygulamasına bağlı olarak, ImageAnalysis eklemek mümkün olmayabilir; uzantılar VideoCapture kullanım alanı için etkinleştirilmelidir. Kontrol edin Uzantı referans belgesi inceleyebilirsiniz.
  • Kamera kapasitesine bağlı olarak, bazı kameralar daha düşük çözünürlük modları vardır, ancak bazı cihazlarda aynı kombinasyonu destekleyemez. kullanabilirsiniz.

Desteklenen donanım düzeyi Camera2CameraInfo adresinden alınabilir. Örneğin, aşağıdaki kod varsayılan arka kameranın LEVEL_3 cihaz olup olmadığını kontrol eder:

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

İzinler

Uygulamanız için CAMERA izni. Alıcı: dosyaları kaydederken ayrıca dosya oluşturma sırasında WRITE_EXTERNAL_STORAGE (Android 10 veya sonraki sürümleri çalıştıran cihazlar hariç)

Uygulamanızın izinlerini yapılandırma hakkında daha fazla bilgi için İstekte bulunma Uygulama İzinleri.

Gereksinimler

CameraX aşağıdaki minimum sürüm gereksinimlerine sahiptir:

  • Android API düzeyi 21
  • Android Mimari Bileşenleri 1.1.1

Yaşam döngüsüne duyarlı etkinlikler için FragmentActivity veya AppCompatActivity.

Bağımlılıkları belirtme

CameraX'e bağımlılık eklemek için Google Maven repository'yi projenize ekleyebilirsiniz.

Projeniz için settings.gradle dosyasını açın ve google() deposunu ekleyin aşağıda gösterildiği gibidir:

Eski

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

Kotlin

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

Aşağıdakini Android bloğunun sonuna ekleyin:

Eski

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

Uygulama için her modülün build.gradle dosyasına aşağıdakileri ekleyin:

Eski

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}")
}

Uygulamanızı bu gereksinimlere uyacak şekilde yapılandırma hakkında daha fazla bilgi için Beyan bağımlılıklarını görebilirsiniz.

Camera2 ile CameraX birlikte çalışabilirliği

CameraX, Camera2 üzerine inşa edilmiştir ve CameraX, okuma ve hatta yazma yöntemlerini sunar özelliklerine bakın. Tüm ayrıntılar için bkz. Birlikte çalışabilirlik paketi.

CameraX'ın Camera2 özelliklerini nasıl yapılandırdığı hakkında daha fazla bilgi için Camera2CameraInfo CameraCharacteristics Kamera2'nin temelini belirten bir özellikleri aşağıdaki iki yoldan birinde kullanabilirsiniz:

ziyaret edin.

Aşağıdaki kod örneğinde, görüntülü görüşme için optimizasyon yapmak amacıyla akış kullanım alanları kullanılmaktadır. Camera2CameraInfo kullanın görüntülü görüşme akışı kullanım alanının mevcut olup olmadığını getirir. Daha sonra, Camera2Interop.Extender temel akış kullanım alanını belirlemek için kullanabilirsiniz.

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)

Ek kaynaklar

CameraX hakkında daha fazla bilgi edinmek için aşağıdaki ek kaynaklara bakın.

Kod Laboratuvarı

  • CameraX'i Kullanmaya Başlama

    • Kod örneği

  • CameraX örnek uygulamaları

    •