Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Interfejs API rozszerzeń CameraX

CameraX udostępnia interfejs Extensions API, który umożliwia dostęp do rozszerzeń zaimplementowanych przez producentów na różnych urządzeniach z Androidem. Listę obsługiwanych trybów rozszerzeń znajdziesz w artykule Rozszerzenia aparatu.

Listę urządzeń obsługujących rozszerzenia znajdziesz w sekcji Obsługiwane urządzenia.

Architektura rozszerzeń

Poniższy obraz przedstawia architekturę rozszerzeń aparatu.

Aplikacja CameraX może używać rozszerzeń za pomocą interfejsu CameraX Extensions API. Interfejs CameraX Extensions API zarządza wysyłaniem zapytań o dostępne rozszerzenia, konfigurowaniem sesji aparatu z rozszerzeniami i komunikacją z biblioteką Camera Extensions OEM. Dzięki temu aplikacja może korzystać z takich funkcji jak tryb nocny, HDR, tryb automatyczny, bokeh czy retusz twarzy.

Włączanie rozszerzenia do robienia zdjęć i wyświetlania podglądu

Zanim użyjesz interfejsu API rozszerzeń, pobierz instancję ExtensionsManager za pomocą metody ExtensionsManager#getInstanceAsync(Context, CameraProvider). Dzięki temu możesz wysyłać zapytania o informacje o dostępności rozszerzenia. Następnie pobierz rozszerzenie z włączoną funkcją CameraSelector. Tryb rozszerzenia zostanie zastosowany w przypadkach użycia robienia zdjęć i podglądu podczas wywoływania metody bindToLifecycle() z włączonym rozszerzeniem CameraSelector.

Aby wdrożyć rozszerzenie w przypadkach użycia związanych z robieniem zdjęć i podglądem, zapoznaj się z tym przykładowym kodem:

// 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))
}ExtensionsApi.kt

Wyłączanie rozszerzenia

Aby wyłączyć rozszerzenia dostawcy, odłącz wszystkie przypadki użycia i ponownie powiąż przypadki użycia robienia zdjęć i podglądu z normalnym selektorem aparatu. Możesz na przykład ponownie powiązać z tylnym aparatem za pomocą CameraSelector.DEFAULT_BACK_CAMERA.

Zależności

Interfejs CameraX Extensions API jest zaimplementowany w bibliotece camera-extensions. Rozszerzenia zależą od modułów podstawowych CameraX (core, camera2, lifecycle).

Dynamiczny

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

Usunięcie starszego interfejsu API

Wraz z wydaniem nowego interfejsu Extensions API w 1.0.0-alpha26 starszy interfejs Extensions API wydany w sierpniu 2019 r. został wycofany. Począwszy od wersji 1.0.0-alpha28, starszy interfejs Extensions API został usunięty z biblioteki. Aplikacje korzystające z nowego interfejsu Extensions API muszą teraz uzyskać obiekt CameraSelector z włączonym rozszerzeniem i używać go do wiązania przypadków użycia.

Aplikacje korzystające ze starszego interfejsu Extensions API powinny przejść na nowy interfejs Extensions API, aby zapewnić zgodność z przyszłymi wersjami CameraX.

Dodatkowe materiały

Więcej informacji o CameraX znajdziesz w tych materiałach: