react-native-frame-capture 1.0.1

package/android/src/main/java/com/framecapture/capture/BitmapProcessor.kt

@@ -0,0 +1,157 @@
+package com.framecapture.capture
+
+import android.graphics.Bitmap
+import android.media.Image
+import android.util.Log
+import com.framecapture.models.CaptureOptions
+import com.framecapture.models.CaptureRegion
+import java.nio.ByteBuffer
+
+/**
+ * Handles bitmap conversion and processing operations
+ *
+ * Converts Android Image objects to Bitmap and applies transformations:
+ * - Pixel buffer conversion from RGBA_8888 format
+ * - Row padding removal
+ * - Status bar cropping (if excludeStatusBar is enabled)
+ * - Custom region cropping (if captureRegion is specified)
+ *
+ * Properly manages bitmap memory by recycling intermediate bitmaps.
+ */
+class BitmapProcessor(
+    private val statusBarHeight: Int
+) {
+
+    /**
+     * Converts an Image to a Bitmap with optional cropping
+     *
+     * Performs the following operations in order:
+     * 1. Converts RGBA_8888 pixel buffer to Bitmap
+     * 2. Removes row padding if present
+     * 3. Crops status bar if excludeStatusBar is enabled
+     * 4. Crops to custom region if captureRegion is specified
+     *
+     * @param image The Image from ImageReader
+     * @param captureOptions Capture options (for cropping configuration)
+     * @return Processed Bitmap ready for overlay rendering and storage
+     */
+    fun imageToBitmap(image: Image, captureOptions: CaptureOptions?): Bitmap {
+        try {
+            val planes = image.planes
+            val buffer: ByteBuffer = planes[0].buffer
+            val pixelStride = planes[0].pixelStride
+            val rowStride = planes[0].rowStride
+            val rowPadding = rowStride - pixelStride * image.width
+
+            // Create bitmap with the correct dimensions
+            var bitmap = Bitmap.createBitmap(
+                image.width + rowPadding / pixelStride,
+                image.height,
+                Bitmap.Config.ARGB_8888
+            )
+
+            // Copy pixel data to bitmap
+            bitmap.copyPixelsFromBuffer(buffer)
+
+            // Crop row padding if present
+            if (rowPadding > 0) {
+                val croppedBitmap = Bitmap.createBitmap(
+                    bitmap,
+                    0,
+                    0,
+                    image.width,
+                    image.height
+                )
+                bitmap.recycle()
+                bitmap = croppedBitmap
+            }
+
+            // Crop status bar if requested
+            val excludeStatusBar = captureOptions?.excludeStatusBar ?: false
+            if (excludeStatusBar && statusBarHeight > 0 && statusBarHeight < bitmap.height) {
+                val croppedBitmap = Bitmap.createBitmap(
+                    bitmap,
+                    0,
+                    statusBarHeight,  // Start below status bar
+                    bitmap.width,
+                    bitmap.height - statusBarHeight  // Reduced height
+                )
+                bitmap.recycle()
+                bitmap = croppedBitmap
+            }
+
+            // Crop custom region if specified
+            val captureRegion = captureOptions?.captureRegion
+            if (captureRegion != null) {
+                bitmap = cropToRegion(bitmap, captureRegion)
+            }
+
+            return bitmap
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to convert image to bitmap", e)
+            throw e
+        }
+    }
+
+    /**
+     * Crops bitmap to the specified custom region
+     *
+     * Supports both coordinate systems:
+     * - Pixel-based: Absolute pixel coordinates
+     * - Percentage-based: Relative to bitmap dimensions (0.0 to 1.0)
+     *
+     * Validates and clamps coordinates to prevent out-of-bounds errors.
+     *
+     * @param bitmap The bitmap to crop
+     * @param region Custom region specification
+     * @return Cropped bitmap (original is recycled)
+     */
+    private fun cropToRegion(bitmap: Bitmap, region: CaptureRegion): Bitmap {
+        try {
+            // Calculate actual pixel coordinates
+            val (x, y, width, height) = if (region.unit == com.framecapture.Constants.POSITION_UNIT_PERCENTAGE) {
+                // Convert percentages to pixels
+                val cropX = (region.x * bitmap.width).toInt()
+                val cropY = (region.y * bitmap.height).toInt()
+                val cropWidth = (region.width * bitmap.width).toInt()
+                val cropHeight = (region.height * bitmap.height).toInt()
+                listOf(cropX, cropY, cropWidth, cropHeight)
+            } else {
+                // Use pixel values directly
+                listOf(region.x.toInt(), region.y.toInt(), region.width.toInt(), region.height.toInt())
+            }
+
+            // Validate bounds
+            val safeX = maxOf(0, minOf(x, bitmap.width - 1))
+            val safeY = maxOf(0, minOf(y, bitmap.height - 1))
+            val safeWidth = minOf(width, bitmap.width - safeX)
+            val safeHeight = minOf(height, bitmap.height - safeY)
+
+            if (safeWidth <= 0 || safeHeight <= 0) {
+                return bitmap
+            }
+
+            // Crop the bitmap
+            val croppedBitmap = Bitmap.createBitmap(
+                bitmap,
+                safeX,
+                safeY,
+                safeWidth,
+                safeHeight
+            )
+
+            // Recycle original bitmap
+            bitmap.recycle()
+
+            return croppedBitmap
+
+        } catch (e: Exception) {
+            return bitmap
+        }
+    }
+
+    companion object {
+        private const val TAG = "BitmapProcessor"
+    }
+}

