react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/CameraTheme.kt

@@ -0,0 +1,479 @@
+package com.customcamera
+
+import android.content.Context
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import org.json.JSONObject
+
+/**
+ * Relative-luminance dark test for an arbitrary ARGB color (< 0.5 = dark). Mirrors the JS shell's
+ * `luminance()`/`isDarkTheme()` in palette.ts so native and React Native agree on the light/dark
+ * split, and lets callers test a surface color that isn't the window `background` (e.g. the barcode
+ * scanner's own backdrop) to pick a matching status-bar icon appearance.
+ */
+fun isColorDark(color: Int): Boolean =
+    (0.2126 * Color.red(color) +
+        0.7152 * Color.green(color) +
+        0.0722 * Color.blue(color)) / 255.0 < 0.5
+
+data class CameraThemeColors(
+    val background: Int,
+    val surface: Int,
+    val surfaceMuted: Int,
+    val surfaceElevated: Int,
+    val primary: Int,
+    val primaryContrast: Int,
+    val text: Int,
+    val textMuted: Int,
+    val textSecondary: Int,
+    val border: Int,
+    val borderStrong: Int,
+    val overlay: Int,
+    val overlayStrong: Int,
+    val accent: Int,
+    val success: Int,
+    val error: Int,
+    val warning: Int
+) {
+    /**
+     * Whether the active theme reads as dark, from the relative luminance of the
+     * window `background` (< 0.5 = dark). Mirrors the JS shell's `isDarkTheme()`
+     * in palette.ts so native and React Native agree on the light/dark split. Lets
+     * native chrome branch a token (e.g. a status-bar icon appearance) without the
+     * host having to send an explicit flag.
+     */
+    val isDark: Boolean
+        get() = isColorDark(background)
+}
+
+data class CameraThemeTypography(
+    val fontFamily: String,
+    val headingSize: Float,
+    val bodySize: Float,
+    val captionSize: Float,
+    val buttonSize: Float
+)
+
+data class CameraThemeSpacing(
+    val xs: Int,
+    val sm: Int,
+    val md: Int,
+    val lg: Int,
+    val xl: Int,
+    val xxl: Int
+)
+
+data class CameraThemeBorderRadius(
+    val sm: Float,
+    val md: Float,
+    val lg: Float,
+    val xl: Float,
+    val pill: Float,
+    val circle: Float
+)
+
+/** Per-icon appearance override coming from the JS `icons` config section. */
+data class CameraIconStyle(
+    val tintColor: Int?,
+    val sizeDp: Int?,
+    val resourceName: String?,
+    val svg: String?
+)
+
+/**
+ * White-label extras beyond the visual theme: icon tints/sizes/overrides,
+ * animation durations, structural dimension overrides, and upload-notification
+ * appearance. Populated from the `cameraConfig` JSON pushed by
+ * `setCameraConfig`; every accessor falls back to the previously hardcoded
+ * value so an absent config reproduces the stock UI exactly.
+ */
+class CameraConfig(
+    private val globalIconTint: Int?,
+    private val iconOverrides: Map<String, CameraIconStyle>,
+    private val animationDurations: Map<String, Long>,
+    private val animationsDisabled: Boolean,
+    private val dimensionOverrides: Map<String, Int>,
+    val notifications: NotificationConfig,
+    val gif: GifConfig
+) {
+    data class NotificationConfig(
+        val progressChannelId: String,
+        val progressChannelName: String?,
+        val resultChannelId: String,
+        val resultChannelName: String?,
+        val accentColor: Int?,
+        val smallIconResourceName: String?
+    )
+
+    /**
+     * GIF picker configuration. [provider] selects the GIF service ("giphy" is the default,
+     * "tenor" is also supported); [apiKey] is that provider's API key. When [apiKey] is
+     * null/blank the picker shows a dedicated "not configured" state instead of making any
+     * network calls. Delivered under a top-level `gif` object in the `setCameraConfig` JSON
+     * (Channel B) so the secret is never passed through per-launch Intent extras.
+     */
+    data class GifConfig(
+        val provider: String?,
+        val apiKey: String?
+    ) {
+        val isConfigured: Boolean get() = !apiKey.isNullOrBlank()
+    }
+
+    /** Tint for an icon (per-icon override wins over the global tint), or null for as-shipped. */
+    fun iconTint(name: String): Int? = iconOverrides[name]?.tintColor ?: globalIconTint
+
+    /** Fixed dp size for an icon, or null to keep the caller's responsive size. */
+    fun iconSizeDp(name: String): Int? = iconOverrides[name]?.sizeDp
+
+    /**
+     * Resolve the drawable for an icon: a host-app override drawable when
+     * `resourceName` is configured AND resolvable, otherwise the built-in
+     * resource. Tint is applied by the caller via [iconTint].
+     */
+    fun iconRes(context: Context, name: String, builtinRes: Int): Int {
+        val overrideName = iconOverrides[name]?.resourceName ?: return builtinRes
+        val resolved = context.resources.getIdentifier(
+            overrideName, "drawable", context.packageName
+        )
+        return if (resolved != 0) resolved else builtinRes
+    }
+
+    /** Resolve an SVG first, then a host drawable resource, then the built-in drawable. */
+    fun iconDrawable(context: Context, name: String, builtinRes: Int): Drawable {
+        val override = iconOverrides[name]
+        val tint = override?.tintColor ?: globalIconTint
+        val svg = override?.svg
+        if (!svg.isNullOrBlank()) {
+            SvgDrawable.from(svg, tint)?.let { return it }
+        }
+        val resource = iconRes(context, name, builtinRes)
+        return requireNotNull(androidx.core.content.ContextCompat.getDrawable(context, resource))
+    }
+
+    /**
+     * The colour filter to apply to [drawable] (the result of [iconDrawable] for
+     * icon [name]) so both stock and host-provided artwork look right:
+     *  - a configured per-icon / global tint always wins;
+     *  - otherwise a host-provided SVG keeps its OWN colours (null → the caller
+     *    must clear any filter), because a solid SRC_IN filter would flatten a
+     *    multi-colour SVG to one tone (and its `currentColor` was already resolved
+     *    against the config tint inside [SvgDrawable.from]);
+     *  - otherwise a plain built-in / resource glyph gets [defaultTint] so it
+     *    still matches the surrounding chrome (e.g. the editor's white icons).
+     *
+     * Pairs with [iconDrawable]: `val d = iconDrawable(...); view.setImageDrawable(d);
+     * iconTintFor(name, d, default)?.let { view.setColorFilter(it) } ?: view.clearColorFilter()`.
+     */
+    fun iconTintFor(name: String, drawable: Drawable, defaultTint: Int?): Int? {
+        iconTint(name)?.let { return it }
+        return if (drawable is SvgDrawable) null else defaultTint
+    }
+
+    /** Animation duration in ms; 0 when animations are disabled. */
+    fun anim(key: String, defaultMs: Long): Long =
+        if (animationsDisabled) 0L else animationDurations[key] ?: defaultMs
+
+    /** Structural dimension in dp — configured override or the stock default. */
+    fun dim(key: String, defaultDp: Int): Int = dimensionOverrides[key] ?: defaultDp
+
+    /** Whether a fixed override exists for this dimension (vs. responsive stock sizing). */
+    fun hasDim(key: String): Boolean = dimensionOverrides.containsKey(key)
+
+    companion object {
+        val DEFAULT = CameraConfig(
+            globalIconTint = null,
+            iconOverrides = emptyMap(),
+            animationDurations = emptyMap(),
+            animationsDisabled = false,
+            dimensionOverrides = emptyMap(),
+            notifications = NotificationConfig(
+                progressChannelId = "UploadServiceChannel",
+                progressChannelName = null,
+                resultChannelId = "UploadResultChannel",
+                resultChannelName = null,
+                accentColor = null,
+                smallIconResourceName = null
+            ),
+            gif = GifConfig(provider = null, apiKey = null)
+        )
+    }
+}
+
+class CameraTheme(
+    val colors: CameraThemeColors,
+    val typography: CameraThemeTypography,
+    val spacing: CameraThemeSpacing,
+    val borderRadius: CameraThemeBorderRadius,
+    val config: CameraConfig = CameraConfig.DEFAULT,
+    private val componentOverrides: Map<String, Map<String, String>> = emptyMap()
+) {
+    /**
+     * Component-scoped color from the theme's `components` JSON section
+     * (e.g. `components.mediaGrid.selectionAccent`). The inline default IS the
+     * stock value, so unthemed builds render exactly as before.
+     */
+    fun componentColor(component: String, key: String, default: Int): Int {
+        val raw = componentOverrides[component]?.get(key) ?: return default
+        return parseColor(raw, default)
+    }
+
+    /** Component-scoped numeric value (dp, sp, alpha…) from the theme JSON. */
+    fun componentValue(component: String, key: String, default: Float): Float =
+        componentOverrides[component]?.get(key)?.toFloatOrNull() ?: default
+
+    companion object {
+        @Volatile
+        private var cached: CameraTheme? = null
+
+        /**
+         * Process-wide cached theme for views/adapters that have no Activity
+         * holding a theme instance. Screens re-load on launch (the Activities
+         * use their own `by lazy` theme), so cache staleness within a running
+         * screen matches the pre-existing behavior.
+         */
+        fun get(context: Context): CameraTheme =
+            cached ?: load(context.applicationContext).also { cached = it }
+
+        /** Drop the cache so the next [get] re-reads SharedPreferences. */
+        fun invalidate() {
+            cached = null
+        }
+
+        private fun parseColor(colorString: String?, defaultColor: Int): Int {
+            if (colorString == null) return defaultColor
+            return try {
+                if (colorString.startsWith("rgba(")) {
+                    val parts = colorString.substring(5, colorString.length - 1).split(",")
+                    val r = parts[0].trim().toInt()
+                    val g = parts[1].trim().toInt()
+                    val b = parts[2].trim().toInt()
+                    val a = (parts[3].trim().toFloat() * 255).toInt()
+                    Color.argb(a, r, g, b)
+                } else if (colorString.startsWith("rgb(")) {
+                    val parts = colorString.substring(4, colorString.length - 1).split(",")
+                    val r = parts[0].trim().toInt()
+                    val g = parts[1].trim().toInt()
+                    val b = parts[2].trim().toInt()
+                    Color.rgb(r, g, b)
+                } else {
+                    Color.parseColor(colorString)
+                }
+            } catch (e: Exception) {
+                defaultColor
+            }
+        }
+
+        /** Parse a color string, or null when empty/unparseable (= keep stock appearance). */
+        private fun tryParseColor(colorString: String?): Int? {
+            if (colorString.isNullOrEmpty()) return null
+            val sentinel = 1 // improbable parsed color: fully transparent near-black
+            val parsed = parseColor(colorString, sentinel)
+            return if (parsed == sentinel && colorString != "#00000001") null else parsed
+        }
+
+        fun load(context: Context): CameraTheme {
+            val prefs = context.getSharedPreferences("CameraSettings", Context.MODE_PRIVATE)
+            val jsonString = prefs.getString("cameraTheme", null)
+            
+            // Default palette (Dark)
+            var colors = CameraThemeColors(
+                background = Color.parseColor("#000000"),
+                surface = Color.parseColor("#111827"),
+                surfaceMuted = Color.parseColor("#1F2937"),
+                surfaceElevated = Color.parseColor("#FFFFFF"),
+                primary = Color.parseColor("#4A56FF"),
+                primaryContrast = Color.parseColor("#FFFFFF"),
+                text = Color.parseColor("#FFFFFF"),
+                textMuted = Color.parseColor("#94A3B8"),
+                textSecondary = Color.parseColor("#CBD5E1"),
+                border = Color.parseColor("#1FFFFFFF"),
+                borderStrong = Color.parseColor("#33FFFFFF"),
+                overlay = Color.parseColor("#73000000"),
+                overlayStrong = Color.parseColor("#AD000000"),
+                accent = Color.parseColor("#4A56FF"),
+                success = Color.parseColor("#34D399"),
+                error = Color.parseColor("#FF5B5B"),
+                warning = Color.parseColor("#FBBF24")
+            )
+            
+            var typography = CameraThemeTypography("System", 18f, 16f, 13f, 14f)
+            var spacing = CameraThemeSpacing(4, 8, 12, 16, 20, 24)
+            var borderRadius = CameraThemeBorderRadius(6f, 12f, 16f, 20f, 999f, 999f)
+
+            if (jsonString != null && jsonString.startsWith("{")) {
+                try {
+                    val root = JSONObject(jsonString)
+                    val colorsObj = root.optJSONObject("colors")
+                    if (colorsObj != null) {
+                        colors = CameraThemeColors(
+                            background = parseColor(colorsObj.optString("background"), colors.background),
+                            surface = parseColor(colorsObj.optString("surface"), colors.surface),
+                            surfaceMuted = parseColor(colorsObj.optString("surfaceMuted"), colors.surfaceMuted),
+                            surfaceElevated = parseColor(colorsObj.optString("surfaceElevated"), colors.surfaceElevated),
+                            primary = parseColor(colorsObj.optString("primary"), colors.primary),
+                            primaryContrast = parseColor(colorsObj.optString("primaryContrast"), colors.primaryContrast),
+                            text = parseColor(colorsObj.optString("text"), colors.text),
+                            textMuted = parseColor(colorsObj.optString("textMuted"), colors.textMuted),
+                            textSecondary = parseColor(colorsObj.optString("textSecondary"), colors.textSecondary),
+                            border = parseColor(colorsObj.optString("border"), colors.border),
+                            borderStrong = parseColor(colorsObj.optString("borderStrong"), colors.borderStrong),
+                            overlay = parseColor(colorsObj.optString("overlay"), colors.overlay),
+                            overlayStrong = parseColor(colorsObj.optString("overlayStrong"), colors.overlayStrong),
+                            accent = parseColor(colorsObj.optString("accent"), colors.accent),
+                            success = parseColor(colorsObj.optString("success"), colors.success),
+                            error = parseColor(colorsObj.optString("error"), colors.error),
+                            warning = parseColor(colorsObj.optString("warning"), colors.warning)
+                        )
+                    }
+                    val typeObj = root.optJSONObject("typography")
+                    if (typeObj != null) {
+                        typography = CameraThemeTypography(
+                            fontFamily = typeObj.optString("fontFamily", typography.fontFamily),
+                            headingSize = typeObj.optDouble("headingSize", typography.headingSize.toDouble()).toFloat(),
+                            bodySize = typeObj.optDouble("bodySize", typography.bodySize.toDouble()).toFloat(),
+                            captionSize = typeObj.optDouble("captionSize", typography.captionSize.toDouble()).toFloat(),
+                            buttonSize = typeObj.optDouble("buttonSize", typography.buttonSize.toDouble()).toFloat()
+                        )
+                    }
+                    val spaceObj = root.optJSONObject("spacing")
+                    if (spaceObj != null) {
+                        spacing = CameraThemeSpacing(
+                            xs = spaceObj.optInt("xs", spacing.xs),
+                            sm = spaceObj.optInt("sm", spacing.sm),
+                            md = spaceObj.optInt("md", spacing.md),
+                            lg = spaceObj.optInt("lg", spacing.lg),
+                            xl = spaceObj.optInt("xl", spacing.xl),
+                            xxl = spaceObj.optInt("xxl", spacing.xxl)
+                        )
+                    }
+                    val borderObj = root.optJSONObject("borderRadius")
+                    if (borderObj != null) {
+                        borderRadius = CameraThemeBorderRadius(
+                            sm = borderObj.optDouble("sm", borderRadius.sm.toDouble()).toFloat(),
+                            md = borderObj.optDouble("md", borderRadius.md.toDouble()).toFloat(),
+                            lg = borderObj.optDouble("lg", borderRadius.lg.toDouble()).toFloat(),
+                            xl = borderObj.optDouble("xl", borderRadius.xl.toDouble()).toFloat(),
+                            pill = borderObj.optDouble("pill", borderRadius.pill.toDouble()).toFloat(),
+                            circle = borderObj.optDouble("circle", borderRadius.circle.toDouble()).toFloat()
+                        )
+                    }
+                } catch (e: Exception) {
+                    // Fallback to default on parse error
+                }
+            }
+
+            // Flatten the theme's `components` section into per-component
+            // key→string maps consumed via componentColor()/componentValue().
+            val componentOverrides = mutableMapOf<String, Map<String, String>>()
+            if (jsonString != null && jsonString.startsWith("{")) {
+                try {
+                    JSONObject(jsonString).optJSONObject("components")?.let { comps ->
+                        for (compName in comps.keys()) {
+                            val comp = comps.optJSONObject(compName) ?: continue
+                            val entries = mutableMapOf<String, String>()
+                            for (key in comp.keys()) {
+                                comp.opt(key)?.let { value ->
+                                    if (value !is JSONObject) entries[key] = value.toString()
+                                }
+                            }
+                            componentOverrides[compName] = entries
+                        }
+                    }
+                } catch (e: Exception) {
+                    // Ignore malformed components; scoped lookups fall back to defaults
+                }
+            }
+
+            return CameraTheme(
+                colors, typography, spacing, borderRadius,
+                loadConfig(context), componentOverrides
+            )
+        }
+
+        /**
+         * Parse the white-label extras JSON stored by `setCameraConfig`. Any
+         * missing/malformed section degrades to [CameraConfig.DEFAULT] values.
+         */
+        fun loadConfig(context: Context): CameraConfig {
+            val prefs = context.getSharedPreferences("CameraSettings", Context.MODE_PRIVATE)
+            val jsonString = prefs.getString("cameraConfig", null)
+                ?: return CameraConfig.DEFAULT
+            if (!jsonString.startsWith("{")) return CameraConfig.DEFAULT
+
+            return try {
+                val root = JSONObject(jsonString)
+
+                var globalIconTint: Int? = null
+                val iconOverrides = mutableMapOf<String, CameraIconStyle>()
+                root.optJSONObject("icons")?.let { icons ->
+                    globalIconTint = tryParseColor(icons.optString("tintColor"))
+                    icons.optJSONObject("overrides")?.let { overrides ->
+                        for (name in overrides.keys()) {
+                            val o = overrides.optJSONObject(name) ?: continue
+                            iconOverrides[name] = CameraIconStyle(
+                                tintColor = tryParseColor(o.optString("tintColor")),
+                                sizeDp = if (o.has("size")) o.optInt("size") else null,
+                                resourceName = o.optString("resourceName")
+                                    .takeIf { it.isNotEmpty() },
+                                svg = o.optString("svg").takeIf { it.isNotEmpty() }
+                            )
+                        }
+                    }
+                }
+
+                val animationDurations = mutableMapOf<String, Long>()
+                var animationsDisabled = false
+                root.optJSONObject("animations")?.let { anims ->
+                    animationsDisabled = anims.optBoolean("disableAnimations", false)
+                    for (key in anims.keys()) {
+                        if (key == "disableAnimations") continue
+                        animationDurations[key] = anims.optLong(key)
+                    }
+                }
+
+                val dimensionOverrides = mutableMapOf<String, Int>()
+                root.optJSONObject("dimensions")?.let { dims ->
+                    for (key in dims.keys()) {
+                        dimensionOverrides[key] = dims.optInt(key)
+                    }
+                }
+
+                val defaults = CameraConfig.DEFAULT.notifications
+                val notifications = root.optJSONObject("notifications")?.let { n ->
+                    CameraConfig.NotificationConfig(
+                        progressChannelId = n.optString("progressChannelId")
+                            .takeIf { it.isNotEmpty() } ?: defaults.progressChannelId,
+                        progressChannelName = n.optString("progressChannelName")
+                            .takeIf { it.isNotEmpty() },
+                        resultChannelId = n.optString("resultChannelId")
+                            .takeIf { it.isNotEmpty() } ?: defaults.resultChannelId,
+                        resultChannelName = n.optString("resultChannelName")
+                            .takeIf { it.isNotEmpty() },
+                        accentColor = tryParseColor(n.optString("accentColor")),
+                        smallIconResourceName = n.optString("smallIconResourceName")
+                            .takeIf { it.isNotEmpty() }
+                    )
+                } ?: defaults
+
+                val gif = root.optJSONObject("gif")?.let { g ->
+                    CameraConfig.GifConfig(
+                        provider = g.optString("provider").takeIf { it.isNotEmpty() },
+                        apiKey = g.optString("apiKey").takeIf { it.isNotEmpty() }
+                    )
+                } ?: CameraConfig.DEFAULT.gif
+
+                CameraConfig(
+                    globalIconTint = globalIconTint,
+                    iconOverrides = iconOverrides,
+                    animationDurations = animationDurations,
+                    animationsDisabled = animationsDisabled,
+                    dimensionOverrides = dimensionOverrides,
+                    notifications = notifications,
+                    gif = gif
+                )
+            } catch (e: Exception) {
+                CameraConfig.DEFAULT
+            }
+        }
+    }
+}