react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/gif/NeuQuant.kt

@@ -0,0 +1,435 @@
+package com.customcamera.gif
+
+/**
+ * NeuQuant Neural-Net image quantization algorithm.
+ *
+ * Faithful Kotlin port of Anthony Dekker's NeuQuant (1994), as adapted to Java by Kevin Weiner
+ * (FM Software, 12/00) for the widely used [AnimatedGifEncoder]. The algorithm trains a
+ * 256-neuron one-dimensional self-organizing map on a sample of the image's BGR pixels and then
+ * uses the trained network as a 256-colour lookup table.
+ *
+ * Reference: A. Dekker, "Kohonen neural networks for optimal colour quantization",
+ * Network: Computation in Neural Systems, Vol. 5 (1994) pp 351-367.
+ *
+ * Original copyright (c) 1994 Anthony Dekker, released for unrestricted use provided this notice
+ * remains intact. This is a syntax-only translation to idiomatic Kotlin; the numeric behaviour is
+ * intended to be byte-for-byte equivalent to the canonical Java implementation.
+ *
+ * @param thepic the input image as a BGR byte array (3 bytes per pixel, blue first)
+ * @param len the usable length of [thepic] (H * W * 3)
+ * @param sample the sampling factor in the range 1..30 (1 = best quality / slowest)
+ */
+class NeuQuant(thepic: ByteArray, len: Int, sample: Int) {
+
+  companion object {
+    /** Number of colours (neurons) in the network. */
+    private val netsize = 256
+
+    /* Four primes near 500 - assume no image has a length so large that it is */
+    /* divisible by all four of them. */
+    private val prime1 = 499
+    private val prime2 = 491
+    private val prime3 = 487
+    private val prime4 = 503
+
+    /** Minimum size for the input image before the sampling factor is forced to 1. */
+    private val minpicturebytes = 3 * prime4
+
+    /* Network definitions. */
+    private val maxnetpos = netsize - 1
+    private val netbiasshift = 4 // bias for colour values
+    private val ncycles = 100 // number of learning cycles
+
+    /* Definitions for freq and bias. */
+    private val intbiasshift = 16 // bias for fractions
+    private val intbias = 1 shl intbiasshift
+    private val gammashift = 10 // gamma = 1024
+    private val gamma = 1 shl gammashift
+    private val betashift = 10
+    private val beta = intbias shr betashift // beta = 1/1024
+    private val betagamma = intbias shl (gammashift - betashift)
+
+    /* Definitions for the decreasing radius factor. */
+    private val initrad = netsize shr 3 // for 256 cols, radius starts at 32.0
+    private val radiusbiasshift = 6 // at 32.0 biased by 6 bits
+    private val radiusbias = 1 shl radiusbiasshift
+    private val initradius = initrad * radiusbias // and decreases by a
+    private val radiusdec = 30 // factor of 1/30 each cycle
+
+    /* Definitions for the decreasing alpha factor. */
+    private val alphabiasshift = 10 // alpha starts at 1.0
+    private val initalpha = 1 shl alphabiasshift
+
+    /* radbias and alpharadbias are used for the radpower calculation. */
+    private val radbiasshift = 8
+    private val radbias = 1 shl radbiasshift
+    private val alpharadbshift = alphabiasshift + radbiasshift
+    private val alpharadbias = 1 shl alpharadbshift
+  }
+
+  /** Learning rate decrement, biased by 10 bits. */
+  private var alphadec = 0
+
+  /** The input image itself (BGR bytes). */
+  private val thepicture: ByteArray = thepic
+
+  /** lengthcount = H * W * 3. */
+  private val lengthcount: Int = len
+
+  /** Sampling factor, 1..30. */
+  private var samplefac: Int = sample
+
+  /** The network itself: netsize entries of [b, g, r, colourIndex]. */
+  private val network: Array<IntArray> = Array(netsize) { IntArray(4) }
+
+  /** For network lookup - really 256 entries. */
+  private val netindex = IntArray(256)
+
+  /** Bias array for learning. */
+  private val bias = IntArray(netsize)
+
+  /** Frequency array for learning. */
+  private val freq = IntArray(netsize)
+
+  /** Precomputed radpower for the neighbourhood function. */
+  private val radpower = IntArray(initrad)
+
+  init {
+    var p: IntArray
+    for (i in 0 until netsize) {
+      p = network[i]
+      p[0] = (i shl (netbiasshift + 8)) / netsize
+      p[1] = p[0]
+      p[2] = p[0]
+      freq[i] = intbias / netsize // 1 / netsize
+      bias[i] = 0
+    }
+  }
+
+  /**
+   * Runs the full quantization: [learn], [unbiasnet], [inxbuild], then returns the colour map.
+   */
+  fun process(): ByteArray {
+    learn()
+    unbiasnet()
+    inxbuild()
+    return getColormap()
+  }
+
+  /**
+   * Builds the colour map as 3 bytes per entry, ordered by the recorded colour index. The bytes
+   * are in the same channel order that was fed to the constructor (BGR); the caller swaps to RGB.
+   */
+  fun getColormap(): ByteArray {
+    val map = ByteArray(3 * netsize)
+    val index = IntArray(netsize)
+    for (i in 0 until netsize) {
+      index[network[i][3]] = i
+    }
+    var k = 0
+    for (i in 0 until netsize) {
+      val j = index[i]
+      map[k++] = network[j][0].toByte()
+      map[k++] = network[j][1].toByte()
+      map[k++] = network[j][2].toByte()
+    }
+    return map
+  }
+
+  /**
+   * Insertion sort of the network on the green axis and building of netindex[0..255].
+   * Must be called after [unbiasnet].
+   */
+  fun inxbuild() {
+    var i = 0
+    var j: Int
+    var smallpos: Int
+    var smallval: Int
+    var p: IntArray
+    var q: IntArray
+    var previouscol = 0
+    var startpos = 0
+
+    while (i < netsize) {
+      p = network[i]
+      smallpos = i
+      smallval = p[1] // index on g
+      // find smallest in i..netsize-1
+      j = i + 1
+      while (j < netsize) {
+        q = network[j]
+        if (q[1] < smallval) { // index on g
+          smallpos = j
+          smallval = q[1] // index on g
+        }
+        j++
+      }
+      q = network[smallpos]
+      // swap p (i) and q (smallpos) entries
+      if (i != smallpos) {
+        j = q[0]; q[0] = p[0]; p[0] = j
+        j = q[1]; q[1] = p[1]; p[1] = j
+        j = q[2]; q[2] = p[2]; p[2] = j
+        j = q[3]; q[3] = p[3]; p[3] = j
+      }
+      // smallval entry is now in position i
+      if (smallval != previouscol) {
+        netindex[previouscol] = (startpos + i) shr 1
+        j = previouscol + 1
+        while (j < smallval) {
+          netindex[j] = i
+          j++
+        }
+        previouscol = smallval
+        startpos = i
+      }
+      i++
+    }
+    netindex[previouscol] = (startpos + maxnetpos) shr 1
+    j = previouscol + 1
+    while (j < 256) {
+      netindex[j] = maxnetpos // really 256
+      j++
+    }
+  }
+
+  /**
+   * Main learning loop.
+   */
+  fun learn() {
+    if (lengthcount < minpicturebytes) {
+      samplefac = 1
+    }
+    alphadec = 30 + ((samplefac - 1) / 3)
+    val p = thepicture
+    var pix = 0
+    val lim = lengthcount
+    val samplepixels = lengthcount / (3 * samplefac)
+    var delta = samplepixels / ncycles
+    var alpha = initalpha
+    var radius = initradius
+
+    var rad = radius shr radiusbiasshift
+    if (rad <= 1) rad = 0
+    var i = 0
+    while (i < rad) {
+      radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad))
+      i++
+    }
+
+    val step: Int = if (lengthcount < minpicturebytes) {
+      3
+    } else if (lengthcount % prime1 != 0) {
+      3 * prime1
+    } else if (lengthcount % prime2 != 0) {
+      3 * prime2
+    } else if (lengthcount % prime3 != 0) {
+      3 * prime3
+    } else {
+      3 * prime4
+    }
+
+    i = 0
+    while (i < samplepixels) {
+      val b = (p[pix + 0].toInt() and 0xff) shl netbiasshift
+      val g = (p[pix + 1].toInt() and 0xff) shl netbiasshift
+      val r = (p[pix + 2].toInt() and 0xff) shl netbiasshift
+      val j = contest(b, g, r)
+
+      altersingle(alpha, j, b, g, r)
+      if (rad != 0) alterneigh(rad, j, b, g, r) // alter neighbours
+
+      pix += step
+      if (pix >= lim) pix -= lengthcount
+
+      i++
+      if (delta == 0) delta = 1
+      if (i % delta == 0) {
+        alpha -= alpha / alphadec
+        radius -= radius / radiusdec
+        rad = radius shr radiusbiasshift
+        if (rad <= 1) rad = 0
+        var k = 0
+        while (k < rad) {
+          radpower[k] = alpha * (((rad * rad - k * k) * radbias) / (rad * rad))
+          k++
+        }
+      }
+    }
+  }
+
+  /**
+   * Searches for BGR values 0..255 (after the net is unbiased) and returns the colour index of
+   * the nearest neuron. This is the canonical `map`; [inxsearch] is provided as an alias under the
+   * original C name.
+   */
+  fun map(b: Int, g: Int, r: Int): Int {
+    var dist: Int
+    var a: Int
+    var bestd = 1000 // biggest possible dist is 256*3
+    var p: IntArray
+    var best = -1
+
+    var i = netindex[g] // index on g
+    var j = i - 1 // start at netindex[g] and work outwards
+
+    while (i < netsize || j >= 0) {
+      if (i < netsize) {
+        p = network[i]
+        dist = p[1] - g // inx key
+        if (dist >= bestd) {
+          i = netsize // stop iter
+        } else {
+          i++
+          if (dist < 0) dist = -dist
+          a = p[0] - b
+          if (a < 0) a = -a
+          dist += a
+          if (dist < bestd) {
+            a = p[2] - r
+            if (a < 0) a = -a
+            dist += a
+            if (dist < bestd) {
+              bestd = dist
+              best = p[3]
+            }
+          }
+        }
+      }
+      if (j >= 0) {
+        p = network[j]
+        dist = g - p[1] // inx key - reverse dif
+        if (dist >= bestd) {
+          j = -1 // stop iter
+        } else {
+          j--
+          if (dist < 0) dist = -dist
+          a = p[0] - b
+          if (a < 0) a = -a
+          dist += a
+          if (dist < bestd) {
+            a = p[2] - r
+            if (a < 0) a = -a
+            dist += a
+            if (dist < bestd) {
+              bestd = dist
+              best = p[3]
+            }
+          }
+        }
+      }
+    }
+    return best
+  }
+
+  /** Alias for [map] under the original NeuQuant C name. */
+  fun inxsearch(b: Int, g: Int, r: Int): Int = map(b, g, r)
+
+  /**
+   * Unbiases the network to give byte values 0..255 and records the position of each neuron to
+   * prepare for the sort in [inxbuild].
+   */
+  fun unbiasnet() {
+    for (i in 0 until netsize) {
+      network[i][0] = network[i][0] shr netbiasshift
+      network[i][1] = network[i][1] shr netbiasshift
+      network[i][2] = network[i][2] shr netbiasshift
+      network[i][3] = i // record colour number
+    }
+  }
+
+  /**
+   * Moves neurons adjacent to neuron [i] towards the biased (b, g, r) colour by the precomputed
+   * factor held in radpower[|i - neuron|].
+   */
+  private fun alterneigh(rad: Int, i: Int, b: Int, g: Int, r: Int) {
+    var lo = i - rad
+    if (lo < -1) lo = -1
+    var hi = i + rad
+    if (hi > netsize) hi = netsize
+
+    var j = i + 1
+    var k = i - 1
+    var m = 1
+    while (j < hi || k > lo) {
+      val a = radpower[m++]
+      if (j < hi) {
+        val p = network[j++]
+        try {
+          p[0] -= (a * (p[0] - b)) / alpharadbias
+          p[1] -= (a * (p[1] - g)) / alpharadbias
+          p[2] -= (a * (p[2] - r)) / alpharadbias
+        } catch (e: Exception) {
+          // prevents 1.3 miscompilation
+        }
+      }
+      if (k > lo) {
+        val p = network[k--]
+        try {
+          p[0] -= (a * (p[0] - b)) / alpharadbias
+          p[1] -= (a * (p[1] - g)) / alpharadbias
+          p[2] -= (a * (p[2] - r)) / alpharadbias
+        } catch (e: Exception) {
+          // prevents 1.3 miscompilation
+        }
+      }
+    }
+  }
+
+  /**
+   * Moves neuron [i] towards the biased (b, g, r) colour by the factor [alpha].
+   */
+  private fun altersingle(alpha: Int, i: Int, b: Int, g: Int, r: Int) {
+    // alter hit neuron
+    val n = network[i]
+    n[0] -= (alpha * (n[0] - b)) / initalpha
+    n[1] -= (alpha * (n[1] - g)) / initalpha
+    n[2] -= (alpha * (n[2] - r)) / initalpha
+  }
+
+  /**
+   * Searches for the biased BGR values, updating freq and bias, and returns the position of the
+   * best neuron (minimum distance minus bias).
+   */
+  private fun contest(b: Int, g: Int, r: Int): Int {
+    // finds closest neuron (min dist) and updates freq
+    // finds best neuron (min dist-bias) and returns position
+    // for frequently chosen neurons, freq[i] is high and bias[i] is negative
+    // bias[i] = gamma * ((1 / netsize) - freq[i])
+    var dist: Int
+    var a: Int
+    var biasdist: Int
+    var betafreq: Int
+    var bestpos = -1
+    var bestbiaspos = -1
+    var bestd = (1 shl 31).inv()
+    var bestbiasd = bestd
+    var n: IntArray
+    for (i in 0 until netsize) {
+      n = network[i]
+      dist = n[0] - b
+      if (dist < 0) dist = -dist
+      a = n[1] - g
+      if (a < 0) a = -a
+      dist += a
+      a = n[2] - r
+      if (a < 0) a = -a
+      dist += a
+      if (dist < bestd) {
+        bestd = dist
+        bestpos = i
+      }
+      biasdist = dist - (bias[i] shr (intbiasshift - netbiasshift))
+      if (biasdist < bestbiasd) {
+        bestbiasd = biasdist
+        bestbiaspos = i
+      }
+      betafreq = freq[i] shr betashift
+      freq[i] -= betafreq
+      bias[i] += betafreq shl gammashift
+    }
+    freq[bestpos] += beta
+    bias[bestpos] -= betagamma
+    return bestbiaspos
+  }
+}

