CameraX Uzantıları API'sı

CameraX, cihaz üreticilerinin çeşitli Android cihazlara uyguladığı uzantılara erişmek için bir Extensions API'si sağlar. Desteklenen uzantı modlarının listesi için Kamera uzantıları başlıklı makaleyi inceleyin.

Uzantıları destekleyen cihazların listesi için Desteklenen cihazlar başlıklı makaleye bakın.

Uzantı mimarisi

Aşağıdaki resimde kamera uzantıları mimarisi gösterilmektedir.

Şekil 1. Kamera Uzantıları mimarisi

CameraX uygulaması, uzantıları CameraX Extensions API üzerinden kullanabilir. CameraX Extensions API, kullanılabilir uzantılar için sorgulamayı, uzantı kamera oturumunu yapılandırmayı ve Kamera Uzantıları OEM kitaplığıyla iletişimi yönetir. Bu sayede uygulamanız Gece, HDR, Otomatik, Bokeh veya Yüz Rötuşu gibi özellikleri kullanabilir.

Resim yakalama ve önizleme için uzantı etkinleştir

Uzantılar API'sini kullanmadan önce ExtensionsManager#getInstanceAsync(Context, CameraProvider) yöntemini kullanarak bir ExtensionsManager örneği alın. Bu sayede, uzantı kullanılabilirliği bilgilerini sorgulayabilirsiniz. Ardından, CameraSelector etkin bir uzantıyı alın. Uzantı modu, CameraSelector uzantısı etkin olarak bindToLifecycle() yöntemi çağrılırken görüntü yakalama ve önizleme kullanım durumlarına uygulanır.

Uzantıyı görüntü yakalama ve önizleme kullanım alanlarında uygulamak için aşağıdaki kod örneğine bakın:

Kotlin

import androidx.camera.extensions.ExtensionMode
import androidx.camera.extensions.ExtensionsManager

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val lifecycleOwner = this

    val cameraProviderFuture = ProcessCameraProvider.getInstance(applicationContext)
    cameraProviderFuture.addListener({
        // Obtain an instance of a process camera provider
        // The camera provider provides access to the set of cameras associated with the device.
        // The camera obtained from the provider will be bound to the activity lifecycle.
        val cameraProvider = cameraProviderFuture.get()

        val extensionsManagerFuture =
            ExtensionsManager.getInstanceAsync(applicationContext, cameraProvider)
        extensionsManagerFuture.addListener({
            // Obtain an instance of the extensions manager
            // The extensions manager enables a camera to use extension capabilities available on
            // the device.
            val extensionsManager = extensionsManagerFuture.get()

            // Select the camera
            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

            // Query if extension is available.
            // Not all devices will support extensions or might only support a subset of
            // extensions.
            if (extensionsManager.isExtensionAvailable(cameraSelector, ExtensionMode.NIGHT)) {
                // Unbind all use cases before enabling different extension modes.
                try {
                    cameraProvider.unbindAll()

                    // Retrieve a night extension enabled camera selector
                    val nightCameraSelector =
                        extensionsManager.getExtensionEnabledCameraSelector(
                            cameraSelector,
                            ExtensionMode.NIGHT
                        )

                    // Bind image capture and preview use cases with the extension enabled camera
                    // selector.
                    val imageCapture = ImageCapture.Builder().build()
                    val preview = Preview.Builder().build()
                    // Connect the preview to receive the surface the camera outputs the frames
                    // to. This will allow displaying the camera frames in either a TextureView
                    // or SurfaceView. The SurfaceProvider can be obtained from the PreviewView.
                    preview.setSurfaceProvider(surfaceProvider)

                    // Returns an instance of the camera bound to the lifecycle
                    // Use this camera object to control various operations with the camera
                    // Example: flash, zoom, focus metering etc.
                    val camera = cameraProvider.bindToLifecycle(
                        lifecycleOwner,
                        nightCameraSelector,
                        imageCapture,
                        preview
                    )
                } catch (e: Exception) {
                    Log.e(TAG, "Use case binding failed", e)
                }
            }
        }, ContextCompat.getMainExecutor(this))
    }, ContextCompat.getMainExecutor(this))
}

Java

