tauri-plugin-torchlight 1.0.11

Tauri v2 plugin to control the smartphone torch on Android and iOS: on/off, brightness, availability and state queries, and system torch change events.
Documentation
package com.lembryo.tauri.plugin.torchlight

import android.app.Activity
import android.content.Context
import android.hardware.camera2.CameraAccessException
import android.hardware.camera2.CameraCharacteristics
import android.hardware.camera2.CameraManager
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.webkit.WebView
import app.tauri.annotation.Command
import app.tauri.annotation.InvokeArg
import app.tauri.annotation.TauriPlugin
import app.tauri.plugin.Invoke
import app.tauri.plugin.JSObject
import app.tauri.plugin.Plugin

@InvokeArg
class TorchOptions {
    var enabled: Boolean = false
    /** Optional brightness in the 0.0..1.0 range. */
    var level: Double? = null
}

@TauriPlugin
class TorchlightPlugin(private val activity: Activity) : Plugin(activity) {

    private val cameraManager: CameraManager by lazy {
        activity.getSystemService(Context.CAMERA_SERVICE) as CameraManager
    }

    /** Id of a camera that actually has a flash unit (usually the rear camera), or null. */
    private val torchCameraId: String? by lazy { findTorchCameraId() }

    @Volatile
    private var torchEnabled: Boolean = false

    private val torchCallback = object : CameraManager.TorchCallback() {
        override fun onTorchModeChanged(cameraId: String, enabled: Boolean) {
            if (cameraId != torchCameraId) return
            torchEnabled = enabled
            emitTorchModeChanged(enabled = enabled, available = true)
        }

        override fun onTorchModeUnavailable(cameraId: String) {
            if (cameraId != torchCameraId) return
            torchEnabled = false
            emitTorchModeChanged(enabled = false, available = false)
        }
    }

    override fun load(webView: WebView) {
        super.load(webView)
        // Keep our cached state in sync with the system: the torch can be turned
        // off by another app, by thermal limits, or by the OS at any time.
        if (torchCameraId != null) {
            cameraManager.registerTorchCallback(torchCallback, Handler(Looper.getMainLooper()))
        }
    }

    private fun emitTorchModeChanged(enabled: Boolean, available: Boolean) {
        val payload = JSObject()
        payload.put("enabled", enabled)
        payload.put("available", available)
        trigger("torchModeChanged", payload)
    }

    private fun findTorchCameraId(): String? {
        return try {
            cameraManager.cameraIdList.firstOrNull { id ->
                cameraManager.getCameraCharacteristics(id)
                    .get(CameraCharacteristics.FLASH_INFO_AVAILABLE) == true
            }
        } catch (e: CameraAccessException) {
            null
        } catch (e: IllegalArgumentException) {
            null
        }
    }

    @Command
    fun torch(invoke: Invoke) {
        val args = invoke.parseArgs(TorchOptions::class.java)
        val cameraId = torchCameraId
        if (cameraId == null) {
            invoke.reject("Torch is not available on this device")
            return
        }

        try {
            val level = args.level
            if (args.enabled && level != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                applyTorchWithBrightness(cameraId, level)
            } else {
                cameraManager.setTorchMode(cameraId, args.enabled)
            }
            invoke.resolve()
        } catch (e: CameraAccessException) {
            invoke.reject(e.message ?: "Camera access error")
        } catch (e: IllegalArgumentException) {
            // Thrown when the camera does not support the requested operation.
            invoke.reject(e.message ?: "Torch is not available on this device")
        }
    }

    private fun applyTorchWithBrightness(cameraId: String, level: Double) {
        val maxLevel = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            cameraManager.getCameraCharacteristics(cameraId)
                .get(CameraCharacteristics.FLASH_INFO_STRENGTH_MAXIMUM_LEVEL) ?: 1
        } else {
            1
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && TorchMath.supportsBrightness(maxLevel)) {
            val strength = TorchMath.strengthFromLevel(level, maxLevel)
            cameraManager.turnOnTorchWithStrengthLevel(cameraId, strength)
        } else {
            cameraManager.setTorchMode(cameraId, true)
        }
    }

    @Command
    fun isAvailable(invoke: Invoke) {
        val result = JSObject()
        result.put("available", torchCameraId != null)
        invoke.resolve(result)
    }

    @Command
    fun isEnabled(invoke: Invoke) {
        val result = JSObject()
        result.put("enabled", torchEnabled)
        invoke.resolve(result)
    }
}