package/android/src/main/java/com/customcamera/gif/TenorGifProvider.kt

@@ -0,0 +1,147 @@
+package com.customcamera.gif
+
+import java.net.URLEncoder
+import org.json.JSONObject
+
+/**
+ * [GifProvider] backed by the Tenor API (v2, tenor.googleapis.com).
+ *
+ * Blocking and non-throwing: every failure is folded into a typed [GifResult.Failure] via
+ * [GifHttp]. Tenor paginates with an opaque `pos`/`next` token rather than a numeric offset, so
+ * that token is passed straight through as [GifPage.nextCursor].
+ *
+ * @param apiKey Tenor API key; null/blank => [isConfigured] == false and calls short-circuit with
+ *   [GifError.NO_API_KEY].
+ * @param clientKey Tenor "client_key" integration identifier sent on every request.
+ */
+class TenorGifProvider(
+  private val apiKey: String?,
+  private val clientKey: String = "react_native_custom_camera"
+) : GifProvider {
+
+  override val id: String = "tenor"
+
+  override val attributionLabel: String? = "Powered by Tenor"
+
+  override fun isConfigured(): Boolean = !apiKey.isNullOrBlank()
+
+  override fun trending(limit: Int, cursor: String?): GifResult<GifPage> {
+    val key = apiKey
+    if (key.isNullOrBlank()) return GifResult.Failure(GifError.NO_API_KEY)
+    val url = buildString {
+      append(BASE).append("/featured?key=").append(enc(key))
+      append("&client_key=").append(enc(clientKey))
+      append("&limit=").append(limit)
+      append("&media_filter=tinygif,gif&contentfilter=high")
+      if (!cursor.isNullOrBlank()) append("&pos=").append(enc(cursor))
+    }
+    return when (val res = GifHttp.getJson(url)) {
+      is GifResult.Failure -> res
+      is GifResult.Success -> parsePage(res.value)
+    }
+  }
+
+  override fun search(query: String, limit: Int, cursor: String?): GifResult<GifPage> {
+    val key = apiKey
+    if (key.isNullOrBlank()) return GifResult.Failure(GifError.NO_API_KEY)
+    val url = buildString {
+      append(BASE).append("/search?key=").append(enc(key))
+      append("&client_key=").append(enc(clientKey))
+      append("&q=").append(enc(query))
+      append("&limit=").append(limit)
+      append("&media_filter=tinygif,gif&contentfilter=high")
+      if (!cursor.isNullOrBlank()) append("&pos=").append(enc(cursor))
+    }
+    return when (val res = GifHttp.getJson(url)) {
+      is GifResult.Failure -> res
+      is GifResult.Success -> parsePage(res.value)
+    }
+  }
+
+  override fun categories(): GifResult<List<GifCategory>> {
+    val key = apiKey
+    if (key.isNullOrBlank()) return GifResult.Failure(GifError.NO_API_KEY)
+    val url = "$BASE/categories?key=${enc(key)}&client_key=${enc(clientKey)}"
+    val json = when (val res = GifHttp.getJson(url)) {
+      is GifResult.Failure -> return GifResult.Success(emptyList())
+      is GifResult.Success -> res.value
+    }
+    // Categories are optional: any failure to parse degrades to an empty list, never a hard error.
+    val list = runCatching { parseCategories(json) }.getOrDefault(emptyList())
+    return GifResult.Success(list)
+  }
+
+  /** Parse a Tenor list response ({ results, next }) into a [GifPage]. */
+  private fun parsePage(json: JSONObject): GifResult<GifPage> {
+    val results = json.optJSONArray("results") ?: return GifResult.Failure(GifError.PARSE)
+    val items = ArrayList<GifItem>(results.length())
+    for (i in 0 until results.length()) {
+      val obj = results.optJSONObject(i) ?: continue
+      val formats = obj.optJSONObject("media_formats")
+      val preview = format(formats, "tinygif", "gif") ?: continue
+      val content = format(formats, "gif", "tinygif") ?: continue
+      val (pUrl, pW, pH) = preview
+      val (cUrl, cW, cH) = content
+      items.add(
+        GifItem(
+          id = obj.optString("id"),
+          description = obj.optString("content_description"),
+          previewUrl = pUrl,
+          previewWidth = pW,
+          previewHeight = pH,
+          contentUrl = cUrl,
+          contentWidth = cW,
+          contentHeight = cH
+        )
+      )
+    }
+    val next = json.optString("next")
+    return GifResult.Success(GifPage(items, if (next.isBlank()) null else next))
+  }
+
+  /** Parse the optional Tenor categories response; the caller downgrades any throw to empty. */
+  private fun parseCategories(json: JSONObject): List<GifCategory> {
+    val tags = json.optJSONArray("tags") ?: return emptyList()
+    val out = ArrayList<GifCategory>(tags.length())
+    for (i in 0 until tags.length()) {
+      val tag = tags.optJSONObject(i) ?: continue
+      val displayName = tag.optString("name").removePrefix("#")
+      val searchTerm = tag.optString("searchterm")
+      val name = displayName.ifBlank { searchTerm }
+      val term = searchTerm.ifBlank { displayName }
+      if (name.isBlank() || term.isBlank()) continue
+      out.add(
+        GifCategory(
+          name = name,
+          searchTerm = term,
+          imageUrl = tag.optString("image").ifBlank { null }
+        )
+      )
+    }
+    return out
+  }
+
+  /**
+   * Pick the first present Tenor media format among [names] and return its (url, width, height),
+   * or null when none has a usable url. Tenor stores size as an int `dims: [w, h]` array.
+   */
+  private fun format(formats: JSONObject?, vararg names: String): Triple<String, Int, Int>? {
+    if (formats == null) return null
+    for (name in names) {
+      val f = formats.optJSONObject(name) ?: continue
+      val url = f.optString("url")
+      if (url.isBlank()) continue
+      val dims = f.optJSONArray("dims")
+      val w = if (dims != null && dims.length() >= 1) dims.optInt(0, 0) else 0
+      val h = if (dims != null && dims.length() >= 2) dims.optInt(1, 0) else 0
+      return Triple(url, w, h)
+    }
+    return null
+  }
+
+  private fun enc(value: String): String = URLEncoder.encode(value, "UTF-8")
+
+  companion object {
+    private const val BASE = "https://tenor.googleapis.com/v2"
+  }
+}

