react-native-frame-capture 1.0.1

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

@@ -0,0 +1,154 @@
+package com.framecapture.models
+
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Overlay position - either preset or custom coordinates
+ */
+sealed class OverlayPosition {
+    data class Preset(val value: String) : OverlayPosition()
+    data class Coordinates(val x: Float, val y: Float, val unit: String = com.framecapture.Constants.POSITION_UNIT_PIXELS) : OverlayPosition()
+
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): OverlayPosition? {
+            if (map == null) return null
+
+            return try {
+                val preset = map.getString("preset")
+                if (preset != null) Preset(preset) else null
+            } catch (e: Exception) {
+                Coordinates(
+                    x = if (map.hasKey("x")) map.getDouble("x").toFloat() else 0f,
+                    y = if (map.hasKey("y")) map.getDouble("y").toFloat() else 0f,
+                    unit = if (map.hasKey("unit")) map.getString("unit") ?: com.framecapture.Constants.POSITION_UNIT_PIXELS else com.framecapture.Constants.POSITION_UNIT_PIXELS
+                )
+            }
+        }
+
+        fun fromString(preset: String): OverlayPosition {
+            return Preset(preset)
+        }
+    }
+}
+
+/**
+ * Text style configuration
+ */
+data class TextStyle(
+    val fontSize: Int = com.framecapture.Constants.TEXT_DEFAULT_FONT_SIZE,
+    val color: String = com.framecapture.Constants.TEXT_DEFAULT_COLOR,
+    val backgroundColor: String = com.framecapture.Constants.TEXT_DEFAULT_BACKGROUND_COLOR,
+    val padding: Int = com.framecapture.Constants.TEXT_DEFAULT_PADDING,
+    val fontWeight: String = com.framecapture.Constants.TEXT_WEIGHT_NORMAL,
+    val textAlign: String = com.framecapture.Constants.TEXT_ALIGN_LEFT
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): TextStyle {
+            if (map == null) return TextStyle()
+
+            val bgColor = map.getStringOrDefault("backgroundColor", com.framecapture.Constants.TEXT_DEFAULT_BACKGROUND_COLOR)
+
+            return TextStyle(
+                fontSize = map.getIntOrDefault("fontSize", com.framecapture.Constants.TEXT_DEFAULT_FONT_SIZE),
+                color = map.getStringOrDefault("color", com.framecapture.Constants.TEXT_DEFAULT_COLOR),
+                backgroundColor = bgColor,
+                padding = map.getIntOrDefault("padding", com.framecapture.Constants.TEXT_DEFAULT_PADDING),
+                fontWeight = map.getStringOrDefault("fontWeight", com.framecapture.Constants.TEXT_WEIGHT_NORMAL),
+                textAlign = map.getStringOrDefault("textAlign", com.framecapture.Constants.TEXT_ALIGN_LEFT)
+            )
+        }
+    }
+}
+
+/**
+ * Image size configuration
+ */
+data class ImageSize(
+    val width: Int,
+    val height: Int
+) {
+    companion object {
+        fun fromReadableMap(map: ReadableMap?): ImageSize? {
+            if (map == null) return null
+
+            return ImageSize(
+                width = if (map.hasKey("width")) map.getInt("width") else return null,
+                height = if (map.hasKey("height")) map.getInt("height") else return null
+            )
+        }
+    }
+}
+
+/**
+ * Base overlay configuration
+ */
+sealed class OverlayConfig {
+    abstract val type: String
+    abstract val position: OverlayPosition
+
+    /**
+     * Text overlay configuration
+     */
+    data class Text(
+        override val type: String = com.framecapture.Constants.OVERLAY_TYPE_TEXT,
+        val content: String,
+        override val position: OverlayPosition,
+        val style: TextStyle = TextStyle()
+    ) : OverlayConfig()
+
+    /**
+     * Image overlay configuration
+     */
+    data class Image(
+        override val type: String = com.framecapture.Constants.OVERLAY_TYPE_IMAGE,
+        val source: String,
+        override val position: OverlayPosition,
+        val size: ImageSize? = null,
+        val opacity: Float = com.framecapture.Constants.IMAGE_DEFAULT_OPACITY
+    ) : OverlayConfig()
+
+    companion object {
+        fun fromReadableMap(map: ReadableMap): OverlayConfig? {
+            val type = map.getStringOrNull("type") ?: return null
+
+            return when (type) {
+                com.framecapture.Constants.OVERLAY_TYPE_TEXT -> {
+                    val content = map.getStringOrNull("content") ?: return null
+                    val position = parsePositionFromMap(map) ?: return null
+                    val style = TextStyle.fromReadableMap(map.getMap("style"))
+
+                    Text(content = content, position = position, style = style)
+                }
+                com.framecapture.Constants.OVERLAY_TYPE_IMAGE -> {
+                    val source = map.getStringOrNull("source") ?: return null
+                    val position = parsePositionFromMap(map) ?: return null
+                    val size = ImageSize.fromReadableMap(map.getMap("size"))
+                    val opacity = if (map.hasKey("opacity")) map.getDouble("opacity").toFloat() else com.framecapture.Constants.IMAGE_DEFAULT_OPACITY
+
+                    Image(source = source, position = position, size = size, opacity = opacity)
+                }
+                else -> null
+            }
+        }
+
+        private fun parsePositionFromMap(map: ReadableMap): OverlayPosition? {
+            if (!map.hasKey("position")) return null
+
+            return try {
+                val positionString = map.getString("position")
+                if (positionString != null) {
+                    OverlayPosition.fromString(positionString)
+                } else {
+                    null
+                }
+            } catch (e: Exception) {
+                try {
+                    val positionMap = map.getMap("position")
+                    OverlayPosition.fromReadableMap(positionMap)
+                } catch (e2: Exception) {
+                    null
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/framecapture/service/CaptureNotificationManager.kt

@@ -0,0 +1,286 @@
+package com.framecapture.service
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.framecapture.Constants
+import com.framecapture.ScreenCaptureService
+import com.framecapture.models.NotificationOptions
+
+/**
+ * Manages notification creation, updates, and styling for the capture service
+ *
+ * Handles all notification-related operations for the foreground service:
+ * - Notification channel creation (Android 8.0+)
+ * - Custom styling (colors, icons, priority)
+ * - Action buttons (pause/resume/stop)
+ * - Frame count updates with template substitution
+ * - Paused state notifications
+ *
+ * Supports full customization via NotificationOptions.
+ */
+class CaptureNotificationManager(
+    private val service: Service,
+    private val notificationOptions: NotificationOptions
+) {
+
+    companion object {
+        const val NOTIFICATION_ID = Constants.NOTIFICATION_ID
+    }
+
+    /**
+     * Resolves an icon resource name to a resource ID
+     * Falls back to default icon if resource not found or null
+     */
+    private fun getIconResource(iconName: String?): Int {
+        if (iconName == null) {
+            return android.R.drawable.ic_menu_camera
+        }
+
+        try {
+            val resourceId = service.applicationContext.resources.getIdentifier(
+                iconName,
+                Constants.RESOURCE_TYPE_DRAWABLE,
+                service.applicationContext.packageName
+            )
+
+            if (resourceId == 0) {
+                return android.R.drawable.ic_menu_camera
+            }
+
+            return resourceId
+        } catch (e: Exception) {
+            return android.R.drawable.ic_menu_camera
+        }
+    }
+
+    /**
+     * Parses a color hex string to a color integer
+     * Returns null if parsing fails or input is null
+     */
+    private fun parseColor(colorString: String?): Int? {
+        if (colorString == null) return null
+
+        try {
+            return android.graphics.Color.parseColor(colorString)
+        } catch (e: Exception) {
+            return null
+        }
+    }
+
+    /**
+     * Maps a priority string to a NotificationCompat priority constant
+     * Supports "low", "default", "high" (case-insensitive)
+     */
+    private fun getNotificationPriority(priority: String): Int {
+        return when (priority.lowercase()) {
+            Constants.NOTIFICATION_PRIORITY_HIGH -> NotificationCompat.PRIORITY_HIGH
+            Constants.NOTIFICATION_PRIORITY_DEFAULT -> NotificationCompat.PRIORITY_DEFAULT
+            Constants.NOTIFICATION_PRIORITY_LOW -> NotificationCompat.PRIORITY_LOW
+            else -> NotificationCompat.PRIORITY_LOW
+        }
+    }
+
+    /**
+     * Formats a description template by replacing {frameCount} placeholder with actual count
+     */
+    private fun formatDescription(template: String, frameCount: Int): String {
+        return template.replace(Constants.NOTIFICATION_TEMPLATE_FRAME_COUNT, frameCount.toString())
+    }
+
+    /**
+     * Generates a unique channel ID based on notification options
+     * Returns default CHANNEL_ID for default settings, or hash-based ID for custom channels
+     */
+    private fun getChannelId(): String {
+        return if (notificationOptions.channelName == Constants.CHANNEL_NAME) {
+            Constants.CHANNEL_ID
+        } else {
+            "${Constants.CUSTOM_CHANNEL_ID_PREFIX}${notificationOptions.channelName.hashCode()}"
+        }
+    }
+
+    /**
+     * Creates notification channel for API 26+
+     * Uses custom channel settings from notificationOptions
+     */
+    fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channelId = getChannelId()
+
+            val channel = NotificationChannel(
+                channelId,
+                notificationOptions.channelName,
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = notificationOptions.channelDescription
+                setShowBadge(false)
+            }
+
+            val notificationManager = service.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    /**
+     * Creates a reusable notification builder with custom styling applied
+     */
+    private fun createNotificationBuilder(): NotificationCompat.Builder {
+        val builder = NotificationCompat.Builder(service, getChannelId())
+            .setSmallIcon(getIconResource(notificationOptions.smallIcon))
+            .setPriority(getNotificationPriority(notificationOptions.priority))
+            .setOngoing(true)
+
+        // Apply color if provided
+        parseColor(notificationOptions.color)?.let {
+            builder.setColor(it)
+        }
+
+        // Apply large icon if provided
+        notificationOptions.icon?.let { iconName ->
+            try {
+                val iconRes = getIconResource(iconName)
+                val bitmap = android.graphics.BitmapFactory.decodeResource(service.resources, iconRes)
+                if (bitmap != null) {
+                    builder.setLargeIcon(bitmap)
+                }
+            } catch (e: Exception) {
+                // Silently fail - large icon is optional
+            }
+        }
+
+        return builder
+    }
+
+    /**
+     * Creates a PendingIntent for service actions
+     */
+    private fun createActionPendingIntent(action: String, requestCode: Int): PendingIntent {
+        val intent = Intent(service, ScreenCaptureService::class.java).apply {
+            this.action = action
+        }
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            PendingIntent.getService(
+                service,
+                requestCode,
+                intent,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        } else {
+            PendingIntent.getService(
+                service,
+                requestCode,
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        }
+    }
+
+    /**
+     * Creates the initial foreground service notification
+     */
+    fun createNotification(): Notification {
+        val builder = createNotificationBuilder()
+            .setContentTitle(notificationOptions.title)
+            .setContentText(notificationOptions.description)
+
+        // Add pause action if enabled
+        if (notificationOptions.showPauseAction) {
+            builder.addAction(
+                android.R.drawable.ic_media_pause,
+                Constants.NOTIFICATION_ACTION_PAUSE,
+                createActionPendingIntent(Constants.ACTION_PAUSE_CAPTURE, Constants.NOTIFICATION_REQUEST_CODE_PAUSE_RESUME)
+            )
+        }
+
+        // Add stop action if enabled
+        if (notificationOptions.showStopAction) {
+            builder.addAction(
+                android.R.drawable.ic_menu_close_clear_cancel,
+                Constants.NOTIFICATION_ACTION_STOP,
+                createActionPendingIntent(Constants.ACTION_STOP_CAPTURE, Constants.NOTIFICATION_REQUEST_CODE_STOP)
+            )
+        }
+
+        return builder.build()
+    }
+
+    /**
+     * Updates the notification with current frame count progress
+     */
+    fun updateNotification(frameCount: Int) {
+        try {
+            val builder = createNotificationBuilder()
+                .setContentTitle(notificationOptions.title)
+                .setContentText(formatDescription(notificationOptions.description, frameCount))
+
+            // Add pause action if enabled
+            if (notificationOptions.showPauseAction) {
+                builder.addAction(
+                    android.R.drawable.ic_media_pause,
+                    Constants.NOTIFICATION_ACTION_PAUSE,
+                    createActionPendingIntent(Constants.ACTION_PAUSE_CAPTURE, Constants.NOTIFICATION_REQUEST_CODE_PAUSE_RESUME)
+                )
+            }
+
+            // Add stop action if enabled
+            if (notificationOptions.showStopAction) {
+                builder.addAction(
+                    android.R.drawable.ic_menu_close_clear_cancel,
+                    Constants.NOTIFICATION_ACTION_STOP,
+                    createActionPendingIntent(Constants.ACTION_STOP_CAPTURE, Constants.NOTIFICATION_REQUEST_CODE_STOP)
+                )
+            }
+
+            val notification = builder.build()
+            val notificationManager = service.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.notify(NOTIFICATION_ID, notification)
+
+        } catch (e: Exception) {
+            // Silently fail - notification update is not critical
+        }
+    }
+
+    /**
+     * Updates the notification to show paused state
+     */
+    fun updateNotificationPaused(frameCount: Int) {
+        try {
+            val builder = createNotificationBuilder()
+                .setContentTitle(notificationOptions.pausedTitle)
+                .setContentText(formatDescription(notificationOptions.pausedDescription, frameCount))
+
+            // Add resume action if enabled
+            if (notificationOptions.showResumeAction) {
+                builder.addAction(
+                    android.R.drawable.ic_media_play,
+                    Constants.NOTIFICATION_ACTION_RESUME,
+                    createActionPendingIntent(Constants.ACTION_RESUME_CAPTURE, Constants.NOTIFICATION_REQUEST_CODE_PAUSE_RESUME)
+                )
+            }
+
+            // Add stop action if enabled
+            if (notificationOptions.showStopAction) {
+                builder.addAction(
+                    android.R.drawable.ic_menu_close_clear_cancel,
+                    Constants.NOTIFICATION_ACTION_STOP,
+                    createActionPendingIntent(Constants.ACTION_STOP_CAPTURE, Constants.NOTIFICATION_REQUEST_CODE_STOP)
+                )
+            }
+
+            val notification = builder.build()
+            val notificationManager = service.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.notify(NOTIFICATION_ID, notification)
+
+        } catch (e: Exception) {
+            // Silently fail - notification update is not critical
+        }
+    }
+}