Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

API CameraX Extensions

CameraX fornisce un'API Extensions per accedere alle estensioni che i produttori di dispositivi hanno implementato su vari dispositivi Android. Per un elenco delle modalità di estensione supportate, consulta Estensioni della fotocamera.

Per un elenco dei dispositivi che supportano le estensioni, consulta Dispositivi supportati.

Architettura delle estensioni

La seguente immagine mostra l'architettura delle estensioni della fotocamera.

**Figura 1.** Architettura di Camera Extensions

Un'applicazione CameraX può utilizzare le estensioni tramite l'API CameraX Extensions. L'API CameraX Extensions gestisce l'esecuzione di query per le estensioni disponibili, la configurazione di una sessione della fotocamera con estensione e la comunicazione con la libreria OEM Camera Extensions. In questo modo, l'applicazione può utilizzare funzionalità come Notturna, HDR, Auto, Effetto bokeh o Ritocco viso.

Attiva un'estensione per l'acquisizione di immagini e l'anteprima

Prima di utilizzare l'API Extensions, recupera un'istanza ExtensionsManager utilizzando il metodo ExtensionsManager#getInstanceAsync(Context, CameraProvider). In questo modo potrai eseguire query sulle informazioni sulla disponibilità dell'estensione. Quindi recupera un CameraSelector con estensione abilitata. La modalità di estensione verrà applicata ai casi d'uso di acquisizione di immagini e anteprima quando viene chiamato il metodo bindToLifecycle() con l'estensione CameraSelector abilitata.

Per implementare l'estensione per i casi d'uso di acquisizione di immagini e anteprima, fai riferimento al seguente esempio di codice:

// 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

Disattiva l'estensione

Per disattivare le estensioni del fornitore, scollega tutti i casi d'uso e ricollega i casi d'uso di acquisizione di immagini e anteprima con un selettore della fotocamera normale. Ad esempio, ricollega la fotocamera posteriore utilizzando CameraSelector.DEFAULT_BACK_CAMERA.

Dipendenze

L'API CameraX Extensions è implementata nella libreria camera-extensions. Le estensioni dipendono dai moduli principali di CameraX (core, camera2, lifecycle).

Alla moda

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

Rimozione delle API legacy

Con la nuova API Extensions rilasciata in 1.0.0-alpha26, l'API Extensions legacy rilasciata ad agosto 2019 è ora deprecata. A partire dalla versione 1.0.0-alpha28, l'API Extensions precedente è stata rimossa dalla libreria. Le applicazioni che utilizzano la nuova API Extensions devono ora acquisire un CameraSelector abilitato per le estensioni e utilizzarlo per associare i casi d'uso.

Le applicazioni che utilizzano l'API Extensions precedente devono eseguire la migrazione alla nuova API Extensions per garantire la compatibilità futura con le prossime release di CameraX.

Risorse aggiuntive

Per scoprire di più su CameraX, consulta le seguenti risorse aggiuntive.