package/android/src/main/java/com/framecapture/capture/CaptureEventEmitter.kt

@@ -0,0 +1,120 @@
+package com.framecapture.capture
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.framecapture.Constants
+import com.framecapture.models.ErrorCode
+import com.framecapture.models.FrameInfo
+
+/**
+ * Handles event emission for capture operations
+ *
+ * Formats and emits capture-related events to the JavaScript layer.
+ * Provides type-safe event emission with proper error handling.
+ *
+ * Events emitted:
+ * - onFrameCaptured: When a frame is captured and saved
+ * - onCaptureStart: When capture session starts
+ * - onCaptureStop: When capture session stops (with statistics)
+ * - onCaptureError: When an error occurs during capture
+ */
+class CaptureEventEmitter(
+    private val eventEmitter: (String, WritableMap?) -> Unit
+) {
+
+    /**
+     * Emits onFrameCaptured event to JavaScript
+     *
+     * Contains frame information: file path, size, timestamp, and frame number.
+     *
+     * @param frameInfo Frame metadata
+     * @param frameNumber Zero-based frame number in the session
+     */
+    fun emitFrameCaptured(frameInfo: FrameInfo, frameNumber: Int) {
+        try {
+            val params = frameInfo.toWritableMap(frameNumber)
+            eventEmitter(Constants.EVENT_FRAME_CAPTURED, params)
+        } catch (e: Exception) {
+            // Silently fail - event emission is not critical
+        }
+    }
+
+    /**
+     * Emits onCaptureStart event to JavaScript
+     *
+     * Contains session ID and capture options.
+     *
+     * @param sessionId Unique session identifier
+     * @param options Capture configuration options
+     */
+    fun emitCaptureStart(sessionId: String, options: com.framecapture.models.CaptureOptions) {
+        try {
+            val params = Arguments.createMap().apply {
+                putString("sessionId", sessionId)
+                putMap("options", options.toWritableMap())
+            }
+            eventEmitter(Constants.EVENT_CAPTURE_START, params)
+        } catch (e: Exception) {
+            // Silently fail - event emission is not critical
+        }
+    }
+
+    /**
+     * Emits onCaptureStop event to JavaScript with session statistics
+     *
+     * Contains session ID, total frames captured, and session duration.
+     *
+     * @param sessionId Unique session identifier
+     * @param totalFrames Total number of frames captured
+     * @param duration Session duration in milliseconds
+     */
+    fun emitCaptureStop(sessionId: String, totalFrames: Int, duration: Long) {
+        try {
+            val params = Arguments.createMap().apply {
+                putString("sessionId", sessionId)
+                putInt("totalFrames", totalFrames)
+                putDouble("duration", duration.toDouble())
+            }
+            eventEmitter(Constants.EVENT_CAPTURE_STOP, params)
+        } catch (e: Exception) {
+            // Silently fail - event emission is not critical
+        }
+    }
+
+    /**
+     * Emits onCaptureError event to JavaScript
+     *
+     * Contains error code, message, and optional details for debugging.
+     *
+     * @param errorCode Error code enum value
+     * @param message Human-readable error message
+     * @param details Optional map of additional error context
+     */
+    fun emitError(errorCode: ErrorCode, message: String, details: Map<String, Any>?) {
+        try {
+            val params = Arguments.createMap().apply {
+                putString("code", errorCode.value)
+                putString("message", message)
+
+                details?.let { detailsMap ->
+                    val detailsWritableMap = Arguments.createMap()
+                    detailsMap.forEach { (key, value) ->
+                        when (value) {
+                            is String -> detailsWritableMap.putString(key, value)
+                            is Int -> detailsWritableMap.putInt(key, value)
+                            is Long -> detailsWritableMap.putDouble(key, value.toDouble())
+                            is Double -> detailsWritableMap.putDouble(key, value)
+                            is Boolean -> detailsWritableMap.putBoolean(key, value)
+                            else -> detailsWritableMap.putString(key, value.toString())
+                        }
+                    }
+                    putMap("details", detailsWritableMap)
+                }
+            }
+
+            eventEmitter(Constants.EVENT_CAPTURE_ERROR, params)
+        } catch (e: Exception) {
+            // Silently fail - event emission is not critical
+        }
+    }
+}

