CameraX Torch/Flashlight — Complete Guide

// Enabling torch immediately after binding — camera not ready yet
cameraProvider.bindToLifecycle(this, cameraSelector, preview)
camera!!.cameraControl.enableTorch(true) // Camera not fully initialized

class TorchManager(private val context: Context) {
    private var camera: Camera? = null
    private var cameraProvider: ProcessCameraProvider? = null
    private var isTorchOn = false

    fun startCamera(previewView: PreviewView, onReady: () -> Unit = {}) {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
        cameraProviderFuture.addListener({
            cameraProvider = cameraProviderFuture.get()

            val preview = Preview.Builder().build()
                .also { it.setSurfaceProvider(previewView.surfaceProvider) }

            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

            try {
                cameraProvider?.unbindAll()
                camera = cameraProvider?.bindToLifecycle(
                    context as LifecycleOwner,
                    cameraSelector,
                    preview
                )
                onReady()
            } catch (e: Exception) {
                Log.e("Torch", "Camera bind failed", e)
            }
        }, ContextCompat.getMainExecutor(context))
    }

    fun toggleTorch(): Boolean {
        val cam = camera ?: return false
        val cameraInfo = cam.cameraInfo

        if (!cameraInfo.torchState.value == true) {
            // Torch not available
            if (cameraInfo.torchState.value == null) return false
        }

        isTorchOn = !isTorchOn
        cam.cameraControl.enableTorch(isTorchOn)
        return isTorchOn
    }

    fun setTorch(on: Boolean) {
        camera?.cameraControl?.enableTorch(on)
        isTorchOn = on
    }

    // Flash mode for image capture (not torch)
    fun setFlashMode(imageCapture: ImageCapture, mode: Int) {
        // ImageCapture.FLASH_MODE_AUTO, _ON, _OFF
        imageCapture.flashMode = mode
    }

    fun isFlashAvailable(): Boolean {
        return camera?.cameraInfo?.hasFlashUnit() ?: false
    }

    // Observe torch state
    fun observeTorchState(callback: (Boolean) -> Unit) {
        camera?.cameraInfo?.torchState?.observe(context as LifecycleOwner) { state ->
            callback(state == TorchState.ON)
        }
    }

    fun release() {
        cameraProvider?.unbindAll()
        camera = null
        isTorchOn = false
    }
}

// Usage
if (torchManager.isFlashAvailable()) {
    torchManager.toggleTorch()
}