react-native-photo-video-editor 0.1.0 → 0.2.0

package/android/src/main/java/com/photovideoeditor/stickers/OpenMojiCatalog.kt

@@ -1,172 +0,0 @@
-package com.photovideoeditor.stickers
-
-import android.content.Context
-import android.os.Handler
-import android.os.Looper
-import org.json.JSONArray
-import org.json.JSONObject
-import java.io.File
-import java.net.HttpURLConnection
-import java.net.URL
-import java.util.concurrent.Executors
-
-/** One entry from OpenMoji's `data/openmoji.json` index. */
-data class OpenMojiEntry(
-  val emoji: String,
-  val hexcode: String,
-  val group: String,
-  val annotation: String,
-  val tags: String
-)
-
-/**
- * Fetches and disk-caches the OpenMoji catalog index (CC BY-SA 4.0, https://openmoji.org),
- * exposing search/filter helpers plus the CDN URL builders for thumbnail/full-res assets.
- *
- * Networking uses plain [HttpURLConnection] on a background executor (this codebase has no
- * networking dependency and shouldn't gain one for a simple GET) and parses with
- * [org.json.JSONArray]/[org.json.JSONObject], matching the JSON style already used elsewhere
- * (e.g. `PhotoVideoEditorActivity`'s `stickerAssets` parsing).
- */
-object OpenMojiCatalog {
-  private const val INDEX_URL =
-    "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/data/openmoji.json"
-  private const val CACHE_FILE_NAME = "openmoji_index.json"
-  private const val CACHE_TIMESTAMP_PREFS = "openmoji_cache"
-  private const val CACHE_TIMESTAMP_KEY = "fetched_at"
-  private val CACHE_TTL_MS = 7L * 24L * 60L * 60L * 1000L
-
-  /** Fixed, sensible display order for the "All" chip row; unknown groups are appended after. */
-  private val GROUP_DISPLAY_ORDER = listOf(
-    "smileys-emotion",
-    "people-body",
-    "animals-nature",
-    "food-drink",
-    "travel-places",
-    "activities",
-    "objects",
-    "symbols",
-    "flags"
-  )
-
-  private val executor = Executors.newSingleThreadExecutor { task -> Thread(task, "openmoji-catalog") }
-  private val mainHandler = Handler(Looper.getMainLooper())
-
-  @Volatile private var cachedEntries: List<OpenMojiEntry>? = null
-
-  /**
-   * Loads the catalog (memory -> disk cache -> network, falling back to any cached copy on
-   * network failure), delivering the result on the main thread.
-   */
-  fun load(context: Context, onResult: (entries: List<OpenMojiEntry>?, error: Exception?) -> Unit) {
-    val inMemory = cachedEntries
-    if (inMemory != null) {
-      mainHandler.post { onResult(inMemory, null) }
-      return
-    }
-    val appContext = context.applicationContext
-    executor.execute {
-      try {
-        val entries = loadBlocking(appContext)
-        cachedEntries = entries
-        mainHandler.post { onResult(entries, null) }
-      } catch (e: Exception) {
-        mainHandler.post { onResult(null, e) }
-      }
-    }
-  }
-
-  private fun loadBlocking(context: Context): List<OpenMojiEntry> {
-    val cacheFile = File(context.cacheDir, CACHE_FILE_NAME)
-    val cacheAgeMs = cacheAgeMs(context)
-    val cacheFresh = cacheFile.exists() && cacheAgeMs != null && cacheAgeMs < CACHE_TTL_MS
-
-    if (cacheFresh) {
-      return parse(cacheFile.readText())
-    }
-
-    return try {
-      val json = fetch(INDEX_URL)
-      cacheFile.writeText(json)
-      markCacheTimestamp(context)
-      parse(json)
-    } catch (e: Exception) {
-      // Network failed: fall back to any cached copy, regardless of age, per spec.
-      if (cacheFile.exists()) parse(cacheFile.readText()) else throw e
-    }
-  }
-
-  private fun fetch(urlString: String): String {
-    val connection = URL(urlString).openConnection() as HttpURLConnection
-    connection.instanceFollowRedirects = true
-    connection.connectTimeout = 15_000
-    connection.readTimeout = 30_000
-    connection.requestMethod = "GET"
-    try {
-      val code = connection.responseCode
-      if (code !in 200..299) throw java.io.IOException("HTTP $code fetching $urlString")
-      return connection.inputStream.bufferedReader().use { it.readText() }
-    } finally {
-      connection.disconnect()
-    }
-  }
-
-  private fun parse(json: String): List<OpenMojiEntry> {
-    val array = JSONArray(json)
-    val result = ArrayList<OpenMojiEntry>(array.length())
-    for (i in 0 until array.length()) {
-      val obj: JSONObject = array.optJSONObject(i) ?: continue
-      val hexcode = obj.optString("hexcode").takeIf { it.isNotBlank() } ?: continue
-      result.add(
-        OpenMojiEntry(
-          emoji = obj.optString("emoji"),
-          hexcode = hexcode,
-          group = obj.optString("group"),
-          annotation = obj.optString("annotation"),
-          tags = obj.optString("tags")
-        )
-      )
-    }
-    return result
-  }
-
-  private fun cacheAgeMs(context: Context): Long? {
-    val prefs = context.getSharedPreferences(CACHE_TIMESTAMP_PREFS, Context.MODE_PRIVATE)
-    val fetchedAt = prefs.getLong(CACHE_TIMESTAMP_KEY, -1L)
-    if (fetchedAt < 0) return null
-    return System.currentTimeMillis() - fetchedAt
-  }
-
-  private fun markCacheTimestamp(context: Context) {
-    context.getSharedPreferences(CACHE_TIMESTAMP_PREFS, Context.MODE_PRIVATE)
-      .edit()
-      .putLong(CACHE_TIMESTAMP_KEY, System.currentTimeMillis())
-      .apply()
-  }
-
-  fun groups(): List<String> {
-    val entries = cachedEntries ?: return emptyList()
-    val present = entries.map { it.group }.distinct()
-    val ordered = GROUP_DISPLAY_ORDER.filter { it in present }
-    val rest = present.filter { it !in GROUP_DISPLAY_ORDER }.sorted()
-    return ordered + rest
-  }
-
-  fun byGroup(group: String): List<OpenMojiEntry> =
-    cachedEntries?.filter { it.group == group } ?: emptyList()
-
-  fun search(query: String): List<OpenMojiEntry> {
-    val entries = cachedEntries ?: return emptyList()
-    val needle = query.trim().lowercase()
-    if (needle.isEmpty()) return entries
-    return entries.filter {
-      it.annotation.lowercase().contains(needle) || it.tags.lowercase().contains(needle)
-    }
-  }
-
-  fun thumbnailUrl(hexcode: String): String =
-    "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/color/72x72/$hexcode.png"
-
-  fun fullUrl(hexcode: String): String =
-    "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/color/618x618/$hexcode.png"
-}