package/android/src/main/java/com/framecapture/models/CaptureModels.kt

@@ -0,0 +1,302 @@
+package com.framecapture.models
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Custom capture region specification
+ */
+data class CaptureRegion(
+    val x: Float,
+    val y: Float,
+    val width: Float,
+    val height: Float,
+    val unit: String = com.framecapture.Constants.POSITION_UNIT_PERCENTAGE // "pixels" or "percentage"
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): CaptureRegion? {
+            if (map == null) return null
+
+            return CaptureRegion(
+                x = if (map.hasKey("x")) map.getDouble("x").toFloat() else 0f,
+                y = if (map.hasKey("y")) map.getDouble("y").toFloat() else 0f,
+                width = if (map.hasKey("width")) map.getDouble("width").toFloat() else 1f,
+                height = if (map.hasKey("height")) map.getDouble("height").toFloat() else 1f,
+                unit = if (map.hasKey("unit")) map.getString("unit") ?: com.framecapture.Constants.POSITION_UNIT_PERCENTAGE else com.framecapture.Constants.POSITION_UNIT_PERCENTAGE
+            )
+        }
+    }
+}
+
+/**
+ * Storage configuration
+ */
+data class StorageConfig(
+    val warningThreshold: Long = com.framecapture.Constants.DEFAULT_STORAGE_WARNING_THRESHOLD
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): StorageConfig {
+            if (map == null) return StorageConfig()
+
+            return StorageConfig(
+                warningThreshold = if (map.hasKey("warningThreshold")) map.getDouble("warningThreshold").toLong() else com.framecapture.Constants.DEFAULT_STORAGE_WARNING_THRESHOLD
+            )
+        }
+    }
+}
+
+
+
+/**
+ * File naming configuration
+ */
+data class FileNamingConfig(
+    val prefix: String = com.framecapture.Constants.DEFAULT_FILENAME_PREFIX,
+    val dateFormat: String = com.framecapture.Constants.DEFAULT_FILENAME_DATE_FORMAT,
+    val framePadding: Int = com.framecapture.Constants.DEFAULT_FILENAME_FRAME_PADDING
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): FileNamingConfig {
+            if (map == null) return FileNamingConfig()
+
+            return FileNamingConfig(
+                prefix = map.getStringOrDefault("prefix", com.framecapture.Constants.DEFAULT_FILENAME_PREFIX),
+                dateFormat = map.getStringOrDefault("dateFormat", com.framecapture.Constants.DEFAULT_FILENAME_DATE_FORMAT),
+                framePadding = map.getIntOrDefault("framePadding", com.framecapture.Constants.DEFAULT_FILENAME_FRAME_PADDING)
+            )
+        }
+    }
+}
+
+/**
+ * Performance configuration
+ */
+data class PerformanceConfig(
+    val overlayCacheSize: Int = com.framecapture.Constants.DEFAULT_OVERLAY_IMAGE_CACHE_SIZE,
+    val imageReaderBuffers: Int = com.framecapture.Constants.DEFAULT_IMAGE_READER_MAX_IMAGES,
+    val executorShutdownTimeout: Long = com.framecapture.Constants.DEFAULT_EXECUTOR_SHUTDOWN_TIMEOUT,
+    val executorForcedShutdownTimeout: Long = com.framecapture.Constants.DEFAULT_EXECUTOR_FORCED_SHUTDOWN_TIMEOUT
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): PerformanceConfig {
+            if (map == null) return PerformanceConfig()
+
+            return PerformanceConfig(
+                overlayCacheSize = if (map.hasKey("overlayCacheSize")) map.getDouble("overlayCacheSize").toInt() else com.framecapture.Constants.DEFAULT_OVERLAY_IMAGE_CACHE_SIZE,
+                imageReaderBuffers = map.getIntOrDefault("imageReaderBuffers", com.framecapture.Constants.DEFAULT_IMAGE_READER_MAX_IMAGES),
+                executorShutdownTimeout = if (map.hasKey("executorShutdownTimeout")) map.getDouble("executorShutdownTimeout").toLong() else com.framecapture.Constants.DEFAULT_EXECUTOR_SHUTDOWN_TIMEOUT,
+                executorForcedShutdownTimeout = if (map.hasKey("executorForcedShutdownTimeout")) map.getDouble("executorForcedShutdownTimeout").toLong() else com.framecapture.Constants.DEFAULT_EXECUTOR_FORCED_SHUTDOWN_TIMEOUT
+            )
+        }
+    }
+}
+
+/**
+ * Advanced configuration options
+ */
+data class AdvancedConfig(
+    val storage: StorageConfig = StorageConfig(),
+    val fileNaming: FileNamingConfig = FileNamingConfig(),
+    val performance: PerformanceConfig = PerformanceConfig()
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): AdvancedConfig {
+            if (map == null) return AdvancedConfig()
+
+            return AdvancedConfig(
+                storage = StorageConfig.fromReadableMap(map.getMap("storage")),
+                fileNaming = FileNamingConfig.fromReadableMap(map.getMap("fileNaming")),
+                performance = PerformanceConfig.fromReadableMap(map.getMap("performance"))
+            )
+        }
+    }
+}
+
+/**
+ * Configuration options for notification customization
+ */
+data class NotificationOptions(
+    val title: String = com.framecapture.Constants.NOTIFICATION_DEFAULT_TITLE,
+    val description: String = com.framecapture.Constants.NOTIFICATION_DEFAULT_DESCRIPTION,
+    val icon: String? = null,
+    val smallIcon: String? = null,
+    val color: String? = null,
+    val channelName: String = com.framecapture.Constants.CHANNEL_NAME,
+    val channelDescription: String = com.framecapture.Constants.CHANNEL_DESCRIPTION,
+    val priority: String = com.framecapture.Constants.NOTIFICATION_PRIORITY_LOW,
+    val showFrameCount: Boolean = true,
+    val updateInterval: Int = com.framecapture.Constants.NOTIFICATION_DEFAULT_UPDATE_INTERVAL,
+    val pausedTitle: String = com.framecapture.Constants.NOTIFICATION_DEFAULT_PAUSED_TITLE,
+    val pausedDescription: String = com.framecapture.Constants.NOTIFICATION_DEFAULT_PAUSED_DESCRIPTION,
+    val showStopAction: Boolean = true,
+    val showPauseAction: Boolean = false,
+    val showResumeAction: Boolean = true
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): NotificationOptions {
+            if (map == null) return NotificationOptions()
+
+            return NotificationOptions(
+                title = map.getStringOrDefault("title", com.framecapture.Constants.NOTIFICATION_DEFAULT_TITLE),
+                description = map.getStringOrDefault("description", com.framecapture.Constants.NOTIFICATION_DEFAULT_DESCRIPTION),
+                icon = map.getStringOrNull("icon"),
+                smallIcon = map.getStringOrNull("smallIcon"),
+                color = map.getStringOrNull("color"),
+                channelName = map.getStringOrDefault("channelName", com.framecapture.Constants.CHANNEL_NAME),
+                channelDescription = map.getStringOrDefault("channelDescription", com.framecapture.Constants.CHANNEL_DESCRIPTION),
+                priority = map.getStringOrDefault("priority", com.framecapture.Constants.NOTIFICATION_PRIORITY_LOW),
+                showFrameCount = map.getBooleanOrDefault("showFrameCount", true),
+                updateInterval = map.getIntOrDefault("updateInterval", com.framecapture.Constants.NOTIFICATION_DEFAULT_UPDATE_INTERVAL),
+                pausedTitle = map.getStringOrDefault("pausedTitle", com.framecapture.Constants.NOTIFICATION_DEFAULT_PAUSED_TITLE),
+                pausedDescription = map.getStringOrDefault("pausedDescription", com.framecapture.Constants.NOTIFICATION_DEFAULT_PAUSED_DESCRIPTION),
+                showStopAction = map.getBooleanOrDefault("showStopAction", true),
+                showPauseAction = map.getBooleanOrDefault("showPauseAction", false),
+                showResumeAction = map.getBooleanOrDefault("showResumeAction", true)
+            )
+        }
+    }
+}
+
+/**
+ * Configuration options for screen capture
+ */
+data class CaptureOptions(
+    val interval: Long = com.framecapture.Constants.DEFAULT_INTERVAL,
+    val quality: Int = com.framecapture.Constants.DEFAULT_QUALITY,
+    val format: String = com.framecapture.Constants.DEFAULT_FORMAT,
+    val saveFrames: Boolean = false,
+    val storageLocation: String = com.framecapture.Constants.STORAGE_LOCATION_PRIVATE,
+    val outputDirectory: String? = null,
+    val scaleResolution: Float? = null,
+    val captureRegion: CaptureRegion? = null,
+    val excludeStatusBar: Boolean = false,
+    val notification: NotificationOptions? = null,
+    val overlays: List<OverlayConfig>? = null,
+    val advanced: AdvancedConfig = AdvancedConfig()
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap): CaptureOptions {
+            val notificationOptions = if (map.hasKey("notification")) {
+                NotificationOptions.fromReadableMap(map.getMap("notification"))
+            } else {
+                null
+            }
+
+            val captureRegion = if (map.hasKey("captureRegion")) {
+                CaptureRegion.fromReadableMap(map.getMap("captureRegion"))
+            } else {
+                null
+            }
+
+            val overlays = if (map.hasKey("overlays")) {
+                val overlaysArray = map.getArray("overlays")
+                if (overlaysArray != null) {
+                    val overlayList = mutableListOf<OverlayConfig>()
+                    for (i in 0 until overlaysArray.size()) {
+                        val overlayMap = overlaysArray.getMap(i)
+                        if (overlayMap != null) {
+                            val overlay = OverlayConfig.fromReadableMap(overlayMap)
+                            if (overlay != null) {
+                                overlayList.add(overlay)
+                            }
+                        }
+                    }
+                    overlayList.ifEmpty { null }
+                } else {
+                    null
+                }
+            } else {
+                null
+            }
+
+            val advancedConfig = if (map.hasKey("advanced")) {
+                AdvancedConfig.fromReadableMap(map.getMap("advanced"))
+            } else {
+                AdvancedConfig()
+            }
+
+            return CaptureOptions(
+                interval = if (map.hasKey("interval")) map.getDouble("interval").toLong() else com.framecapture.Constants.DEFAULT_INTERVAL,
+                quality = if (map.hasKey("quality")) map.getInt("quality") else com.framecapture.Constants.DEFAULT_QUALITY,
+                format = if (map.hasKey("format")) map.getString("format") ?: com.framecapture.Constants.DEFAULT_FORMAT else com.framecapture.Constants.DEFAULT_FORMAT,
+                saveFrames = if (map.hasKey("saveFrames")) map.getBoolean("saveFrames") else false,
+                storageLocation = if (map.hasKey("storageLocation")) map.getString("storageLocation") ?: com.framecapture.Constants.STORAGE_LOCATION_PRIVATE else com.framecapture.Constants.STORAGE_LOCATION_PRIVATE,
+                outputDirectory = if (map.hasKey("outputDirectory")) map.getString("outputDirectory") else null,
+                scaleResolution = if (map.hasKey("scaleResolution")) map.getDouble("scaleResolution").toFloat() else null,
+                captureRegion = captureRegion,
+                excludeStatusBar = if (map.hasKey("excludeStatusBar")) map.getBoolean("excludeStatusBar") else false,
+                notification = notificationOptions,
+                overlays = overlays,
+                advanced = advancedConfig
+            )
+        }
+    }
+
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            putDouble("interval", interval.toDouble())
+            putInt("quality", quality)
+            putString("format", format)
+            putBoolean("saveFrames", saveFrames)
+            putString("storageLocation", storageLocation)
+            outputDirectory?.let { putString("outputDirectory", it) }
+            scaleResolution?.let { putDouble("scaleResolution", it.toDouble()) }
+            putBoolean("excludeStatusBar", excludeStatusBar)
+        }
+    }
+}
+
+/**
+ * Represents an active capture session
+ */
+data class CaptureSession(
+    val id: String,
+    val startTime: Long,
+    var frameCount: Int,
+    val options: CaptureOptions
+) {
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            putString("id", id)
+            putDouble("startTime", startTime.toDouble())
+            putInt("frameCount", frameCount)
+            putMap("options", options.toWritableMap())
+        }
+    }
+}
+
+/**
+ * Current status of the capture system
+ */
+data class CaptureStatus(
+    val state: CaptureState,
+    val session: CaptureSession?,
+    val isPaused: Boolean
+) {
+    fun toWritableMap(): WritableMap {
+        return Arguments.createMap().apply {
+            putString("state", state.value)
+            session?.let { putMap("session", it.toWritableMap()) }
+            putBoolean("isPaused", isPaused)
+        }
+    }
+}
+
+/**
+ * Information about a captured frame
+ */
+data class FrameInfo(
+    val filePath: String,
+    val fileSize: Long,
+    val timestamp: Long
+) {
+    fun toWritableMap(frameNumber: Int): WritableMap {
+        return Arguments.createMap().apply {
+            putString("filePath", filePath)
+            putDouble("fileSize", fileSize.toDouble())
+            putDouble("timestamp", timestamp.toDouble())
+            putInt("frameNumber", frameNumber)
+        }
+    }
+}

