react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,175 @@
+package com.customcamera
+
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.ColorFilter
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.Rect
+import android.graphics.RectF
+import android.graphics.drawable.Drawable
+import android.util.Xml
+import java.io.StringReader
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.max
+import org.xmlpull.v1.XmlPullParser
+
+/** Small, deliberately bounded SVG renderer for icon-sized artwork. */
+class SvgDrawable private constructor(private val document: Document, private val tint: Int?) : Drawable() {
+    private val fillPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+    private val strokePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE }
+
+    override fun draw(canvas: Canvas) {
+        val source = document.viewBox
+        val target = bounds
+        if (source.width() <= 0f || source.height() <= 0f || target.isEmpty) return
+        val scale = minOf(target.width() / source.width(), target.height() / source.height())
+        val matrix = Matrix().apply {
+            setScale(scale, scale)
+            postTranslate(
+                target.left + (target.width() - source.width() * scale) / 2f - source.left * scale,
+                target.top + (target.height() - source.height() * scale) / 2f - source.top * scale
+            )
+        }
+        canvas.save()
+        document.items.forEach { item ->
+            val path = Path(item.path)
+            path.transform(matrix)
+            item.fill?.let { color ->
+                fillPaint.color = resolveColor(color)
+                fillPaint.alpha = (Color.alpha(fillPaint.color) * item.opacity).toInt()
+                canvas.drawPath(path, fillPaint)
+            }
+            item.stroke?.let { color ->
+                strokePaint.color = resolveColor(color)
+                strokePaint.alpha = (Color.alpha(strokePaint.color) * item.opacity).toInt()
+                strokePaint.strokeWidth = item.strokeWidth * scale
+                canvas.drawPath(path, strokePaint)
+            }
+        }
+        canvas.restore()
+    }
+
+    private fun resolveColor(value: String): Int =
+        if (value.equals("currentColor", true)) tint ?: Color.BLACK
+        else parseColor(value, tint ?: Color.BLACK)
+
+    override fun setAlpha(alpha: Int) { fillPaint.alpha = alpha; strokePaint.alpha = alpha; invalidateSelf() }
+    override fun getOpacity(): Int = android.graphics.PixelFormat.TRANSLUCENT
+    override fun setColorFilter(colorFilter: ColorFilter?) { fillPaint.colorFilter = colorFilter; strokePaint.colorFilter = colorFilter; invalidateSelf() }
+    override fun getIntrinsicWidth(): Int = document.width.toInt()
+    override fun getIntrinsicHeight(): Int = document.height.toInt()
+
+    companion object {
+        private val cache = ConcurrentHashMap<String, Document>()
+
+        fun from(svg: String, tint: Int? = null): SvgDrawable? = try {
+            val document = cache[svg] ?: parse(svg)?.also {
+                if (cache.size >= 32) cache.clear()
+                cache[svg] = it
+            }
+            document?.let { SvgDrawable(it, tint) }
+        } catch (_: Exception) { null }
+
+        private data class Item(val path: Path, val fill: String?, val stroke: String?, val strokeWidth: Float, val opacity: Float)
+        private data class Document(val items: List<Item>, val viewBox: RectF, val width: Float, val height: Float)
+
+        private fun parse(svg: String): Document? {
+            if (svg.length > 256 * 1024) return null
+            val parser = Xml.newPullParser().apply { setInput(StringReader(svg)) }
+            val items = mutableListOf<Item>()
+            var viewBox: RectF? = null
+            var width = 24f
+            var height = 24f
+            while (parser.next() != XmlPullParser.END_DOCUMENT) {
+                if (parser.eventType != XmlPullParser.START_TAG) continue
+                val tag = parser.name.lowercase()
+                if (tag == "svg") {
+                    parser.getAttributeValue(null, "viewBox")?.let { parseNumbers(it).takeIf { n -> n.size >= 4 }?.let { n -> viewBox = RectF(n[0], n[1], n[0] + n[2], n[1] + n[3]); width = n[2]; height = n[3] } }
+                    width = parseLength(parser.getAttributeValue(null, "width"), width)
+                    height = parseLength(parser.getAttributeValue(null, "height"), height)
+                }
+                if (tag !in setOf("path", "rect", "circle", "ellipse", "line", "polyline", "polygon")) continue
+                val path = when (tag) {
+                    "path" -> parsePath(parser.getAttributeValue(null, "d"))
+                    "rect" -> rectPath(parser)
+                    "circle", "ellipse" -> ellipsePath(parser, tag == "circle")
+                    "line" -> linePath(parser)
+                    else -> pointsPath(parser, tag == "polygon")
+                } ?: continue
+                val transform = parseTransform(parser.getAttributeValue(null, "transform"))
+                path.transform(transform)
+                val fill = parser.getAttributeValue(null, "fill") ?: "currentColor"
+                val stroke = parser.getAttributeValue(null, "stroke")?.takeUnless { it.equals("none", true) }
+                val strokeWidth = parser.getAttributeValue(null, "stroke-width")?.toFloatOrNull() ?: 1f
+                val opacity = (parser.getAttributeValue(null, "opacity")?.toFloatOrNull() ?: 1f).coerceIn(0f, 1f)
+                items += Item(path, fill.takeUnless { it.equals("none", true) }, stroke, strokeWidth, opacity)
+            }
+            val box = viewBox ?: RectF(0f, 0f, width, height)
+            return Document(items, box, max(1f, width), max(1f, height))
+        }
+
+        private fun parseLength(value: String?, fallback: Float): Float = value?.replace(Regex("[^0-9.+-]"), "")?.toFloatOrNull() ?: fallback
+        private fun parseNumbers(value: String): List<Float> = Regex("[-+]?(?:\\d*\\.)?\\d+(?:[eE][-+]?\\d+)?").findAll(value).mapNotNull { it.value.toFloatOrNull() }.toList()
+
+        private fun rectPath(p: XmlPullParser): Path? {
+            val x = p.attr("x"); val y = p.attr("y"); val w = p.attr("width"); val h = p.attr("height")
+            return if (w > 0 && h > 0) Path().apply { addRect(x, y, x + w, y + h, Path.Direction.CW) } else null
+        }
+        private fun ellipsePath(p: XmlPullParser, circle: Boolean): Path? {
+            val cx = p.attr("cx"); val cy = p.attr("cy"); val rx = if (circle) p.attr("r") else p.attr("rx"); val ry = if (circle) p.attr("r") else p.attr("ry")
+            return if (rx > 0 && ry > 0) Path().apply { addOval(cx - rx, cy - ry, cx + rx, cy + ry, Path.Direction.CW) } else null
+        }
+        private fun linePath(p: XmlPullParser): Path = Path().apply { moveTo(p.attr("x1"), p.attr("y1")); lineTo(p.attr("x2"), p.attr("y2")) }
+        private fun pointsPath(p: XmlPullParser, close: Boolean): Path? { val n = parseNumbers(p.getAttributeValue(null, "points") ?: ""); if (n.size < 4) return null; return Path().apply { moveTo(n[0], n[1]); var i = 2; while (i + 1 < n.size) { lineTo(n[i], n[i + 1]); i += 2 }; if (close) close() } }
+        private fun XmlPullParser.attr(name: String): Float = getAttributeValue(null, name)?.toFloatOrNull() ?: 0f
+
+        private fun parseTransform(value: String?): Matrix {
+            val matrix = Matrix()
+            Regex("(translate|scale|rotate)\\s*\\(([^)]*)\\)").findAll(value ?: "").forEach { match ->
+                val n = parseNumbers(match.groupValues[2])
+                when (match.groupValues[1]) {
+                    "translate" -> matrix.postTranslate(n.getOrElse(0) { 0f }, n.getOrElse(1) { 0f })
+                    "scale" -> matrix.postScale(n.getOrElse(0) { 1f }, n.getOrElse(1) { n.getOrElse(0) { 1f } })
+                    "rotate" -> matrix.postRotate(n.getOrElse(0) { 0f }, n.getOrElse(1) { 0f }, n.getOrElse(2) { 0f })
+                }
+            }
+            return matrix
+        }
+
+        private fun parsePath(data: String?): Path? {
+            val tokens = Regex("[AaCcHhLlMmQqSsTtVvZz]|[-+]?(?:\\d*\\.)?\\d+(?:[eE][-+]?\\d+)?").findAll(data ?: "").map { it.value }.toList()
+            if (tokens.isEmpty()) return null
+            val path = Path(); var i = 0; var command = ' '; var x = 0f; var y = 0f
+            fun number(): Float = tokens[i++].toFloat()
+            while (i < tokens.size) {
+                if (tokens[i].length == 1 && tokens[i][0].isLetter()) command = tokens[i++].first()
+                if (command.equals('z', true)) { path.close(); command = ' '; continue }
+                val rel = command.isLowerCase(); val c = command.uppercaseChar()
+                try {
+                    when (c) {
+                        'M' -> { val nx = number(); val ny = number(); x = if (rel) x + nx else nx; y = if (rel) y + ny else ny; path.moveTo(x, y); command = if (rel) 'l' else 'L' }
+                        'L' -> { val nx = number(); val ny = number(); x = if (rel) x + nx else nx; y = if (rel) y + ny else ny; path.lineTo(x, y) }
+                        'H' -> { x = if (rel) x + number() else number(); path.lineTo(x, y) }
+                        'V' -> { y = if (rel) y + number() else number(); path.lineTo(x, y) }
+                        'C' -> { val x1 = number(); val y1 = number(); val x2 = number(); val y2 = number(); val nx = number(); val ny = number(); path.cubicTo(if (rel) x + x1 else x1, if (rel) y + y1 else y1, if (rel) x + x2 else x2, if (rel) y + y2 else y2, if (rel) x + nx else nx, if (rel) y + ny else ny); x = if (rel) x + nx else nx; y = if (rel) y + ny else ny }
+                        'Q' -> { val x1 = number(); val y1 = number(); val nx = number(); val ny = number(); path.quadTo(if (rel) x + x1 else x1, if (rel) y + y1 else y1, if (rel) x + nx else nx, if (rel) y + ny else ny); x = if (rel) x + nx else nx; y = if (rel) y + ny else ny }
+                        'S', 'T' -> { i += if (c == 'S') 4 else 2; if (i < tokens.size) { x = number(); y = number() } }
+                        else -> return null // elliptical arcs and unknown commands are unsupported
+                    }
+                } catch (_: Exception) { return null }
+            }
+            return path
+        }
+
+        private fun parseColor(value: String, fallback: Int): Int = try {
+            when {
+                value.equals("none", true) -> Color.TRANSPARENT
+                value.startsWith("#") -> Color.parseColor(value)
+                value.startsWith("rgb", true) -> { val n = parseNumbers(value); Color.rgb(n[0].toInt(), n[1].toInt(), n[2].toInt()) }
+                else -> Color.parseColor(value)
+            }
+        } catch (_: Exception) { fallback }
+    }
+}

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