package/android/src/main/java/com/photovideoeditor/stickers/RemoteImageLoader.kt

@@ -1,110 +0,0 @@
-package com.photovideoeditor.stickers
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.os.Handler
-import android.os.Looper
-import android.util.LruCache
-import android.widget.ImageView
-import java.io.File
-import java.io.FileOutputStream
-import java.net.HttpURLConnection
-import java.net.URL
-import java.security.MessageDigest
-import java.util.concurrent.Executors
-
-/**
- * Small async image pipeline for the online-stickers sheet: thumbnails for the grid (memory LRU
- * + disk cache) and full-res download-on-tap for the sticker that gets inserted as a layer.
- *
- * No image library dependency (Glide/Coil/Picasso) is used, matching this codebase's
- * dependency-light approach elsewhere.
- */
-object RemoteImageLoader {
-  private val executor = Executors.newFixedThreadPool(4) { task -> Thread(task, "openmoji-image") }
-  private val mainHandler = Handler(Looper.getMainLooper())
-
-  private val memoryCache = object : LruCache<String, Bitmap>(8 * 1024 * 1024) {
-    override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount
-  }
-
-  private fun diskCacheDir(context: Context): File =
-    File(context.cacheDir, "openmoji").apply { mkdirs() }
-
-  private fun cacheFileFor(context: Context, url: String): File {
-    val name = MessageDigest.getInstance("MD5").digest(url.toByteArray())
-      .joinToString("") { "%02x".format(it) }
-    return File(diskCacheDir(context), "$name.png")
-  }
-
-  /**
-   * Loads [url] into [imageView], tagging the view with the URL being loaded so a recycled
-   * RecyclerView cell doesn't get a stale bitmap set on it after the fact.
-   */
-  fun loadThumbnail(context: Context, url: String, imageView: ImageView) {
-    imageView.tag = url
-    val memoryHit = memoryCache.get(url)
-    if (memoryHit != null) {
-      imageView.setImageBitmap(memoryHit)
-      return
-    }
-    imageView.setImageDrawable(null)
-    val appContext = context.applicationContext
-    executor.execute {
-      val bitmap = try {
-        val cacheFile = cacheFileFor(appContext, url)
-        if (cacheFile.exists()) {
-          BitmapFactory.decodeFile(cacheFile.absolutePath)
-        } else {
-          val bytes = download(url)
-          cacheFile.writeBytes(bytes)
-          BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
-        }
-      } catch (_: Exception) {
-        null
-      }
-      if (bitmap != null) {
-        memoryCache.put(url, bitmap)
-        mainHandler.post {
-          if (imageView.tag == url) imageView.setImageBitmap(bitmap)
-        }
-      }
-    }
-  }
-
-  /**
-   * Downloads (or returns the cached copy of) the full-res sticker image, delivering the local
-   * file path on the main thread.
-   */
-  fun downloadFull(context: Context, url: String, onResult: (localFilePath: String?, error: Exception?) -> Unit) {
-    val appContext = context.applicationContext
-    executor.execute {
-      try {
-        val cacheFile = cacheFileFor(appContext, url)
-        if (!cacheFile.exists()) {
-          val bytes = download(url)
-          FileOutputStream(cacheFile).use { it.write(bytes) }
-        }
-        mainHandler.post { onResult(cacheFile.absolutePath, null) }
-      } catch (e: Exception) {
-        mainHandler.post { onResult(null, e) }
-      }
-    }
-  }
-
-  private fun download(urlString: String): ByteArray {
-    val connection = URL(urlString).openConnection() as HttpURLConnection
-    connection.instanceFollowRedirects = true
-    connection.connectTimeout = 15_000
-    connection.readTimeout = 30_000
-    connection.requestMethod = "GET"
-    try {
-      val code = connection.responseCode
-      if (code !in 200..299) throw java.io.IOException("HTTP $code fetching $urlString")
-      return connection.inputStream.use { it.readBytes() }
-    } finally {
-      connection.disconnect()
-    }
-  }
-}