package/android/src/main/java/com/framecapture/models/EnumsAndExtensions.kt

@@ -0,0 +1,60 @@
+package com.framecapture.models
+
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Helper extension functions for safe ReadableMap access
+ */
+fun ReadableMap.getStringOrDefault(key: String, default: String): String {
+    return if (hasKey(key)) getString(key) ?: default else default
+}
+
+fun ReadableMap.getStringOrNull(key: String): String? {
+    return if (hasKey(key)) getString(key) else null
+}
+
+fun ReadableMap.getBooleanOrDefault(key: String, default: Boolean): Boolean {
+    return if (hasKey(key)) getBoolean(key) else default
+}
+
+fun ReadableMap.getIntOrDefault(key: String, default: Int): Int {
+    return if (hasKey(key)) getInt(key) else default
+}
+
+/**
+ * Capture mode determines when frames are captured
+ */
+enum class CaptureMode(val value: String) {
+    INTERVAL("interval")      // Fixed interval capture
+}
+
+/**
+ * Capture state enum
+ */
+enum class CaptureState(val value: String) {
+    IDLE("idle"),
+    CAPTURING("capturing"),
+    PAUSED("paused"),
+    STOPPING("stopping")
+}
+
+/**
+ * Error codes for capture operations
+ */
+enum class ErrorCode(val value: String) {
+    PERMISSION_DENIED("PERMISSION_DENIED"),
+    ALREADY_CAPTURING("ALREADY_CAPTURING"),
+    INVALID_OPTIONS("INVALID_OPTIONS"),
+    STORAGE_ERROR("STORAGE_ERROR"),
+    SYSTEM_ERROR("SYSTEM_ERROR"),
+    NOT_SUPPORTED("NOT_SUPPORTED")
+}
+
+/**
+ * Permission status enum
+ */
+enum class PermissionStatus(val value: String) {
+    GRANTED("granted"),
+    DENIED("denied"),
+    NOT_DETERMINED("not_determined")
+}