import androidx.camera.extensions.ExtensionMode;
import androidx.camera.extensions.ExtensionsManager;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    final LifecycleOwner lifecycleOwner = this;

    final ListenableFuture cameraProviderFuture =
            ProcessCameraProvider.getInstance(getApplicationContext());

    cameraProviderFuture.addListener(() -> {
      try {
          // Obtain an instance of a process camera provider
          // The camera provider provides access to the set of cameras associated with the
          // device. The camera obtained from the provider will be bound to the activity
          // lifecycle.
          final ProcessCameraProvider cameraProvider = cameraProviderFuture.get();

          final ListenableFuture extensionsManagerFuture =
                  ExtensionsManager.getInstanceAsync(getApplicationContext(), cameraProvider);
          extensionsManagerFuture.addListener(() -> {
              // Obtain an instance of the extensions manager
              // The extensions manager enables a camera to use extension capabilities available
              // on the device.
              try {
                  final ExtensionsManager extensionsManager = extensionsManagerFuture.get();

                  // Select the camera
                  final CameraSelector cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA;

                  // Query if extension is available.
                  // Not all devices will support extensions or might only support a subset of
                  // extensions.
                  if (extensionsManager.isExtensionAvailable(
                          cameraSelector,
                          ExtensionMode.NIGHT
                  )) {
                      // Unbind all use cases before enabling different extension modes.
                      cameraProvider.unbindAll();

                      // Retrieve extension enabled camera selector
                      final CameraSelector nightCameraSelector = extensionsManager
                              .getExtensionEnabledCameraSelector(cameraSelector, ExtensionMode.NIGHT);

                      // Bind image capture and preview use cases with the extension enabled camera
                      // selector.
                      final ImageCapture imageCapture = new ImageCapture.Builder().build();
                      final Preview preview = new Preview.Builder().build();
                      // Connect the preview to receive the surface the camera outputs the frames
                      // to. This will allow displaying the camera frames in either a TextureView
                      // or SurfaceView. The SurfaceProvider can be obtained from the PreviewView.
                      preview.setSurfaceProvider(surfaceProvider);

                      cameraProvider.bindToLifecycle(
                              lifecycleOwner,
                              nightCameraSelector,
                              imageCapture,
                              preview
                      );
                  }
              } catch (ExecutionException | InterruptedException e) {
                  throw new RuntimeException(e);
              }
          }, ContextCompat.getMainExecutor(this));

      } catch (ExecutionException | InterruptedException e) {
          throw new RuntimeException(e);
      }

  }, ContextCompat.getMainExecutor(this));
}

Uzantıyı devre dışı bırak

Tedarikçi firma uzantılarını devre dışı bırakmak için tüm kullanım alanlarının bağlantısını kaldırın ve görüntü yakalama ile önizleme kullanım alanlarını normal bir kamera seçiciyle yeniden bağlayın. Örneğin, CameraSelector.DEFAULT_BACK_CAMERA kullanarak arka kameraya yeniden bağlayın.

Bağımlılıklar

CameraX Extensions API, camera-extensions kitaplığına uygulandı. Uzantılar, CameraX temel modüllerine bağlıdır (core, camera2, lifecycle).

Modern

dependencies {
  def camerax_version = "1.2.0-rc01"
  implementation "androidx.camera:camera-core:${camerax_version}"
  implementation "androidx.camera:camera-camera2:${camerax_version}"
  implementation "androidx.camera:camera-lifecycle:${camerax_version}"
  //the CameraX Extensions library
  implementation "androidx.camera:camera-extensions:${camerax_version}"
    ...
}

Kotlin

dependencies {
  val camerax_version = "1.2.0-rc01"
  implementation("androidx.camera:camera-core:${camerax_version}")
  implementation("androidx.camera:camera-camera2:${camerax_version}")
  implementation("androidx.camera:camera-lifecycle:${camerax_version}")
  // the CameraX Extensions library
  implementation("androidx.camera:camera-extensions:${camerax_version}")
    ...
}

Eski API'nin kaldırılması

Ağustos 2019'da kullanıma sunulan eski Extensions API, 1.0.0-alpha26 sürümünde kullanıma sunulan yeni Extensions API ile kullanımdan kaldırıldı. 1.0.0-alpha28 sürümünden itibaren eski Extensions API, kitaplıktan kaldırılmıştır. Yeni Extensions API'yi kullanan uygulamalar, artık uzantının etkinleştirildiği bir CameraSelector edinmeli ve kullanım alanlarını bağlamak için bunu kullanmalıdır.

Eski Extensions API'yi kullanan uygulamalar, gelecekteki CameraX sürümleriyle uyumluluğun sağlanması için yeni Extensions API'ye geçirilmelidir.

Ek kaynaklar

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

Codelab

  • CameraX'i kullanmaya başlama
  • Kod örneği

    KameraX Uzantıları Örnek Uygulaması

    Diğer referanslar

    KameraX Tedarikçi Firma Uzantıları

    KameraX Tedarikçi Firma Uzantıları Doğrulama Aracı