package/ios/Stickers/OpenMojiCatalog.swift

@@ -1,188 +0,0 @@
-import Foundation
-
-/// A single entry from OpenMoji's `openmoji.json` index that we care about.
-/// Mirrors Android's `OpenMojiCatalog.Entry` in spirit (same field set).
-struct OpenMojiEntry {
-  let emoji: String
-  let hexcode: String
-  let group: String
-  let annotation: String
-  let tags: String
-}
-
-/// Fetches, disk-caches, and serves the OpenMoji sticker index
-/// (`https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/data/openmoji.json`).
-///
-/// No third-party networking/JSON dependency is used — this codebase is deliberately
-/// dependency-light (see `stickerAssets: [[String: Any]]` in `PhotoVideoEditorViewController`
-/// for the existing dictionary-based JSON precedent). Plain `URLSession` + `JSONSerialization`.
-final class OpenMojiCatalog {
-  static let shared = OpenMojiCatalog()
-
-  /// Fixed, sensible display order for OpenMoji's `group` values.
-  static let orderedGroups: [String] = [
-    "smileys-emotion",
-    "people-body",
-    "animals-nature",
-    "food-drink",
-    "travel-places",
-    "activities",
-    "objects",
-    "symbols",
-    "flags",
-  ]
-
-  private static let indexURL = URL(string: "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/data/openmoji.json")!
-  private static let cacheFileName = "openmoji_index.json"
-  private static let cacheTimestampKey = "OpenMojiCatalog.cacheTimestamp"
-  private static let cacheMaxAgeSeconds: TimeInterval = 7 * 24 * 60 * 60 // 7 days
-
-  private let queue = DispatchQueue(label: "com.photovideoeditor.openmojicatalog", qos: .userInitiated)
-  private var entries: [OpenMojiEntry]?
-  private var isLoading = false
-  private var pendingCompletions: [([OpenMojiEntry]?, Error?) -> Void] = []
-
-  private init() {}
-
-  private var cacheFileURL: URL? {
-    FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?
-      .appendingPathComponent(Self.cacheFileName)
-  }
-
-  enum CatalogError: Error {
-    case network(Error)
-    case badResponse
-    case emptyCache
-  }
-
-  /// Loads the catalog (cache-first, network fallback with cache-refresh) and calls `completion`
-  /// on the main thread. Safe to call multiple times concurrently; duplicate in-flight calls are coalesced.
-  func load(completion: @escaping ([OpenMojiEntry]?, Error?) -> Void) {
-    if let entries {
-      DispatchQueue.main.async { completion(entries, nil) }
-      return
-    }
-    queue.async { [weak self] in
-      guard let self else { return }
-      self.pendingCompletions.append(completion)
-      if self.isLoading { return }
-      self.isLoading = true
-      self.loadLocked()
-    }
-  }
-
-  /// Must be called on `queue`. Decides whether to use the on-disk cache or fetch fresh, then
-  /// fans results out to every completion queued while the load was in flight.
-  private func loadLocked() {
-    let cacheAge = self.cacheAgeSeconds()
-    if let cacheAge, cacheAge < Self.cacheMaxAgeSeconds, let cached = self.readCache() {
-      self.finishLoad(entries: cached, error: nil)
-      return
-    }
-    self.fetchFromNetwork { [weak self] data, error in
-      guard let self else { return }
-      self.queue.async {
-        if let data {
-          self.writeCache(data)
-          let parsed = self.parse(data)
-          self.finishLoad(entries: parsed, error: parsed.isEmpty ? CatalogError.badResponse : nil)
-        } else if let cached = self.readCache() {
-          // Network failed but we have a cache of any age — fall back to it.
-          self.finishLoad(entries: cached, error: nil)
-        } else {
-          self.finishLoad(entries: nil, error: error ?? CatalogError.emptyCache)
-        }
-      }
-    }
-  }
-
-  /// Must be called on `queue`.
-  private func finishLoad(entries: [OpenMojiEntry]?, error: Error?) {
-    if let entries { self.entries = entries }
-    let completions = self.pendingCompletions
-    self.pendingCompletions = []
-    self.isLoading = false
-    DispatchQueue.main.async {
-      completions.forEach { $0(entries, entries == nil ? error : nil) }
-    }
-  }
-
-  private func fetchFromNetwork(completion: @escaping (Data?, Error?) -> Void) {
-    let task = URLSession.shared.dataTask(with: Self.indexURL) { data, response, error in
-      if let error {
-        completion(nil, CatalogError.network(error))
-        return
-      }
-      guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode), let data else {
-        completion(nil, CatalogError.badResponse)
-        return
-      }
-      completion(data, nil)
-    }
-    task.resume()
-  }
-
-  private func cacheAgeSeconds() -> TimeInterval? {
-    let timestamp = UserDefaults.standard.double(forKey: Self.cacheTimestampKey)
-    guard timestamp > 0 else { return nil }
-    return Date().timeIntervalSince1970 - timestamp
-  }
-
-  private func readCache() -> [OpenMojiEntry]? {
-    guard let url = cacheFileURL, let data = try? Data(contentsOf: url) else { return nil }
-    let parsed = parse(data)
-    return parsed.isEmpty ? nil : parsed
-  }
-
-  private func writeCache(_ data: Data) {
-    guard let url = cacheFileURL else { return }
-    do {
-      try data.write(to: url, options: .atomic)
-      UserDefaults.standard.set(Date().timeIntervalSince1970, forKey: Self.cacheTimestampKey)
-    } catch {
-      // Best-effort cache; ignore write failures.
-    }
-  }
-
-  private func parse(_ data: Data) -> [OpenMojiEntry] {
-    guard let raw = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else { return [] }
-    return raw.compactMap { dict in
-      guard
-        let hexcode = dict["hexcode"] as? String, !hexcode.isEmpty,
-        let group = dict["group"] as? String
-      else { return nil }
-      let emoji = dict["emoji"] as? String ?? ""
-      let annotation = dict["annotation"] as? String ?? ""
-      let tags = dict["tags"] as? String ?? ""
-      return OpenMojiEntry(emoji: emoji, hexcode: hexcode, group: group, annotation: annotation, tags: tags)
-    }
-  }
-
-  // MARK: - Query surface
-
-  func groups() -> [String] {
-    guard let entries else { return [] }
-    let present = Set(entries.map { $0.group })
-    return Self.orderedGroups.filter { present.contains($0) }
-  }
-
-  func byGroup(_ group: String) -> [OpenMojiEntry] {
-    (entries ?? []).filter { $0.group == group }
-  }
-
-  func search(_ query: String) -> [OpenMojiEntry] {
-    let needle = query.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-    guard !needle.isEmpty else { return entries ?? [] }
-    return (entries ?? []).filter {
-      $0.annotation.lowercased().contains(needle) || $0.tags.lowercased().contains(needle)
-    }
-  }
-
-  func thumbnailURL(_ hexcode: String) -> URL {
-    URL(string: "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/color/72x72/\(hexcode).png")!
-  }
-
-  func fullURL(_ hexcode: String) -> URL {
-    URL(string: "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/color/618x618/\(hexcode).png")!
-  }
-}