package/android/src/main/res/drawable/bg_brush_selected.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_brush_selected_bg" />
+</shape>

package/android/src/main/res/drawable/bg_color_swatch.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <stroke android:width="2dp" android:color="@color/customcamera_color_swatch_border" />
+</shape>

package/android/src/main/res/drawable/bg_editor_toolbar.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <solid android:color="@color/customcamera_editor_toolbar_bg" />
+  <corners android:radius="28dp" />
+</shape>

package/android/src/main/res/drawable/bg_icon_circle.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_icon_circle_bg" />
+</shape>

package/android/src/main/res/drawable/bg_icon_circle_light.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_icon_circle_light_bg" />
+</shape>

package/android/src/main/res/drawable/bg_mode_tab_active.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <solid android:color="@color/customcamera_mode_tab_active_bg" />
+  <corners android:radius="14dp" />
+</shape>

package/android/src/main/res/drawable/bg_pill.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <solid android:color="@color/customcamera_pill_bg" />
+  <corners android:radius="24dp" />
+</shape>

package/android/src/main/res/drawable/bg_recording_dot.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="#FFE53935" />
+  <size android:width="6dp" android:height="6dp" />
+</shape>

package/android/src/main/res/drawable/bg_selection_badge.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_selection_badge_bg" />
+  <stroke
+    android:width="2dp"
+    android:color="@color/customcamera_selection_badge_border" />
+</shape>

package/android/src/main/res/drawable/bg_send_button.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_send_button_bg" />
+</shape>

package/android/src/main/res/drawable/bg_shutter_inner.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_shutter_inner" />
+</shape>

package/android/src/main/res/drawable/bg_shutter_recording.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <solid android:color="@color/customcamera_shutter_recording" />
+  <corners android:radius="10dp" />
+</shape>

package/android/src/main/res/drawable/bg_shutter_ring.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@android:color/transparent" />
+  <stroke
+    android:width="5dp"
+    android:color="@color/customcamera_shutter_ring" />
+</shape>

package/android/src/main/res/drawable/bg_shutter_video_idle.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="oval">
+  <solid android:color="@color/customcamera_shutter_video_idle" />
+</shape>