react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,163 @@
+package com.customcamera
+
+import android.os.Build
+import java.util.Locale
+
+/**
+ * Single source of truth for "which still-image container is this, and what can this device
+ * do with it".
+ *
+ * Before this existed, four tables answered overlapping halves of the same question and drifted
+ * apart: [MediaCacheManager.MediaFormat], [MediaPublisher]'s publish-time MIME mapping,
+ * [MediaPreviewEditor]'s save-to-gallery extension, and [ThumbnailLoader]'s alpha-capable set.
+ * A format added to one but not the others is exactly how HEIF/AVIF ended up being cached as
+ * `.jpg`, published as `image/jpeg`, and decoded into an alpha-less config. Those call sites now
+ * all read from here, so a format is supported everywhere or nowhere.
+ *
+ * Detection deliberately uses BOTH signals the platform gives us — the declared MIME type first,
+ * the file extension second — because MediaStore rows written by other apps routinely carry one
+ * without the other. [GifSupport] keeps its own GIF-specific entry point (animation detection has
+ * no analogue for these formats) but follows the same precedence, so the two never disagree.
+ */
+object ImageFormatSupport {
+  /**
+   * A still-image container this library understands end to end: it can be discovered, decoded
+   * to a thumbnail, cached, previewed, edited and published without ever being renamed to
+   * something it is not.
+   *
+   * [minSdk] is the API level whose *platform decoders* gained the format. Below it the file is
+   * still a first-class asset — it is listed, selected, cached and sent byte-for-byte — only its
+   * pixels cannot be rendered locally, which is what [isDecodable] exists to tell callers.
+   */
+  enum class Format(
+    val extension: String,
+    val mimeType: String,
+    val alternateMimeTypes: Set<String> = emptySet(),
+    val alternateExtensions: Set<String> = emptySet(),
+    val mayHaveAlpha: Boolean = false,
+    val minSdk: Int = Build.VERSION_CODES.BASE
+  ) {
+    JPEG("jpg", "image/jpeg", alternateExtensions = setOf("jpeg")),
+    PNG("png", "image/png", mayHaveAlpha = true),
+    WEBP("webp", "image/webp", mayHaveAlpha = true),
+    GIF("gif", "image/gif", mayHaveAlpha = true),
+    BMP("bmp", "image/bmp"),
+    PDF("pdf", "application/pdf"),
+
+    // HEIF and HEIC are the same underlying container, but they are kept as separate entries
+    // rather than aliases so each keeps its OWN name. Collapsing them would rename every
+    // `image/heic` file (what every iPhone produces) to `.heif` on its way into the cache —
+    // the exact class of "the name no longer describes the bytes" bug this registry exists to
+    // prevent. They share decodability and alpha capability because the container is the same.
+    HEIF(
+      "heif",
+      "image/heif",
+      alternateMimeTypes = setOf("image/heif-sequence"),
+      alternateExtensions = setOf("hif"),
+      mayHaveAlpha = true,
+      minSdk = Build.VERSION_CODES.P
+    ),
+    HEIC(
+      "heic",
+      "image/heic",
+      alternateMimeTypes = setOf("image/heic-sequence"),
+      mayHaveAlpha = true,
+      minSdk = Build.VERSION_CODES.P
+    ),
+
+    // AVIF decoding is platform-provided from Android 12 (API 31). `image/avif` is the
+    // registered type; `.avifs` is the animated-sequence extension and shares the container.
+    AVIF(
+      "avif",
+      "image/avif",
+      alternateExtensions = setOf("avifs"),
+      mayHaveAlpha = true,
+      minSdk = Build.VERSION_CODES.S
+    );
+
+    /** Every MIME spelling that identifies this container. */
+    val mimeTypes: Set<String> get() = alternateMimeTypes + mimeType
+
+    /** Every file extension that identifies this container, without the leading dot. */
+    val extensions: Set<String> get() = alternateExtensions + extension
+
+    /** The extension with its leading dot, for building file names. */
+    val dottedExtension: String get() = ".$extension"
+
+    /**
+     * Whether THIS device can turn the bytes into pixels. False only for HEIF below API 28 and
+     * AVIF below API 31 — see [Format.minSdk]. Callers use this to fall back to a placeholder
+     * instead of showing a black or empty tile.
+     */
+    val isDecodable: Boolean get() = Build.VERSION.SDK_INT >= minSdk
+  }
+
+  private val BY_MIME: Map<String, Format> =
+    Format.entries.flatMap { format -> format.mimeTypes.map { it to format } }.toMap()
+
+  private val BY_EXTENSION: Map<String, Format> =
+    Format.entries.flatMap { format -> format.extensions.map { it to format } }.toMap()
+
+  /** The format [mimeType] names, or null if it is absent or not a container we handle. */
+  fun fromMimeType(mimeType: String?): Format? =
+    mimeType?.lowercase(Locale.US)?.substringBefore(';')?.trim()?.let { BY_MIME[it] }
+
+  /** The format the extension of [name] (a file name, path or URI) names, or null. */
+  fun fromFileName(name: String?): Format? = extensionOf(name)?.let { BY_EXTENSION[it] }
+
+  /**
+   * Resolve the format of an asset from its declared MIME type first, then its file name /
+   * cache path / URI path.
+   *
+   * A declared, recognised `image/` type is authoritative: an asset that says it is
+   * `image/jpeg` is not reclassified because something in its path ends in `.png`. Only an
+   * absent or unrecognised type falls through to the extension — which is what rescues the
+   * many MediaStore rows and SAF documents that arrive with no MIME type at all.
+   *
+   * (Written `image/` rather than with a trailing wildcard on purpose: Kotlin block comments
+   * NEST, so a literal slash-star inside a KDoc opens a comment that is never closed and
+   * silently swallows the rest of the file. GifSupport's KDoc avoids it the same way.)
+   */
+  fun of(asset: CameraAsset): Format? {
+    fromMimeType(asset.mimeType)?.let { return it }
+    // An unrecognised but declared image type (e.g. image/x-adobe-dng) is a real image we
+    // simply do not special-case; do NOT let a misleading path extension override it.
+    if (asset.mimeType?.lowercase(Locale.US)?.startsWith("image/") == true) return null
+    return fromFileName(asset.fileName ?: asset.cachePath ?: asset.uri.path)
+  }
+
+  /**
+   * True when [mimeType] denotes any still image, including containers this registry does not
+   * enumerate. Used to widen MediaStore discovery: a row whose MEDIA_TYPE is wrong but whose
+   * MIME type says `image/…` is still an image the user expects to see.
+   */
+  fun isImageMimeType(mimeType: String?): Boolean =
+    mimeType?.lowercase(Locale.US)?.startsWith("image/") == true
+
+  /**
+   * True when this asset's container can carry per-pixel transparency, and so must not be
+   * decoded into RGB_565 (which would replace transparency with solid black).
+   *
+   * An unrecognised container answers false: RGB_565 is only ever an optimisation for known
+   * opaque formats, and JPEG — every camera capture and every extracted cover frame — is the
+   * overwhelmingly common case.
+   */
+  fun mayHaveAlpha(asset: CameraAsset): Boolean = of(asset)?.mayHaveAlpha == true
+
+  /**
+   * Whether this device's platform decoders can render [asset]'s pixels. Unknown/unlisted
+   * containers answer true — BitmapFactory supports more than this registry enumerates, and
+   * refusing to try would regress formats that work today.
+   */
+  fun isDecodable(asset: CameraAsset): Boolean = of(asset)?.isDecodable ?: true
+
+  /** The lower-cased extension of [name] without its dot, or null when it has none. */
+  private fun extensionOf(name: String?): String? {
+    if (name.isNullOrEmpty()) return null
+    // Strip any query/fragment so `…/file.avif?token=…` still resolves.
+    val path = name.substringBefore('?').substringBefore('#')
+    val segment = path.substringAfterLast('/', path)
+    val extension = segment.substringAfterLast('.', "")
+    return extension.lowercase(Locale.US).takeIf { it.isNotEmpty() }
+  }
+}

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