@@ -0,0 +1,77 @@
+package com.customcamera
+
+import android.content.Context
+import android.widget.ImageView
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+/**
+ * ReactNative view manager that draws inline SVG icon markup using the library's
+ * OWN [SvgDrawable] parser — no `react-native-svg`, no third-party dependency.
+ *
+ * ReactNative's `<Image>` cannot render an `<svg>` data URI on Android (Fresco
+ * has no SVG decoder), so a host app that customizes an icon with inline `svg`
+ * needs this view to see that artwork on the React Native surface exactly as the
+ * native camera screen already does. Anything the parser cannot handle renders
+ * as an empty view; the JS wrapper ([NativeSvgIcon]) detects that this manager is
+ * present and, when it is not, draws the plugin's built-in default icon instead —
+ * so a missing native half or malformed markup always degrades to the default.
+ */
+class SvgIconViewManager : SimpleViewManager<SvgIconView>() {
+  override fun getName() = "CameraSvgIcon"
+
+  override fun createViewInstance(reactContext: ThemedReactContext): SvgIconView =
+    SvgIconView(reactContext)
+
+  /** Inline SVG markup to draw. Empty/blank clears the view. */
+  @ReactProp(name = "svg")
+  fun setSvg(view: SvgIconView, svg: String?) {
+    view.setSvg(svg)
+  }
+
+  /**
+   * Optional tint. Resolves `currentColor` (and any un-parseable colour) in the
+   * markup; explicit colours in the SVG are left untouched. `null` keeps the
+   * artwork's own colours (currentColor then falls back to black in the parser).
+   */
+  @ReactProp(name = "tintColor", customType = "Color")
+  fun setTintColor(view: SvgIconView, color: Int?) {
+    view.setTint(color)
+  }
+}
+
+/**
+ * An [ImageView] that renders [SvgDrawable]. Scaled `FIT_CENTER` to match the
+ * `resizeMode: 'contain'` the RN icon surface uses, so a substituted SVG sits in
+ * the same box as the icon it replaces. Re-parsing is skipped when neither the
+ * markup nor the tint changed, and parse failures leave the view empty rather
+ * than throwing.
+ */
+class SvgIconView(context: Context) : ImageView(context) {
+  private var svg: String? = null
+  private var tint: Int? = null
+
+  init {
+    scaleType = ScaleType.FIT_CENTER
+  }
+
+  fun setSvg(value: String?) {
+    if (value == svg) return
+    svg = value
+    render()
+  }
+
+  fun setTint(color: Int?) {
+    if (color == tint) return
+    tint = color
+    render()
+  }
+
+  private fun render() {
+    val markup = svg
+    setImageDrawable(
+      if (markup.isNullOrBlank()) null else SvgDrawable.from(markup, tint)
+    )
+  }
+}