CameraX Image Analysis — Complete Guide

// No cooldown — analyzer called for every frame
class BarcodeAnalyzer : ImageAnalysis.Analyzer {
    override fun analyze(image: ImageProxy) {
        // Heavy ML processing on every frame — can't keep up!
        val barcodes = detectBarcodes(image)
        image.close()
    }
}

class EfficientAnalyzer : ImageAnalysis.Analyzer {
    private var isProcessing = false
    private val fpsController = FpsController()

    override fun analyze(image: ImageProxy) {
        // Skip frames if still processing
        if (isProcessing) {
            image.close()
            return
        }

        isProcessing = true

        // Convert to Bitmap for processing
        val bitmap = imageProxyToBitmap(image)

        // Process on background thread
        Thread {
            try {
                val result = processFrame(bitmap)

                // Post result back to UI
                Handler(Looper.getMainLooper()).post {
                    onResult(result)
                }
            } finally {
                image.close() // Always close!
                isProcessing = false
            }
        }.start()
    }

    // Alternative: use executor for background processing
    fun setupImageAnalysis(imageAnalysis: ImageAnalysis) {
        imageAnalysis.setAnalyzer(Executors.newSingleThreadExecutor()) { image ->
            processOnBackground(image)
            image.close()
        }
    }

    // Set target frame rate
    fun setupWithBackpressure(imageAnalysis: ImageAnalysis) {
        // STRATEGY_KEEP_ONLY_LATEST: drops frames if analyzer is busy
        ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setTargetFrameRate(15) // Process 15 fps max
            .build()
    }

    private var lastAnalyzedTime = 0L
    private fun shouldAnalyze(): Boolean {
        val now = System.currentTimeMillis()
        return if (now - lastAnalyzedTime > 100) { // 10 fps max
            lastAnalyzedTime = now
            true
        } else false
    }

    private class FpsController {
        private val frameWindow = ArrayDeque<Long>(30)

        fun canProcess(currentFps: Int = 15): Boolean {
            val now = System.currentTimeMillis()
            frameWindow.addLast(now)
            if (frameWindow.size > 30) frameWindow.removeFirst()
            val elapsed = now - (frameWindow.firstOrNull() ?: now)
            return elapsed > 0 && frameWindow.size * 1000 / elapsed < currentFps
        }
    }
}