使用CameraX简化Androin相机的开发

class App : Application(),CameraXConfig.Provider {

    override fun onCreate() {
        super.onCreate()
        //...
    }

    override fun getCameraXConfig(): CameraXConfig {
        return Camera2Config.defaultConfig()
    }

}

class MainActivity : AppCompatActivity() {
  private lateinit var binding: MainActivityBinding

  private lateinit var cameraProviderFuture: ListenableFuture

  private lateinit var previewView: PreviewView
  
  
  override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        previewView = binding.previewView

        cameraProviderFuture = ProcessCameraProvider.getInstance(this)

        if (allPermissionsGranted()) {
            previewView.post { startCamera() }
        } else {
            // request permission
        }
    }
    
    /**
     * 开启相机
     */
    private fun startCamera() {
        //预览相机
        imagePreview = Preview.Builder().apply {
            setTargetAspectRatio(AspectRatio.RATIO_16_9)
            setTargetRotation(previewView.display.rotation)
        }.build()


        val cameraSelector = CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()
        cameraProviderFuture.addListener(Runnable {
            val cameraProvider = cameraProviderFuture.get()
            val camera = cameraProvider.bindToLifecycle(this, cameraSelector,imagePreview)
        }, ContextCompat.getMainExecutor(this))
    }
    //...
}

/**
 * 开启相机
 */
private fun startCamera() {
    //...
    //图片分析
    imageAnalysis = ImageAnalysis.Builder().apply {
        setImageQueueDepth(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
    }.build()
    //...


    val cameraSelector =
        CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()
    cameraProviderFuture.addListener(Runnable {
        val cameraProvider = cameraProviderFuture.get()
        val camera = cameraProvider.bindToLifecycle(this, cameraSelector,imagePreview,imageAnalysis)
    }, ContextCompat.getMainExecutor(this))
}

/**
 * 光强度分析
 */
private class LuminosityAnalyzer : ImageAnalysis.Analyzer {
    private var lastAnalyzedTimestamp = 0L

    /**
     * Helper extension function used to extract a byte array from an
     * image plane buffer
     */
    private fun ByteBuffer.toByteArray(): ByteArray {
        rewind()    // Rewind the buffer to zero
        val data = ByteArray(remaining())
        get(data)   // Copy the buffer into a byte array
        return data // Return the byte array
    }

    override fun analyze(image: ImageProxy) {
        val currentTimestamp = System.currentTimeMillis()
        // Calculate the average luma no more often than every second
        if (currentTimestamp - lastAnalyzedTimestamp >=
            TimeUnit.SECONDS.toMillis(1)) {
            // Since format in ImageAnalysis is YUV, image.planes[0]
            // contains the Y (luminance) plane
            val buffer = image.planes[0].buffer
            // Extract image data from callback object
            val data = buffer.toByteArray()
            // Convert the data into an array of pixel values
            val pixels = data.map { it.toInt() and 0xFF }
            // Compute average luminance for the image
            val luma = pixels.average()
            // Log the new luma value
            Log.d("CameraX", "Average luminosity: $luma")
            // Update timestamp of last analyzed frame
            lastAnalyzedTimestamp = currentTimestamp
        }
        image.close()
    }
}

/**
 * 开启相机
 */
private fun startCamera() {
    //...
    //拍照
    imageCapture = ImageCapture.Builder().apply {
        setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
    }.build()


    val cameraSelector =
        CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()
    cameraProviderFuture.addListener(Runnable {
        val cameraProvider = cameraProviderFuture.get()
        val camera = cameraProvider.bindToLifecycle(this, cameraSelector,imagePreview,imageAnalysis,imageCapture)
    }, ContextCompat.getMainExecutor(this))
}

/**
 * 拍照
 */
private fun takePicture() {
    val file = createFile(
        outputDirectory,
        FILENAME,
        PHOTO_EXTENSION
    )
    val outputFileOptions = ImageCapture.OutputFileOptions.Builder(file).build()
    imageCapture.takePicture(outputFileOptions, executor, object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
            val msg = "Photo capture succeeded: ${file.absolutePath}"
            previewView.post {
                Toast.makeText(this@MainActivity, msg, Toast.LENGTH_LONG).show()
            }
        }

        override fun onError(exception: ImageCaptureException) {
            exception.printStackTrace()
            val msg = "Photo capture failed: ${exception.message}"
            previewView.post {
                Toast.makeText(this@MainActivity, msg, Toast.LENGTH_LONG).show()
            }
        }
    })
}

/**
 * 切换闪光灯状态
 */
private fun toggleTorch() {
    if (cameraInfo.torchState.value == TorchState.ON) {
        cameraControl.enableTorch(false)
    } else {
        cameraControl.enableTorch(true)
    }
}

/**
 * 监听闪光灯状态
 */
private fun setTorchStateObserver() {
    cameraInfo.torchState.observe(this, Observer { state ->
        if (state == TorchState.ON) {
            binding.cameraTorchButton.setImageDrawable(
                ContextCompat.getDrawable(
                    this,
                    R.drawable.ic_flash_on_24dp
                )
            )
        } else {
            binding.cameraTorchButton.setImageDrawable(
                ContextCompat.getDrawable(
                    this,
                    R.drawable.ic_flash_off_24dp
                )
            )
        }
    })
}

 /**
 * 监听缩放状态
 */
private fun setZoomStateObserver() {
    cameraInfo.zoomState.observe(this, Observer { state ->
        // state.linearZoom
        // state.zoomRatio
        // state.maxZoomRatio
        // state.minZoomRatio
        Log.d(TAG, "${state.linearZoom}")
    })
}

// 控制缩放
override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
    return when (keyCode) {
        KeyEvent.KEYCODE_VOLUME_UP -> {
            if (linearZoom <= 0.9) {
                linearZoom += 0.1f
            }
            cameraControl.setLinearZoom(linearZoom)
            true
        }
        KeyEvent.KEYCODE_VOLUME_DOWN -> {
            if (linearZoom >= 0.1) {
                linearZoom -= 0.1f
            }
            cameraControl.setLinearZoom(linearZoom)
            true
        }
        else -> super.onKeyDown(keyCode, event)
    }
}