@@ -0,0 +1,206 @@
+package com.customcamera
+
+import android.content.Context
+import android.content.Intent
+import android.view.View
+import android.widget.TextView
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import org.json.JSONObject
+import java.util.Locale
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Every user-facing string, the text direction, and the active language for the
+ * native camera screens.
+ *
+ * The host app owns all of it. React Native pushes a flat key -> string map plus
+ * the active locale through `CustomCameraModule.setLocalization`; this object
+ * persists them so an Activity launched cold is already translated, and
+ * broadcasts [ACTION_LOCALIZATION_CHANGED] so screens that are already open
+ * re-render without a restart.
+ *
+ * The plugin never picks a language itself and ships no per-language resources:
+ * a missing key falls back to the English default passed at the call site.
+ */
+object Localization {
+    const val ACTION_LOCALIZATION_CHANGED = "com.customcamera.LOCALIZATION_CHANGED"
+
+    private const val PREFS_NAME = "CameraLocalization"
+    private const val KEY_TRANSLATIONS = "translations"
+    private const val KEY_IS_RTL = "isRtl"
+    private const val KEY_LOCALE = "locale"
+
+    private val translations = ConcurrentHashMap<String, String>()
+
+    var isRtl: Boolean = false
+        private set
+
+    /**
+     * The host app's active language as a BCP-47 tag ("fr", "pt-BR", "zh-Hans",
+     * "ar"), or empty when the host has not told us. Empty means "use the
+     * device locale", which is the best guess available.
+     */
+    var localeTag: String = ""
+        private set
+
+    @Volatile
+    private var resolvedLocale: Locale = Locale.getDefault()
+
+    /**
+     * The locale to format user-facing dates, file sizes and durations with, so
+     * that a Japanese UI does not show English month names and a French UI gets
+     * a comma decimal separator.
+     *
+     * Never use this to normalise machine-readable text (MIME types, file
+     * extensions, cache keys) — those must stay [Locale.US] or the Turkish
+     * dotless-i turns "IMAGE/JPEG" into something that no longer matches.
+     */
+    val locale: Locale
+        get() = resolvedLocale
+
+    fun init(context: Context) {
+        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        val jsonString = prefs.getString(KEY_TRANSLATIONS, "{}") ?: "{}"
+        isRtl = prefs.getBoolean(KEY_IS_RTL, false)
+        applyLocaleTag(prefs.getString(KEY_LOCALE, "") ?: "")
+
+        try {
+            val jsonObject = JSONObject(jsonString)
+            translations.clear()
+            val keys = jsonObject.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                translations[key] = jsonObject.getString(key)
+            }
+        } catch (e: Exception) {
+            // Ignore parsing errors, fall back to defaults
+        }
+    }
+
+    fun setTranslations(
+        context: Context,
+        map: Map<String, String>,
+        rtl: Boolean,
+        localeTag: String = "",
+    ) {
+        translations.clear()
+        translations.putAll(map)
+        isRtl = rtl
+        applyLocaleTag(localeTag)
+
+        val jsonObject = JSONObject()
+        for ((key, value) in map) {
+            jsonObject.put(key, value)
+        }
+
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putString(KEY_TRANSLATIONS, jsonObject.toString())
+            .putBoolean(KEY_IS_RTL, rtl)
+            .putString(KEY_LOCALE, this.localeTag)
+            .apply()
+
+        // Invalidate caches dependent on localization
+        EmojiPickerData.invalidateCache()
+        StickerPickerData.invalidateCache()
+
+        LocalBroadcastManager.getInstance(context).sendBroadcast(Intent(ACTION_LOCALIZATION_CHANGED))
+    }
+
+    fun getString(key: String, default: String, vararg args: Any): String {
+        var text = translations[key] ?: default
+        args.forEachIndexed { index, arg ->
+            text = text.replace("{$index}", arg.toString())
+        }
+        return text
+    }
+
+    /**
+     * [String.format] in the host app's language, for anything the user reads.
+     *
+     * Use instead of a bare `String.format` or a hardcoded [Locale.US]: it is
+     * what makes "1.5 MB" render as "1,5 MB" in French and switches digits in
+     * locales that use their own numerals.
+     */
+    fun format(format: String, vararg args: Any?): String =
+        String.format(locale, format, *args)
+
+    /**
+     * A measurement and its unit, both localized: the number picks up the host
+     * locale's digits and decimal separator, the unit comes from [unitKey] so a
+     * language that does not abbreviate "MB" as "MB" can override it.
+     *
+     * @param numberFormat a [String.format] spec for the number alone, e.g. `"%.1f"`.
+     */
+    fun formatUnit(unitKey: String, default: String, numberFormat: String, value: Double): String =
+        getString(unitKey, default, format(numberFormat, value))
+
+    /** [formatUnit] for a whole number, e.g. a raw byte count. */
+    fun formatUnit(unitKey: String, default: String, value: Long): String =
+        getString(unitKey, default, format("%d", value))
+
+    /**
+     * A [SimpleDateFormat] over the active language, using the host-overridable
+     * `dateFormatPattern` key. Month and weekday names follow [locale], so the
+     * pattern only needs overriding to change field order.
+     */
+    fun dateFormatter(): java.text.SimpleDateFormat =
+        java.text.SimpleDateFormat(
+            getString("dateFormatPattern", "MMM dd, yyyy"),
+            locale,
+        )
+
+    /** [View.LAYOUT_DIRECTION_RTL] or [View.LAYOUT_DIRECTION_LTR] for the active language. */
+    val layoutDirection: Int
+        get() = if (isRtl) View.LAYOUT_DIRECTION_RTL else View.LAYOUT_DIRECTION_LTR
+
+    /** Mirrors a view subtree to match the active language's direction. */
+    fun applyLayoutDirection(view: View?) {
+        view?.layoutDirection = layoutDirection
+    }
+
+    /**
+     * Mirrors a dialog to match the active language's direction.
+     *
+     * A dialog lives in its OWN window, and that window's decor view has no
+     * parent to inherit from — Android resolves its direction from
+     * `Locale.getDefault()`, i.e. the DEVICE language. So the direction set on
+     * the activity's root view does not reach it: an Arabic dialog on an
+     * English device would lay its title, message and buttons out
+     * left-to-right while the screen behind it is mirrored.
+     *
+     * Call this AFTER `show()` — the decor view does not exist before that.
+     */
+    fun applyDialogDirection(dialog: android.app.Dialog?) {
+        applyLayoutDirection(dialog?.window?.decorView)
+    }
+
+    /**
+     * Aligns text to the reading direction and lets the paragraph itself be
+     * mirrored, which matters for labels that mix Arabic with Latin file names.
+     */
+    fun applyTextDirection(view: TextView?) {
+        val target = view ?: return
+        target.textDirection =
+            if (isRtl) View.TEXT_DIRECTION_RTL else View.TEXT_DIRECTION_LTR
+        target.textAlignment = View.TEXT_ALIGNMENT_VIEW_START
+    }
+
+    private fun applyLocaleTag(tag: String) {
+        val trimmed = tag.trim()
+        localeTag = trimmed
+        resolvedLocale =
+            if (trimmed.isEmpty()) {
+                Locale.getDefault()
+            } else {
+                try {
+                    // Accepts "fr", "pt-BR" and "zh-Hans"; underscores are the
+                    // one spelling forLanguageTag rejects, so normalise them.
+                    val parsed = Locale.forLanguageTag(trimmed.replace('_', '-'))
+                    if (parsed.language.isEmpty()) Locale.getDefault() else parsed
+                } catch (e: Exception) {
+                    Locale.getDefault()
+                }
+            }
+    }
+}