react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,160 @@
+package com.customcamera.gif
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.PixelFormat
+import android.graphics.Rect
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.Drawable
+import android.os.Handler
+import android.os.Looper
+
+/**
+ * An [Animatable] [Drawable] that cycles through a list of pre-decoded GIF frames.
+ *
+ * This is the all-API animation path for placed GIF overlays: on API < 28 there is no
+ * [android.graphics.drawable.AnimatedImageDrawable], and even on API 28+ we prefer feeding the
+ * exporter the exact same frames it will re-encode. Frames are decoded once (see the GIF decoder)
+ * and owned by this drawable; call [recycle] when the overlay is removed.
+ *
+ * Timing is driven by a main-thread [Handler]: each frame is shown for its own delay, then the
+ * next frame is scheduled. Looping honours the source GIF's loop count (0 == loop forever, the
+ * common case). Drawing scales the current frame to the drawable [bounds], so the same instance
+ * works for a small grid thumbnail and a large placed overlay.
+ */
+class GifFramesDrawable(
+  private val frames: List<Bitmap>,
+  delaysMs: List<Int>,
+  private val loopCount: Int
+) : Drawable(), Animatable, Runnable {
+
+  /** Per-frame display duration, sanitised so a zero/negative delay never busy-loops. */
+  private val delays: IntArray = IntArray(frames.size) { i ->
+    val d = delaysMs.getOrElse(i) { DEFAULT_DELAY_MS }
+    if (d <= 0) DEFAULT_DELAY_MS else d
+  }
+
+  private val paint = Paint(Paint.FILTER_BITMAP_FLAG)
+  private val handler = Handler(Looper.getMainLooper())
+  private val srcRect = Rect()
+
+  private var currentFrame = 0
+  private var loopsDone = 0
+  private var running = false
+
+  /** Number of decoded frames; 1 (or 0) means this is effectively a static image. */
+  val frameCount: Int get() = frames.size
+
+  /** Total time for one full pass through every frame, in milliseconds. */
+  val totalDurationMs: Int get() = delays.sum()
+
+  override fun draw(canvas: Canvas) {
+    if (frames.isEmpty()) return
+    val bmp = frames[currentFrame.coerceIn(0, frames.size - 1)]
+    if (bmp.isRecycled) return
+    srcRect.set(0, 0, bmp.width, bmp.height)
+    canvas.drawBitmap(bmp, srcRect, bounds, paint)
+  }
+
+  override fun run() {
+    if (!running || frames.size <= 1) return
+    val next = currentFrame + 1
+    if (next >= frames.size) {
+      // Completed one full pass through the frames.
+      if (loopCount != 0) {
+        loopsDone++
+        if (loopsDone >= loopCount) {
+          currentFrame = frames.size - 1
+          running = false
+          invalidateSelf()
+          return
+        }
+      }
+      currentFrame = 0
+    } else {
+      currentFrame = next
+    }
+    invalidateSelf()
+    scheduleNext()
+  }
+
+  private fun scheduleNext() {
+    if (!running || frames.size <= 1) return
+    val delay = delays[currentFrame.coerceIn(0, delays.size - 1)].toLong()
+    handler.postDelayed(this, delay)
+  }
+
+  override fun start() {
+    if (frames.size <= 1) { invalidateSelf(); return }
+    if (running) return
+    running = true
+    loopsDone = 0
+    scheduleNext()
+    invalidateSelf()
+  }
+
+  override fun stop() {
+    running = false
+    handler.removeCallbacks(this)
+  }
+
+  override fun isRunning(): Boolean = running
+
+  override fun setAlpha(alpha: Int) { paint.alpha = alpha; invalidateSelf() }
+
+  override fun setColorFilter(colorFilter: ColorFilter?) {
+    paint.colorFilter = colorFilter
+    invalidateSelf()
+  }
+
+  @Deprecated("Deprecated in Java", ReplaceWith("PixelFormat.TRANSLUCENT"))
+  override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
+
+  override fun getIntrinsicWidth(): Int = frames.firstOrNull()?.width ?: -1
+
+  override fun getIntrinsicHeight(): Int = frames.firstOrNull()?.height ?: -1
+
+  /** Reset to the first frame without freeing bitmaps; safe to call before re-[start]. */
+  fun reset() {
+    stop()
+    currentFrame = 0
+    loopsDone = 0
+    invalidateSelf()
+  }
+
+  /**
+   * Deterministically position the drawable at the frame visible [timeMs] into a forever-looping
+   * playback (independent of [loopCount]). Used by the exporter to step frames by hand; the caller
+   * must [stop] the handler-driven animation first so the two don't fight over [currentFrame].
+   */
+  fun seekToTime(timeMs: Long) {
+    if (frames.size <= 1) { currentFrame = 0; invalidateSelf(); return }
+    val total = totalDurationMs
+    if (total <= 0) { currentFrame = 0; invalidateSelf(); return }
+    var t = (timeMs % total).toInt()
+    if (t < 0) t += total
+    var acc = 0
+    var idx = 0
+    for (i in delays.indices) {
+      acc += delays[i]
+      if (t < acc) { idx = i; break }
+      idx = i
+    }
+    currentFrame = idx.coerceIn(0, frames.size - 1)
+    invalidateSelf()
+  }
+
+  /** Stop animating and free every frame bitmap. The drawable is unusable afterwards. */
+  fun recycle() {
+    stop()
+    for (f in frames) {
+      if (!f.isRecycled) f.recycle()
+    }
+  }
+
+  companion object {
+    private const val DEFAULT_DELAY_MS = 100
+  }
+}

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

