react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,124 @@
+package com.customcamera.gif
+
+import android.os.Handler
+import android.os.Looper
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicLong
+
+/**
+ * Background-thread orchestrator between the GIF picker UI and a [GifProvider].
+ *
+ * The UI never touches a [GifProvider] directly: it calls the repository, which runs the blocking
+ * provider call on a worker thread and delivers the typed [GifResult] back on the main thread. A
+ * single generation counter implements "latest wins" — when the user starts a new search (or
+ * clears it back to trending) any still-in-flight list request is dropped so a slow earlier
+ * response can never overwrite the newer list. Pagination ([loadMore]) deliberately does NOT bump
+ * the generation, so it continues the current list, but it is dropped if the list changed while it
+ * was loading.
+ *
+ * Categories are cached after the first success (they change rarely) and replayed synchronously.
+ *
+ * The owner (the picker) must call [shutdown] when it closes to release the worker threads.
+ */
+class GifRepository(private val provider: GifProvider) {
+
+  private val executor: ExecutorService = Executors.newFixedThreadPool(2) { r ->
+    Thread(r, "gif-repo").apply { isDaemon = true }
+  }
+  private val main = Handler(Looper.getMainLooper())
+
+  /** Bumped by [refreshList]; a delivered result is discarded when this no longer matches. */
+  private val listGeneration = AtomicLong(0)
+
+  @Volatile private var cachedCategories: List<GifCategory>? = null
+  @Volatile private var shutdown = false
+
+  val attributionLabel: String? get() = provider.attributionLabel
+
+  fun isConfigured(): Boolean = provider.isConfigured()
+
+  /**
+   * Load the first page of a list. [query] null/blank ⇒ trending; otherwise search results.
+   * Supersedes any earlier in-flight list request. [onResult] runs on the main thread.
+   */
+  fun refreshList(query: String?, limit: Int, onResult: (GifResult<GifPage>) -> Unit) {
+    val generation = listGeneration.incrementAndGet()
+    if (!query.isNullOrBlank() && GifSafety.isBlockedQuery(query)) {
+      main.post { onResult(GifResult.Success(GifPage(emptyList(), null))) }
+      return
+    }
+    submitList(query, limit, cursor = null, generation = generation, onResult = onResult)
+  }
+
+  /**
+   * Load the next page of the CURRENT list (continuation of the last [refreshList]). The result is
+   * dropped if the user changed the list meanwhile. [cursor] comes from [GifPage.nextCursor].
+   */
+  fun loadMore(query: String?, limit: Int, cursor: String, onResult: (GifResult<GifPage>) -> Unit) {
+    val generation = listGeneration.get()
+    submitList(query, limit, cursor = cursor, generation = generation, onResult = onResult)
+  }
+
+  private fun submitList(
+    query: String?,
+    limit: Int,
+    cursor: String?,
+    generation: Long,
+    onResult: (GifResult<GifPage>) -> Unit
+  ) {
+    if (shutdown) return
+    execute {
+      val result = if (query.isNullOrBlank()) {
+        provider.trending(limit, cursor)
+      } else {
+        provider.search(query, limit, cursor)
+      }
+      val safeResult = when (result) {
+        is GifResult.Success -> GifResult.Success(GifSafety.filterPage(result.value))
+        is GifResult.Failure -> result
+      }
+      deliver(onResult, safeResult) { listGeneration.get() == generation }
+    }
+  }
+
+  /** Load browsable categories, served from cache after the first success. Main-thread callback. */
+  fun loadCategories(onResult: (GifResult<List<GifCategory>>) -> Unit) {
+    cachedCategories?.let { cached ->
+      main.post { onResult(GifResult.Success(cached)) }
+      return
+    }
+    if (shutdown) return
+    execute {
+      val result = provider.categories()
+      if (result is GifResult.Success) cachedCategories = result.value
+      deliver(onResult, result) { true }
+    }
+  }
+
+  private fun <T> deliver(
+    onResult: (GifResult<T>) -> Unit,
+    result: GifResult<T>,
+    isStillCurrent: () -> Boolean
+  ) {
+    main.post {
+      if (!shutdown && isStillCurrent()) onResult(result)
+    }
+  }
+
+  private fun execute(block: () -> Unit) {
+    try {
+      executor.execute {
+        if (!shutdown) block()
+      }
+    } catch (e: Exception) {
+      // Executor rejected (already shut down) — nothing to deliver.
+    }
+  }
+
+  /** Stop delivering results and release worker threads. Safe to call more than once. */
+  fun shutdown() {
+    shutdown = true
+    executor.shutdownNow()
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.customcamera.gif
+
+/** Shared client-side guard for queries and provider-returned GIF descriptions. */
+internal object GifSafety {
+
+  private val blockedTerms = setOf(
+    "kiss", "kissing", "makeout", "nude", "nudes", "naked", "nsfw", "porn", "porno",
+    "xxx", "sex", "sexual", "erotic", "hentai", "fetish", "topless", "uncensored",
+    "orgasm", "masturbat", "blowjob", "handjob", "intercourse", "vagina", "penis",
+    "dick", "pussy", "boob", "breast", "tits", "anal", "bdsm", "cum", "semen"
+  )
+
+  fun isBlockedQuery(query: String): Boolean = containsBlockedTerm(query)
+
+  fun filterPage(page: GifPage): GifPage = page.copy(
+    items = page.items.filterNot { item ->
+      containsBlockedTerm(item.description) ||
+        containsBlockedTerm(item.previewUrl) ||
+        containsBlockedTerm(item.contentUrl)
+    }
+  )
+
+  private fun containsBlockedTerm(value: String): Boolean {
+    val normalized = value.lowercase()
+    return blockedTerms.any { term ->
+      if (term.length < 4) {
+        Regex("\\b${Regex.escape(term)}\\b").containsMatchIn(normalized)
+      } else {
+        normalized.contains(term)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,146 @@
+package com.customcamera.gif
+
+import java.net.URLEncoder
+import org.json.JSONObject
+
+/**
+ * [GifProvider] backed by the GIPHY HTTP API (v1).
+ *
+ * All calls block on [GifHttp] and fold every failure into a typed [GifResult.Failure]; nothing
+ * throws. GIPHY paginates by integer offset, so the opaque [GifPage.nextCursor] carried across
+ * pages is simply the next offset rendered as a string.
+ *
+ * @param apiKey GIPHY API key; when null/blank the provider reports [isConfigured] == false and
+ *   every call short-circuits with [GifError.NO_API_KEY].
+ */
+class GiphyGifProvider(private val apiKey: String?) : GifProvider {
+
+  override val id: String = "giphy"
+
+  override val attributionLabel: String? = "Powered by GIPHY"
+
+  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 offset = cursor?.toIntOrNull() ?: 0
+    val url = "$BASE/gifs/trending?api_key=${enc(key)}&limit=$limit&offset=$offset" +
+      "&rating=g&bundle=messaging_non_clips"
+    return when (val res = GifHttp.getJson(url)) {
+      is GifResult.Failure -> res
+      is GifResult.Success -> parsePage(res.value, limit, offset)
+    }
+  }
+
+  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 offset = cursor?.toIntOrNull() ?: 0
+    val url = "$BASE/gifs/search?api_key=${enc(key)}&q=${enc(query)}&limit=$limit&offset=$offset" +
+      "&rating=g&lang=en&bundle=messaging_non_clips"
+    return when (val res = GifHttp.getJson(url)) {
+      is GifResult.Failure -> res
+      is GifResult.Success -> parsePage(res.value, limit, offset)
+    }
+  }
+
+  override fun categories(): GifResult<List<GifCategory>> {
+    val key = apiKey
+    if (key.isNullOrBlank()) return GifResult.Failure(GifError.NO_API_KEY)
+    val url = "$BASE/gifs/categories?api_key=${enc(key)}"
+    val json = when (val res = GifHttp.getJson(url)) {
+      is GifResult.Failure -> return GifResult.Success(emptyList())
+      is GifResult.Success -> res.value
+    }
+    // Categories are optional: any parse failure degrades to an empty list, never a hard error.
+    val list = runCatching { parseCategories(json) }.getOrDefault(emptyList())
+    return GifResult.Success(list)
+  }
+
+  /** Parse a GIPHY list response ({ data, pagination, meta }) into a [GifPage]. */
+  private fun parsePage(json: JSONObject, limit: Int, offset: Int): GifResult<GifPage> {
+    // GIPHY echoes its own status inside meta; a >= 400 status can accompany an HTTP 200 body.
+    val status = json.optJSONObject("meta")?.optInt("status", 200) ?: 200
+    if (status >= 400) {
+      return GifResult.Failure(
+        when {
+          status == 429 -> GifError.RATE_LIMITED
+          status in 500..599 -> GifError.SERVER
+          else -> GifError.PARSE
+        }
+      )
+    }
+    val data = json.optJSONArray("data") ?: return GifResult.Failure(GifError.PARSE)
+    val items = ArrayList<GifItem>(data.length())
+    for (i in 0 until data.length()) {
+      val obj = data.optJSONObject(i) ?: continue
+      val images = obj.optJSONObject("images")
+      val preview = rendition(images, "fixed_width_downsampled", "fixed_width", "preview_gif") ?: continue
+      val content = rendition(images, "downsized", "original", "fixed_width") ?: continue
+      val (pUrl, pW, pH) = preview
+      val (cUrl, cW, cH) = content
+      items.add(
+        GifItem(
+          id = obj.optString("id"),
+          description = obj.optString("title"),
+          previewUrl = pUrl,
+          previewWidth = pW,
+          previewHeight = pH,
+          contentUrl = cUrl,
+          contentWidth = cW,
+          contentHeight = cH
+        )
+      )
+    }
+    val pagination = json.optJSONObject("pagination")
+    val count = pagination?.optInt("count", data.length()) ?: data.length()
+    // A missing total_count is treated as unbounded so pagination relies on the count < limit rule.
+    val totalCount = pagination?.optInt("total_count", Int.MAX_VALUE) ?: Int.MAX_VALUE
+    val nextOffset = offset + count
+    val nextCursor = when {
+      count < limit -> null
+      nextOffset >= totalCount -> null
+      else -> nextOffset.toString()
+    }
+    return GifResult.Success(GifPage(items, nextCursor))
+  }
+
+  /** Parse the optional GIPHY categories response; the caller downgrades any throw to empty. */
+  private fun parseCategories(json: JSONObject): List<GifCategory> {
+    val data = json.optJSONArray("data") ?: return emptyList()
+    val out = ArrayList<GifCategory>(data.length())
+    for (i in 0 until data.length()) {
+      val obj = data.optJSONObject(i) ?: continue
+      val name = obj.optString("name")
+      if (name.isBlank()) continue
+      val images = obj.optJSONObject("gif")?.optJSONObject("images")
+      val imageUrl = rendition(images, "fixed_width", "downsized", "original", "preview_gif")?.first
+      out.add(GifCategory(name = name, searchTerm = name, imageUrl = imageUrl))
+    }
+    return out
+  }
+
+  /**
+   * Pick the first present rendition among [names] and return its (url, width, height), or null
+   * when none has a usable (non-blank) url. GIPHY encodes width/height as strings.
+   */
+  private fun rendition(images: JSONObject?, vararg names: String): Triple<String, Int, Int>? {
+    if (images == null) return null
+    for (name in names) {
+      val r = images.optJSONObject(name) ?: continue
+      val url = r.optString("url")
+      if (url.isBlank()) continue
+      val w = r.optString("width").toIntOrNull() ?: 0
+      val h = r.optString("height").toIntOrNull() ?: 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://api.giphy.com/v1"
+  }
+}

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

@@ -0,0 +1,258 @@
+package com.customcamera.gif
+
+import java.io.IOException
+import java.io.OutputStream
+
+/**
+ * GIF-variant LZW compressor.
+ *
+ * Faithful Kotlin port of the LZWEncoder used by Kevin Weiner's [AnimatedGifEncoder], which is
+ * itself adapted (K Weiner 12/00) from Jef Poskanzer's Acme.JPM.Encoders GIF encoder by way of
+ * J. M. G. Elliott, ultimately derived from the public-domain `GIFCOMPR.C` / `compress` lineage
+ * (David Rowley's GIF modifications). This is a syntax-only translation; the emitted bitstream is
+ * intended to be byte-for-byte identical to the canonical Java implementation.
+ *
+ * @param width image width in pixels
+ * @param height image height in pixels
+ * @param pixels palette-indexed pixels, one byte per pixel, row-major
+ * @param colorDepth number of bits per pixel used to seed the initial code size
+ */
+class LZWEncoder(width: Int, height: Int, pixels: ByteArray, colorDepth: Int) {
+
+  private val imgW: Int = width
+  private val imgH: Int = height
+  private val pixAry: ByteArray = pixels
+  private val initCodeSize: Int = maxOf(2, colorDepth)
+  private var remaining: Int = 0
+  private var curPixel: Int = 0
+
+  // GIFCOMPR.C - GIF Image compression routines
+  //
+  // Lempel-Ziv compression based on 'compress'. GIF modifications by
+  // David Rowley (mgardi@watdcsu.waterloo.edu)
+
+  private val bits = 12
+  private val hsize = 5003 // 80% occupancy
+
+  // GIF Image compression - modified 'compress'
+  // Based on: compress.c - File compression ala IEEE Computer, June 1984.
+  // By Authors: Spencer W. Thomas, Jim McKie, Steve Davies, Ken Turkowski,
+  //             James A. Woods, Joe Orost.
+
+  private var nBits = 0 // number of bits/code
+  private val maxbits = bits // user settable max # bits/code
+  private var maxcode = 0 // maximum code, given nBits
+  private val maxmaxcode = 1 shl bits // should NEVER generate this code
+
+  private val htab = IntArray(hsize)
+  private val codetab = IntArray(hsize)
+
+  private var freeEnt = 0 // first unused entry
+
+  // Block compression parameters -- after all codes are used up, and the
+  // compression rate changes, start over.
+  private var clearFlg = false
+
+  private var gInitBits = 0
+  private var clearCode = 0
+  private var eofCode = 0
+
+  // Output accumulator.
+  private var curAccum = 0
+  private var curBits = 0
+
+  private val masks = intArrayOf(
+    0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F,
+    0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
+  )
+
+  // Number of characters so far in this 'packet'.
+  private var aCount = 0
+
+  // Storage for the packet accumulator.
+  private val accum = ByteArray(256)
+
+  companion object {
+    private const val EOF = -1
+  }
+
+  /**
+   * Adds a character to the end of the current packet, flushing to [outs] at 254 characters.
+   */
+  private fun charOut(c: Byte, outs: OutputStream) {
+    accum[aCount++] = c
+    if (aCount >= 254) flushChar(outs)
+  }
+
+  /**
+   * Table clear for block compress.
+   */
+  private fun clBlock(outs: OutputStream) {
+    clHash(hsize)
+    freeEnt = clearCode + 2
+    clearFlg = true
+    output(clearCode, outs)
+  }
+
+  /**
+   * Resets the hash table.
+   */
+  private fun clHash(hsize: Int) {
+    for (i in 0 until hsize) htab[i] = -1
+  }
+
+  /**
+   * Core compressor. See the GIFCOMPR lineage above. Uses open addressing double hashing (Knuth
+   * algorithm D with G. Knott's relatively-prime secondary probe) plus block compression with an
+   * adaptive reset when the table fills.
+   */
+  private fun compress(initBits: Int, outs: OutputStream) {
+    var fcode = 0
+    var i = 0
+    var c = 0
+    var disp = 0
+
+    // Set up the globals: gInitBits - initial number of bits.
+    gInitBits = initBits
+
+    // Set up the necessary values.
+    clearFlg = false
+    nBits = gInitBits
+    maxcode = MAXCODE(nBits)
+
+    clearCode = 1 shl (initBits - 1)
+    eofCode = clearCode + 1
+    freeEnt = clearCode + 2
+
+    aCount = 0 // clear packet
+
+    var ent = nextPixel()
+
+    var hshift = 0
+    fcode = hsize
+    while (fcode < 65536) {
+      hshift++
+      fcode *= 2
+    }
+    hshift = 8 - hshift // set hash code range bound
+
+    val hsizeReg = hsize
+    clHash(hsizeReg) // clear hash table
+
+    output(clearCode, outs)
+
+    outerLoop@ while (true) {
+      c = nextPixel()
+      if (c == EOF) break
+      fcode = (c shl maxbits) + ent
+      i = (c shl hshift) xor ent // xor hashing
+
+      if (htab[i] == fcode) {
+        ent = codetab[i]
+        continue
+      } else if (htab[i] >= 0) { // non-empty slot
+        disp = hsizeReg - i // secondary hash (after G. Knott)
+        if (i == 0) disp = 1
+        do {
+          i -= disp
+          if (i < 0) i += hsizeReg
+          if (htab[i] == fcode) {
+            ent = codetab[i]
+            continue@outerLoop
+          }
+        } while (htab[i] >= 0)
+      }
+      output(ent, outs)
+      ent = c
+      if (freeEnt < maxmaxcode) {
+        codetab[i] = freeEnt++ // code -> hashtable
+        htab[i] = fcode
+      } else {
+        clBlock(outs)
+      }
+    }
+    // Put out the final code.
+    output(ent, outs)
+    output(eofCode, outs)
+  }
+
+  /**
+   * Compresses and writes the pixel data to [os], framed by the initial code-size byte and the
+   * trailing block terminator. This is the public entry point used by [AnimatedGifEncoder].
+   */
+  @Throws(IOException::class)
+  fun encode(os: OutputStream) {
+    os.write(initCodeSize) // write "initial code size" byte
+    remaining = imgW * imgH // reset navigation variables
+    curPixel = 0
+    compress(initCodeSize + 1, os) // compress and write the pixel data
+    os.write(0) // write block terminator
+  }
+
+  /**
+   * Flushes the packet to [outs] and resets the accumulator.
+   */
+  private fun flushChar(outs: OutputStream) {
+    if (aCount > 0) {
+      outs.write(aCount)
+      outs.write(accum, 0, aCount)
+      aCount = 0
+    }
+  }
+
+  /** Largest code representable in [nBits] bits. */
+  private fun MAXCODE(nBits: Int): Int = (1 shl nBits) - 1
+
+  /**
+   * Returns the next pixel from the image, or [EOF] when exhausted.
+   */
+  private fun nextPixel(): Int {
+    if (remaining == 0) return EOF
+    remaining--
+    val pix = pixAry[curPixel++]
+    return pix.toInt() and 0xff
+  }
+  /**
+   * Outputs the given [code], packing it into the bit accumulator and emitting full bytes. When
+   * [code] equals [eofCode] the remaining buffered bits are flushed.
+   */
+  private fun output(code: Int, outs: OutputStream) {
+    curAccum = curAccum and masks[curBits]
+
+    if (curBits > 0) {
+      curAccum = curAccum or (code shl curBits)
+    } else {
+      curAccum = code
+    }
+
+    curBits += nBits
+
+    while (curBits >= 8) {
+      charOut((curAccum and 0xff).toByte(), outs)
+      curAccum = curAccum shr 8
+      curBits -= 8
+    }
+
+    // If the next entry is going to be too big for the code size, increase it if possible.
+    if (freeEnt > maxcode || clearFlg) {
+      if (clearFlg) {
+        nBits = gInitBits
+        maxcode = MAXCODE(nBits)
+        clearFlg = false
+      } else {
+        nBits++
+        maxcode = if (nBits == maxbits) maxmaxcode else MAXCODE(nBits)
+      }
+    }
+
+    if (code == eofCode) {
+      // At EOF, write the rest of the buffer.
+      while (curBits > 0) {
+        charOut((curAccum and 0xff).toByte(), outs)
+        curAccum = curAccum shr 8
+        curBits -= 8
+      }
+      flushChar(outs)
+    }
+  }
+}