package/ios/Stickers/RemoteImageLoader.swift

@@ -1,127 +0,0 @@
-import UIKit
-
-/// Small async image loader for the online-sticker sheet: in-memory + on-disk thumbnail cache,
-/// plus a full-res "download and hand me a local file" path for the sticker that actually gets
-/// inserted as a layer. Plain `URLSession`, no third-party dependency (matches the rest of the
-/// codebase's zero-networking-dependency policy).
-final class RemoteImageLoader {
-  static let shared = RemoteImageLoader()
-
-  private let memoryCache = NSCache<NSString, UIImage>()
-  private let ioQueue = DispatchQueue(label: "com.photovideoeditor.remoteimageloader.io", qos: .userInitiated)
-  private let session = URLSession.shared
-
-  private init() {
-    memoryCache.countLimit = 500
-  }
-
-  private var diskCacheDirectory: URL? {
-    guard let base = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else { return nil }
-    let dir = base.appendingPathComponent("openmoji", isDirectory: true)
-    if !FileManager.default.fileExists(atPath: dir.path) {
-      try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-    }
-    return dir
-  }
-
-  private func diskCacheFile(forKey key: String) -> URL? {
-    diskCacheDirectory?.appendingPathComponent(key)
-  }
-
-  // MARK: - Thumbnails (UICollectionViewCell-safe)
-
-  /// Loads a thumbnail into `imageView`, guarding against cell reuse: the URL being loaded is
-  /// stamped onto the image view via associated object, and the result is only applied if that
-  /// stamp still matches once the load completes (standard fix for the "wrong image after scroll"
-  /// bug with recycled `UICollectionViewCell`/`UITableViewCell` image views).
-  func loadThumbnail(url: URL, into imageView: UIImageView) {
-    Self.setLoadTag(url.absoluteString, on: imageView)
-    imageView.image = nil
-
-    let cacheKey = url.absoluteString as NSString
-    if let cached = memoryCache.object(forKey: cacheKey) {
-      imageView.image = cached
-      return
-    }
-
-    let diskKey = "\(url.lastPathComponent)_thumb.png"
-    ioQueue.async { [weak self] in
-      guard let self else { return }
-      if let diskURL = self.diskCacheFile(forKey: diskKey),
-         let data = try? Data(contentsOf: diskURL),
-         let image = UIImage(data: data) {
-        self.memoryCache.setObject(image, forKey: cacheKey)
-        DispatchQueue.main.async {
-          guard Self.loadTag(on: imageView) == url.absoluteString else { return }
-          imageView.image = image
-        }
-        return
-      }
-
-      self.session.dataTask(with: url) { data, response, _ in
-        guard
-          let data, let image = UIImage(data: data),
-          let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode)
-        else { return }
-        self.memoryCache.setObject(image, forKey: cacheKey)
-        if let diskURL = self.diskCacheFile(forKey: diskKey) {
-          try? data.write(to: diskURL, options: .atomic)
-        }
-        DispatchQueue.main.async {
-          guard Self.loadTag(on: imageView) == url.absoluteString else { return }
-          imageView.image = image
-        }
-      }.resume()
-    }
-  }
-
-  // MARK: - Full-res download
-
-  /// Downloads (or returns the already-cached file for) the full-res sticker image. Completion
-  /// always fires on the main thread.
-  func downloadFull(url: URL, completion: @escaping (URL?, Error?) -> Void) {
-    let diskKey = "\(url.lastPathComponent)_full.png"
-    ioQueue.async { [weak self] in
-      guard let self else { return }
-      if let diskURL = self.diskCacheFile(forKey: diskKey), FileManager.default.fileExists(atPath: diskURL.path) {
-        DispatchQueue.main.async { completion(diskURL, nil) }
-        return
-      }
-      self.session.dataTask(with: url) { data, response, error in
-        if let error {
-          DispatchQueue.main.async { completion(nil, error) }
-          return
-        }
-        guard
-          let data,
-          let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode)
-        else {
-          DispatchQueue.main.async { completion(nil, URLError(.badServerResponse)) }
-          return
-        }
-        guard let diskURL = self.diskCacheFile(forKey: diskKey) else {
-          DispatchQueue.main.async { completion(nil, URLError(.cannotCreateFile)) }
-          return
-        }
-        do {
-          try data.write(to: diskURL, options: .atomic)
-          DispatchQueue.main.async { completion(diskURL, nil) }
-        } catch {
-          DispatchQueue.main.async { completion(nil, error) }
-        }
-      }.resume()
-    }
-  }
-
-  // MARK: - Cell-reuse tagging
-
-  private static var loadTagKey: UInt8 = 0
-
-  private static func setLoadTag(_ tag: String, on imageView: UIImageView) {
-    objc_setAssociatedObject(imageView, &loadTagKey, tag, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
-  }
-
-  private static func loadTag(on imageView: UIImageView) -> String? {
-    objc_getAssociatedObject(imageView, &loadTagKey) as? String
-  }
-}