@@ -0,0 +1,112 @@
+package com.customcamera.gif
+
+import java.io.IOException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.json.JSONException
+import org.json.JSONObject
+
+/**
+ * Minimal blocking HTTP helper shared by every [GifProvider].
+ *
+ * Providers run on a background thread and must never throw, so [getJson] performs a synchronous
+ * GET and folds every failure mode -- transport, HTTP status, and JSON parsing -- into a typed
+ * [GifResult.Failure]. A single [OkHttpClient] is shared across all providers so its connection
+ * pool and dispatcher threads are reused.
+ */
+class GifHttp {
+
+  companion object {
+    /** Shared, lazily-created client: 15s to connect, 20s waiting for the response body. */
+    private val client: OkHttpClient by lazy {
+      OkHttpClient.Builder()
+        .connectTimeout(15, TimeUnit.SECONDS)
+        .readTimeout(20, TimeUnit.SECONDS)
+        .build()
+    }
+
+    /**
+     * Perform a blocking GET and parse the response body as a JSON object.
+     *
+     * Never throws. Failures map to: [GifError.TIMEOUT] (socket timeout), [GifError.NETWORK]
+     * (DNS / connectivity / other IO), [GifError.RATE_LIMITED] (HTTP 429), [GifError.SERVER]
+     * (HTTP 5xx), [GifError.PARSE] (empty or malformed JSON), and [GifError.UNKNOWN] (any other
+     * non-2xx status or unexpected error).
+     */
+    fun getJson(url: String): GifResult<JSONObject> {
+      return try {
+        val request = Request.Builder()
+          .url(url)
+          .header("Accept", "application/json")
+          .get()
+          .build()
+        client.newCall(request).execute().use { response ->
+          val code = response.code
+          when {
+            response.isSuccessful -> {
+              val bodyString = response.body?.string()
+              if (bodyString.isNullOrBlank()) {
+                GifResult.Failure(GifError.PARSE)
+              } else {
+                try {
+                  GifResult.Success(JSONObject(bodyString))
+                } catch (e: JSONException) {
+                  GifResult.Failure(GifError.PARSE, e)
+                }
+              }
+            }
+            code == 429 -> GifResult.Failure(GifError.RATE_LIMITED)
+            code in 500..599 -> GifResult.Failure(GifError.SERVER)
+            else -> GifResult.Failure(GifError.UNKNOWN)
+          }
+        }
+      } catch (e: SocketTimeoutException) {
+        GifResult.Failure(GifError.TIMEOUT, e)
+      } catch (e: UnknownHostException) {
+        GifResult.Failure(GifError.NETWORK, e)
+      } catch (e: IOException) {
+        GifResult.Failure(GifError.NETWORK, e)
+      } catch (e: Exception) {
+        GifResult.Failure(GifError.UNKNOWN, e)
+      }
+    }
+
+    /**
+     * Blocking GET that returns the raw response body bytes — used to download a GIF's bytes
+     * (grid thumbnail or the full content GIF) for decoding. Same failure folding as [getJson],
+     * except the body is returned verbatim rather than parsed. Never throws.
+     */
+    fun getBytes(url: String): GifResult<ByteArray> {
+      return try {
+        val request = Request.Builder().url(url).get().build()
+        client.newCall(request).execute().use { response ->
+          val code = response.code
+          when {
+            response.isSuccessful -> {
+              val bytes = response.body?.bytes()
+              if (bytes == null || bytes.isEmpty()) {
+                GifResult.Failure(GifError.PARSE)
+              } else {
+                GifResult.Success(bytes)
+              }
+            }
+            code == 429 -> GifResult.Failure(GifError.RATE_LIMITED)
+            code in 500..599 -> GifResult.Failure(GifError.SERVER)
+            else -> GifResult.Failure(GifError.UNKNOWN)
+          }
+        }
+      } catch (e: SocketTimeoutException) {
+        GifResult.Failure(GifError.TIMEOUT, e)
+      } catch (e: UnknownHostException) {
+        GifResult.Failure(GifError.NETWORK, e)
+      } catch (e: IOException) {
+        GifResult.Failure(GifError.NETWORK, e)
+      } catch (e: Exception) {
+        GifResult.Failure(GifError.UNKNOWN, e)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,186 @@
+package com.customcamera.gif
+
+import android.graphics.BitmapFactory
+import android.graphics.drawable.AnimatedImageDrawable
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.LruCache
+import android.widget.ImageView
+import java.nio.ByteBuffer
+import java.util.WeakHashMap
+import java.util.concurrent.Executors
+
+/**
+ * Loads GIF thumbnails into the picker grid's [ImageView]s, and downloads raw GIF bytes for the
+ * placed overlay. Deliberately dependency-free (uses only [GifHttp] + the platform decoders) so
+ * the grid works without the frame decoder/encoder.
+ *
+ * Thumbnails animate on API 28+ via [AnimatedImageDrawable] (native, lazy, memory-friendly) and
+ * fall back to a downsampled static first frame on API 24–27 — a deliberate low-RAM degradation
+ * for old devices; the *placed* overlay still animates on every API via the frame decoder.
+ *
+ * Downloaded bytes are held in a bounded LRU cache keyed by URL so re-scrolling the grid and then
+ * picking a GIF never re-downloads. Decoded thumbnails are additionally held in a small drawable
+ * LRU so a GIF that scrolls back into view is re-shown instantly (no re-decode, no blank flash). A
+ * per-[ImageView] "pending url" guard (a [WeakHashMap]) makes the loader safe against RecyclerView
+ * cell recycling: a slow response for a recycled cell is dropped instead of painting the wrong GIF.
+ */
+class GifImageLoader(cacheSizeBytes: Int = DEFAULT_CACHE_BYTES) {
+
+  private val executor = Executors.newFixedThreadPool(3) { r ->
+    Thread(r, "gif-img").apply { isDaemon = true }
+  }
+  private val main = Handler(Looper.getMainLooper())
+
+  private val byteCache = object : LruCache<String, ByteArray>(cacheSizeBytes) {
+    override fun sizeOf(key: String, value: ByteArray): Int = value.size
+  }
+
+  /** The URL each live ImageView currently wants; guards against recycled-cell races. */
+  private val pending = WeakHashMap<ImageView, String>()
+
+  /**
+   * Decoded thumbnails, keyed by URL+size. Lets a previously-viewed GIF that scrolls back into the
+   * grid be re-shown synchronously on the main thread — no re-decode, no background hop, and no
+   * blanking of the cell — which is what removes the 1–2s blank/flicker on scroll-back. Bounded by
+   * entry count; an evicted animation is stopped (unless it is still attached to a live cell).
+   */
+  private val drawableCache = object : LruCache<String, Drawable>(DRAWABLE_CACHE_ENTRIES) {
+    override fun entryRemoved(evicted: Boolean, key: String, oldValue: Drawable, newValue: Drawable?) {
+      if (oldValue !== newValue && oldValue.callback == null) {
+        (oldValue as? AnimatedImageDrawable)?.stop()
+      }
+    }
+  }
+
+  @Volatile private var shutdown = false
+
+  /**
+   * Download (or reuse cached bytes for) [url], decode, and set the result on [target]. Any
+   * previous request for the same view is superseded. [maxDim] caps the decoded thumbnail size.
+   */
+  fun loadThumbnail(url: String, target: ImageView, maxDim: Int = DEFAULT_THUMB_MAX_DIM) {
+    if (url.isBlank()) return
+    pending[target] = url
+    val key = cacheKey(url, maxDim)
+
+    // Fast path: this GIF was decoded earlier (e.g. it was scrolled off and is now coming back).
+    // Re-show the cached drawable straight away on the main thread — no blanking, no re-decode,
+    // no background hop — so a returning cell never flashes its blank placeholder. Only reuse a
+    // drawable that isn't currently attached to a different live cell (the rare same-URL-twice
+    // case), so we never steal an animation from another visible view.
+    val cached = drawableCache.get(key)
+    if (cached != null && (cached.callback == null || cached.callback === target)) {
+      if (target.drawable !== cached) {
+        (target.drawable as? AnimatedImageDrawable)?.stop()
+        target.setImageDrawable(cached)
+      }
+      (cached as? AnimatedImageDrawable)?.start()
+      return
+    }
+
+    // Slow path: first time this GIF is shown. Blank the recycled cell and decode off-main, then
+    // cache the result so any later scroll-back takes the flicker-free fast path above.
+    (target.drawable as? AnimatedImageDrawable)?.stop()
+    target.setImageDrawable(null)
+    execute {
+      val bytes = bytesFor(url) ?: return@execute
+      val drawable = runCatching { decodeThumbnail(bytes, maxDim) }.getOrNull() ?: return@execute
+      main.post {
+        // Cache even if this cell was recycled meanwhile: the decode is done, so a future
+        // appearance of the same GIF should reuse it rather than decode again.
+        drawableCache.put(key, drawable)
+        if (shutdown || pending[target] != url) {
+          (drawable as? AnimatedImageDrawable)?.stop()
+          return@post
+        }
+        target.setImageDrawable(drawable)
+        (drawable as? AnimatedImageDrawable)?.start()
+      }
+    }
+  }
+
+  private fun cacheKey(url: String, maxDim: Int): String = "$url#$maxDim"
+
+  /** Blocking byte fetch for the overlay content GIF; caches on success. Off-main callers only. */
+  fun fetchBytes(url: String): GifResult<ByteArray> {
+    byteCache.get(url)?.let { return GifResult.Success(it) }
+    val res = GifHttp.getBytes(url)
+    if (res is GifResult.Success) byteCache.put(url, res.value)
+    return res
+  }
+
+  /** Forget the pending request for [target] (e.g. when the sheet closes). */
+  fun cancel(target: ImageView) {
+    pending.remove(target)
+    (target.drawable as? AnimatedImageDrawable)?.stop()
+  }
+
+  private fun bytesFor(url: String): ByteArray? {
+    byteCache.get(url)?.let { return it }
+    val res = GifHttp.getBytes(url)
+    return if (res is GifResult.Success) {
+      byteCache.put(url, res.value)
+      res.value
+    } else {
+      null
+    }
+  }
+
+  private fun decodeThumbnail(bytes: ByteArray, maxDim: Int): Drawable? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      val source = android.graphics.ImageDecoder.createSource(ByteBuffer.wrap(bytes))
+      return android.graphics.ImageDecoder.decodeDrawable(source) { decoder, info, _ ->
+        val longest = maxOf(info.size.width, info.size.height)
+        if (maxDim > 0 && longest > maxDim) {
+          decoder.setTargetSampleSize(sampleSizeFor(longest, maxDim))
+        }
+      }
+    }
+    // API 24–27: static first frame, downsampled.
+    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeByteArray(bytes, 0, bytes.size, opts)
+    val longest = maxOf(opts.outWidth, opts.outHeight)
+    val decodeOpts = BitmapFactory.Options().apply {
+      inSampleSize = if (maxDim > 0 && longest > maxDim) sampleSizeFor(longest, maxDim) else 1
+    }
+    val bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.size, decodeOpts) ?: return null
+    return BitmapDrawable(null, bmp)
+  }
+
+  /** Largest power-of-two sample size that keeps the longest edge >= [maxDim]. */
+  private fun sampleSizeFor(longest: Int, maxDim: Int): Int {
+    var sample = 1
+    while (longest / (sample * 2) >= maxDim) sample *= 2
+    return sample
+  }
+
+  private fun execute(block: () -> Unit) {
+    try {
+      executor.execute { if (!shutdown) block() }
+    } catch (e: Exception) {
+      // Executor already shut down — nothing to do.
+    }
+  }
+
+  /** Release worker threads and drop the caches. Safe to call more than once. */
+  fun shutdown() {
+    shutdown = true
+    executor.shutdownNow()
+    byteCache.evictAll()
+    drawableCache.evictAll()
+    pending.clear()
+  }
+
+  companion object {
+    private const val DEFAULT_CACHE_BYTES = 16 * 1024 * 1024
+    private const val DEFAULT_THUMB_MAX_DIM = 256
+    // How many decoded thumbnails to keep for instant, flicker-free scroll-back. Sized to a few
+    // screens of the ~104dp grid cells; thumbnails are downsampled to DEFAULT_THUMB_MAX_DIM and
+    // AnimatedImageDrawable is lazy, so this stays modest on RAM. Evicted animations are stopped.
+    private const val DRAWABLE_CACHE_ENTRIES = 48
+  }
+}

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

@@ -0,0 +1,74 @@
+package com.customcamera.gif
+
+/**
+ * Provider-agnostic data models for the GIF picker feature.
+ *
+ * Everything the UI and the editor overlay consume is expressed in these types so that the
+ * concrete provider (GIPHY, Tenor, or anything added later) stays fully behind [GifProvider].
+ * No GIPHY/Tenor-specific field ever leaks past this file.
+ */
+
+/** A single GIF result. URLs point at remote animated GIF assets. */
+data class GifItem(
+  /** Stable provider-scoped id, used for de-duplication and "recent" tracking. */
+  val id: String,
+  /** Human-readable description for accessibility / content-description. May be blank. */
+  val description: String,
+  /** Small animated GIF used for the grid thumbnail (roughly ~200 px wide). */
+  val previewUrl: String,
+  val previewWidth: Int,
+  val previewHeight: Int,
+  /** Larger animated GIF placed on the photo when the item is picked. */
+  val contentUrl: String,
+  val contentWidth: Int,
+  val contentHeight: Int
+) {
+  /** Aspect ratio (w/h) of the preview, defaulting to 1 when dimensions are unknown. */
+  val previewAspect: Float
+    get() = if (previewWidth > 0 && previewHeight > 0) previewWidth.toFloat() / previewHeight else 1f
+}
+
+/** A browsable category / trending term shown as a chip or tile before the user searches. */
+data class GifCategory(
+  /** Display label (already localized/normalized by the provider). */
+  val name: String,
+  /** The query to run when the category is tapped. */
+  val searchTerm: String,
+  /** Optional still/animated preview image for the category tile. */
+  val imageUrl: String?
+)
+
+/** One page of results plus an opaque cursor for the next page (null/blank = no more). */
+data class GifPage(
+  val items: List<GifItem>,
+  val nextCursor: String?
+)
+
+/** Why a provider call could not return data. Drives the UI's empty/error/retry states. */
+enum class GifError {
+  /** No connectivity, DNS failure, socket error, etc. */
+  NETWORK,
+  /** The request timed out. */
+  TIMEOUT,
+  /** The provider has no API key configured, so it cannot be used at all. */
+  NO_API_KEY,
+  /** HTTP 429 / provider quota exceeded. */
+  RATE_LIMITED,
+  /** HTTP 5xx from the provider. */
+  SERVER,
+  /** The response could not be parsed into the expected shape. */
+  PARSE,
+  /** Anything else. */
+  UNKNOWN
+}
+
+/** Result wrapper. [Success] carries the value; [Failure] carries a typed [GifError]. */
+sealed class GifResult<out T> {
+  data class Success<T>(val value: T) : GifResult<T>()
+  data class Failure(val error: GifError, val cause: Throwable? = null) : GifResult<Nothing>()
+
+  inline fun <R> map(transform: (T) -> R): GifResult<R> = when (this) {
+    is Success -> Success(transform(value))
+    is Failure -> this
+  }
+}

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

@@ -0,0 +1,49 @@
+package com.customcamera.gif
+
+/**
+ * The single seam behind which every GIF service lives.
+ *
+ * The editor and picker UI depend ONLY on this interface, never on GIPHY/Tenor directly, so a
+ * provider can be swapped (or a new one added) by implementing this and registering it in
+ * [GifProviders]. Implementations are called on a background thread by [GifRepository] and must
+ * be blocking (no callbacks of their own); they must never touch the UI thread.
+ *
+ * Implementations must be resilient: any network/parse failure is returned as a
+ * [GifResult.Failure] with a typed [GifError] rather than thrown, so the UI can render a precise
+ * empty/error/retry state.
+ */
+interface GifProvider {
+  /** Stable identifier, e.g. "giphy" or "tenor". Used to select the provider from config. */
+  val id: String
+
+  /**
+   * Attribution string the picker must display when this provider is active (both GIPHY and
+   * Tenor require visible attribution). Null when none is required.
+   */
+  val attributionLabel: String?
+
+  /**
+   * False when the provider cannot operate at all — almost always a missing API key. The UI
+   * shows a dedicated "not configured" message instead of a generic network error, and the
+   * repository short-circuits with [GifError.NO_API_KEY].
+   */
+  fun isConfigured(): Boolean
+
+  /**
+   * Trending / featured GIFs for the initial, no-query state.
+   * @param cursor opaque page cursor from a previous [GifPage.nextCursor]; null for the first page.
+   */
+  fun trending(limit: Int, cursor: String?): GifResult<GifPage>
+
+  /**
+   * Search results for [query].
+   * @param cursor opaque page cursor from a previous [GifPage.nextCursor]; null for the first page.
+   */
+  fun search(query: String, limit: Int, cursor: String?): GifResult<GifPage>
+
+  /**
+   * Browsable categories shown before the user types. Providers without a categories endpoint
+   * may return an empty list; the UI then simply shows trending only.
+   */
+  fun categories(): GifResult<List<GifCategory>>
+}

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

@@ -0,0 +1,27 @@
+package com.customcamera.gif
+
+/**
+ * Factory mapping a configured provider id to a concrete [GifProvider] implementation.
+ *
+ * GIPHY is the default -- selected for a null, blank, or unrecognised id -- because Google has
+ * announced the discontinuation of the Tenor API; Tenor is therefore only used when explicitly
+ * requested by [providerId] == "tenor".
+ */
+object GifProviders {
+
+  /**
+   * Create the provider selected by [providerId].
+   *
+   * @param providerId case-insensitive provider key. "tenor" -> [TenorGifProvider]; anything else
+   *   (including null / blank / unknown) -> [GiphyGifProvider].
+   * @param apiKey API key handed to the selected provider; may be null (the provider then reports
+   *   [GifProvider.isConfigured] == false).
+   * @return a ready-to-use [GifProvider]; never null.
+   */
+  fun create(providerId: String?, apiKey: String?): GifProvider {
+    return when (providerId?.trim()?.lowercase()) {
+      "tenor" -> TenorGifProvider(apiKey)
+      else -> GiphyGifProvider(apiKey)
+    }
+  }
+}