react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,215 @@
+package com.customcamera
+
+import android.content.Context
+import android.net.Uri
+import java.io.File
+import java.io.InputStream
+import java.util.Locale
+
+/**
+ * Single source of truth for "is this a GIF, and does it actually animate".
+ *
+ * The codebase already carries several independent extension/MIME tables (ThumbnailLoader's
+ * alpha-capable set, MediaCacheManager.MediaFormat, MediaPublisher.getMimeType,
+ * MediaPreviewEditor.mediaExtension). Those each answer a different question and are left
+ * alone; this object exists so the GIF-specific decisions — badge, animated playback,
+ * flatten-confirmation — all read the same answer instead of adding a fifth drifting list.
+ *
+ * Detection uses BOTH signals required of it: the declared MIME type first, then the file
+ * extension. The precedence mirrors [ThumbnailLoader.mayHaveAlphaChannel] so the two never
+ * disagree about the same file.
+ */
+object GifSupport {
+  private const val MIME_GIF = "image/gif"
+  private const val EXTENSION_GIF = "gif"
+
+  /**
+   * How far into the file [isAnimated] is willing to read looking for a second frame. An
+   * animated GIF's second Image Descriptor almost always lands within the first frame's
+   * compressed data, so a bounded read answers the question without loading a large file into
+   * memory on the main path.
+   */
+  private const val ANIMATION_SCAN_LIMIT_BYTES = 256 * 1024
+
+  /** `GIF87a` / `GIF89a` — the two legal GIF signatures, as raw header bytes. */
+  private val SIGNATURE_87A = "GIF87a".toByteArray(Charsets.US_ASCII)
+  private val SIGNATURE_89A = "GIF89a".toByteArray(Charsets.US_ASCII)
+
+  /**
+   * True when [asset] is a GIF, judged by its declared MIME type first and its file name /
+   * path extension second.
+   *
+   * A declared, recognised `image/` type is authoritative — an asset that says it is
+   * `image/jpeg` is not reclassified as a GIF just because something in its path ends in
+   * `.gif`. Only an absent or non-image MIME type falls through to the extension, which is
+   * what rescues assets that arrived from a provider reporting no type at all.
+   */
+  fun isGif(asset: CameraAsset): Boolean {
+    asset.mimeType?.lowercase(Locale.US)?.let { mime ->
+      if (mime == MIME_GIF) return true
+      if (mime.startsWith("image/")) return false
+    }
+    val name = asset.fileName ?: asset.cachePath ?: asset.uri.path ?: return false
+    return extensionOf(name) == EXTENSION_GIF
+  }
+
+  /**
+   * URI-only overload for call sites that hold no [CameraAsset] — resolves the MIME type
+   * through the ContentResolver (which reads the provider's own record) before falling back
+   * to the path extension.
+   */
+  fun isGif(context: Context, uri: Uri?): Boolean {
+    if (uri == null) return false
+    val declared = runCatching { context.contentResolver.getType(uri) }
+      .getOrNull()
+      ?.lowercase(Locale.US)
+    if (declared == MIME_GIF) return true
+    if (declared != null && declared.startsWith("image/")) return false
+    return extensionOf(uri.path ?: return false) == EXTENSION_GIF
+  }
+
+  /** True when [data] starts with a GIF signature, regardless of what it claims to be. */
+  fun hasGifSignature(data: ByteArray): Boolean =
+    startsWith(data, SIGNATURE_87A) || startsWith(data, SIGNATURE_89A)
+
+  /**
+   * True when [file] is a GIF holding more than one frame.
+   *
+   * A single-frame `.gif` is, for every purpose here, an ordinary still image: it can be
+   * edited and exported without losing anything, so it must NOT trigger the
+   * convert-to-image confirmation. Only a genuinely animated GIF has animation to lose.
+   *
+   * Failure to parse returns true — the safe direction. Treating an unreadable GIF as
+   * animated means the user is asked before it is flattened; the opposite default would
+   * destroy animation silently, which is exactly what this is here to prevent.
+   */
+  fun isAnimated(file: File): Boolean =
+    runCatching {
+      if (!file.exists() || file.length() < SIGNATURE_87A.size) return false
+      file.inputStream().use { readIsAnimated(it) }
+    }.getOrDefault(true)
+
+  /** [isAnimated] for content:// sources, reading through the resolver. */
+  fun isAnimated(context: Context, uri: Uri): Boolean =
+    runCatching {
+      context.contentResolver.openInputStream(uri)?.use { readIsAnimated(it) } ?: true
+    }.getOrDefault(true)
+
+  /**
+   * Walks the GIF block structure looking for a SECOND Image Descriptor (0x2C).
+   *
+   * A GIF is a header + Logical Screen Descriptor + optional Global Color Table, followed by
+   * a stream of blocks. Each frame is introduced by an Image Descriptor; extension blocks
+   * (0x21) and the trailer (0x3B) sit between them. Counting descriptors is therefore an
+   * exact frame count — far more reliable than looking for a Netscape looping extension,
+   * which plenty of animated GIFs omit.
+   *
+   * Bails out (returning false) once [ANIMATION_SCAN_LIMIT_BYTES] is consumed: a file whose
+   * first frame alone exceeds that is large enough that walking the rest would cost more than
+   * the answer is worth on a scroll or send path.
+   */
+  private fun readIsAnimated(stream: InputStream): Boolean {
+    val header = ByteArray(6)
+    if (stream.read(header) != header.size) return false
+    if (!hasGifSignature(header)) return false
+
+    // Logical Screen Descriptor: width(2) height(2) packed(1) bgIndex(1) aspect(1).
+    val screen = ByteArray(7)
+    if (stream.read(screen) != screen.size) return false
+    val packed = screen[4].toInt() and 0xFF
+    if (packed and 0x80 != 0) {
+      // Global Color Table present: 3 bytes per entry, 2^(N+1) entries.
+      val entries = 1 shl ((packed and 0x07) + 1)
+      if (!skipFully(stream, entries * 3)) return false
+    }
+
+    var consumed = header.size + screen.size
+    var imageDescriptors = 0
+    while (consumed < ANIMATION_SCAN_LIMIT_BYTES) {
+      val block = stream.read()
+      if (block < 0) return false
+      consumed++
+      when (block) {
+        0x2C -> {
+          // Image Descriptor: left(2) top(2) width(2) height(2) packed(1).
+          imageDescriptors++
+          if (imageDescriptors > 1) return true
+          val descriptor = ByteArray(9)
+          if (stream.read(descriptor) != descriptor.size) return false
+          consumed += descriptor.size
+          val localPacked = descriptor[8].toInt() and 0xFF
+          if (localPacked and 0x80 != 0) {
+            val entries = 1 shl ((localPacked and 0x07) + 1)
+            if (!skipFully(stream, entries * 3)) return false
+            consumed += entries * 3
+          }
+          // LZW minimum code size, then the frame's data sub-blocks.
+          if (stream.read() < 0) return false
+          consumed++
+          consumed += skipSubBlocks(stream) ?: return false
+        }
+        0x21 -> {
+          // Extension block: one label byte, then data sub-blocks.
+          if (stream.read() < 0) return false
+          consumed++
+          consumed += skipSubBlocks(stream) ?: return false
+        }
+        // Trailer — end of file reached with at most one frame.
+        0x3B -> return false
+        // Anything else means the stream is not a GIF we can walk; stop rather than guess.
+        else -> return false
+      }
+    }
+    return false
+  }
+
+  /**
+   * Skips a chain of GIF data sub-blocks (each a length byte followed by that many bytes,
+   * terminated by a zero-length block). Returns the number of bytes consumed, or null if the
+   * stream ended mid-chain.
+   */
+  private fun skipSubBlocks(stream: InputStream): Int? {
+    var consumed = 0
+    while (true) {
+      val size = stream.read()
+      if (size < 0) return null
+      consumed++
+      if (size == 0) return consumed
+      if (!skipFully(stream, size)) return null
+      consumed += size
+    }
+  }
+
+  /**
+   * [InputStream.skip] is permitted to skip fewer bytes than asked without being at the end
+   * of the stream, so a single call is not enough to keep the block walk aligned.
+   */
+  private fun skipFully(stream: InputStream, count: Int): Boolean {
+    var remaining = count.toLong()
+    while (remaining > 0) {
+      val skipped = stream.skip(remaining)
+      if (skipped <= 0) {
+        // skip() made no progress — fall back to a read to distinguish "end of stream" from
+        // "this stream just doesn't implement skip".
+        if (stream.read() < 0) return false
+        remaining--
+      } else {
+        remaining -= skipped
+      }
+    }
+    return true
+  }
+
+  private fun extensionOf(path: String): String =
+    path.substringAfterLast('/', path)
+      .substringAfterLast('.', "")
+      .lowercase(Locale.US)
+
+  private fun startsWith(data: ByteArray, signature: ByteArray): Boolean {
+    if (data.size < signature.size) return false
+    for (i in signature.indices) {
+      if (data[i] != signature[i]) return false
+    }
+    return true
+  }
+}

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

@@ -0,0 +1,320 @@
+package com.customcamera
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+object GlobalAudioPlayer {
+    var mediaPlayer: MediaPlayer? = null
+    var currentUri: Uri? = null
+    var currentTitle: String = ""
+    var prepared = false
+    var playbackActive = false
+    private val mainHandler = Handler(Looper.getMainLooper())
+    var reactContext: ReactApplicationContext? = null
+
+    val listeners = mutableSetOf<Listener>()
+
+    // ------------------------------------------------------------------
+    // Audio focus — the platform mechanism for call/interruption handling
+    // ------------------------------------------------------------------
+    // An incoming or outgoing phone call (telephony ring, in-call audio, and VoIP apps
+    // alike) takes TRANSIENT audio focus and returns it when the call ends. Participating
+    // in audio focus is therefore the root-cause fix for "audio keeps playing during a
+    // call": on transient loss we pause and remember the intent to resume; on regain we
+    // resume from the exact paused position (MediaPlayer.pause() preserves it). The same
+    // listener also handles every other interruption class correctly: permanent loss
+    // (another media app starts) pauses without auto-resume, and duck requests
+    // (navigation prompts, notifications) just lower the volume.
+
+    private const val DUCK_VOLUME = 0.2f
+
+    private var audioManager: AudioManager? = null
+    private var focusRequest: AudioFocusRequest? = null // API 26+
+    private var hasAudioFocus = false
+    // True only when WE paused because of a transient focus loss (call). A user-initiated
+    // pause clears it, so pausing manually during a call never auto-resumes afterwards.
+    private var resumeOnFocusGain = false
+
+    private val playbackAttributes: AudioAttributes = AudioAttributes.Builder()
+        .setUsage(AudioAttributes.USAGE_MEDIA)
+        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+        .build()
+
+    private val focusChangeListener = AudioManager.OnAudioFocusChangeListener { change ->
+        // Serialize with all other player mutations on the main thread.
+        mainHandler.post {
+            when (change) {
+                AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                    // Call ringing / in progress (or similar short interruption): pause,
+                    // keep our focus request registered, and resume when focus returns.
+                    if (playbackActive) {
+                        resumeOnFocusGain = true
+                        pauseInternal(fromFocusLoss = true)
+                    }
+                }
+                AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                    // Short prompt where we may keep playing quietly. Only delivered on
+                    // pre-O devices — on O+ the system ducks automatically without a
+                    // callback because the focus request doesn't opt out of auto-duck.
+                    try { mediaPlayer?.setVolume(DUCK_VOLUME, DUCK_VOLUME) } catch (_: Exception) {}
+                }
+                AudioManager.AUDIOFOCUS_LOSS -> {
+                    // Permanent loss (another app started media playback): pause and give
+                    // up focus. Standard platform behavior is to NOT auto-resume here.
+                    resumeOnFocusGain = false
+                    if (playbackActive) {
+                        pauseInternal(fromFocusLoss = false)
+                    } else {
+                        abandonAudioFocus()
+                    }
+                }
+                AudioManager.AUDIOFOCUS_GAIN -> {
+                    // Interruption over: restore full volume and, if the interruption is
+                    // what paused us (call ended), resume from the preserved position.
+                    try { mediaPlayer?.setVolume(1f, 1f) } catch (_: Exception) {}
+                    if (resumeOnFocusGain) {
+                        resumeOnFocusGain = false
+                        resume()
+                    }
+                }
+            }
+        }
+    }
+
+    /** Lazily bind the AudioManager from any available context. */
+    private fun ensureAudioManager(context: Context?): AudioManager? {
+        audioManager?.let { return it }
+        val appContext = context?.applicationContext ?: reactContext?.applicationContext
+        audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+        return audioManager
+    }
+
+    /**
+     * Request audio focus before starting playback. Returns true when playback may start.
+     * Degrades gracefully: if no AudioManager can be resolved, playback proceeds exactly
+     * as it did before this feature existed.
+     */
+    private fun requestAudioFocus(): Boolean {
+        if (hasAudioFocus) return true
+        val am = ensureAudioManager(null) ?: return true
+        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val request = focusRequest ?: AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                .setAudioAttributes(playbackAttributes)
+                .setOnAudioFocusChangeListener(focusChangeListener, mainHandler)
+                .build()
+                .also { focusRequest = it }
+            am.requestAudioFocus(request)
+        } else {
+            @Suppress("DEPRECATION")
+            am.requestAudioFocus(
+                focusChangeListener,
+                AudioManager.STREAM_MUSIC,
+                AudioManager.AUDIOFOCUS_GAIN
+            )
+        }
+        hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+        return hasAudioFocus
+    }
+
+    private fun abandonAudioFocus() {
+        resumeOnFocusGain = false
+        if (!hasAudioFocus) return
+        hasAudioFocus = false
+        val am = audioManager ?: return
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                focusRequest?.let { am.abandonAudioFocusRequest(it) }
+            } else {
+                @Suppress("DEPRECATION")
+                am.abandonAudioFocus(focusChangeListener)
+            }
+        } catch (_: Exception) {}
+    }
+
+    interface Listener {
+        fun onProgressChanged(position: Int, duration: Int)
+        fun onStateChanged(isPlaying: Boolean, prepared: Boolean)
+        fun onSourceChanged(uri: Uri?)
+        fun onCompletion()
+    }
+
+    private val progressUpdater = object : Runnable {
+        override fun run() {
+            val mp = mediaPlayer
+            if (mp != null && prepared) {
+                val duration = try { mp.duration } catch (e: Exception) { 0 }
+                val pos = try { mp.currentPosition } catch (e: Exception) { 0 }
+                if (duration > 0) {
+                    listeners.forEach { it.onProgressChanged(pos, duration) }
+                    
+                    reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        ?.emit("onAudioProgress", Arguments.createMap().apply {
+                            putInt("position", pos)
+                            putInt("duration", duration)
+                        })
+                }
+            }
+            if (playbackActive) mainHandler.postDelayed(this, 250)
+        }
+    }
+
+    fun play(context: Context, uri: Uri?, title: String) {
+        if (uri == null) return
+        // Bind the AudioManager while a context is guaranteed available, so focus
+        // requests/abandons never depend on the React context being set.
+        ensureAudioManager(context)
+        if (uri == currentUri) {
+            resume()
+            return
+        }
+        release()
+        currentUri = uri
+        currentTitle = title
+        prepared = false
+        listeners.forEach { it.onSourceChanged(uri) }
+
+        mediaPlayer = MediaPlayer().apply {
+            setAudioAttributes(playbackAttributes)
+            setOnPreparedListener { mp ->
+                prepared = true
+                listeners.forEach { it.onStateChanged(playbackActive, prepared) }
+                
+                // Emitting the new audio state
+                reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.emit("onAudioStateChange", Arguments.createMap().apply {
+                        putBoolean("isPlaying", playbackActive)
+                        putString("uri", uri.toString())
+                        putString("title", title)
+                        putInt("duration", mp.duration)
+                    })
+            }
+            setOnCompletionListener { mp ->
+                playbackActive = false
+                // Track finished naturally — nothing left to interrupt, so release focus
+                // (and any pending call-resume intent) back to the system.
+                abandonAudioFocus()
+                listeners.forEach { it.onCompletion() }
+                mainHandler.removeCallbacks(progressUpdater)
+                try { mp.seekTo(0) } catch (e: Exception) {}
+                
+                reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.emit("onAudioStateChange", Arguments.createMap().apply {
+                        putBoolean("isPlaying", false)
+                        putBoolean("didComplete", true)
+                    })
+            }
+            setOnErrorListener { _, _, _ -> true }
+            try {
+                setDataSource(context, uri)
+                prepareAsync()
+            } catch (e: Exception) {
+            }
+        }
+    }
+
+    fun resume() {
+        val mp = mediaPlayer ?: return
+        // Every start goes through here (resume() is the only mp.start() call site), so
+        // this is the single choke point for acquiring audio focus. If the system denies
+        // focus (e.g. a call is literally in progress), do not start — the player stays
+        // paused at its current position and the UI keeps showing the play button.
+        if (!requestAudioFocus()) return
+        try {
+            mp.setVolume(1f, 1f) // clear any duck applied during an interruption
+            mp.start()
+            playbackActive = true
+            listeners.forEach { it.onStateChanged(playbackActive, prepared) }
+            mainHandler.post(progressUpdater)
+
+            reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit("onAudioStateChange", Arguments.createMap().apply {
+                    putBoolean("isPlaying", true)
+                    currentUri?.let { putString("uri", it.toString()) }
+                })
+        } catch (e: Exception) {}
+    }
+
+    fun pause() {
+        // Explicit (user/JS-initiated) pause: cancel any pending call-interruption
+        // auto-resume — if the user pauses during a call, the end of the call must not
+        // restart playback behind their back.
+        resumeOnFocusGain = false
+        pauseInternal(fromFocusLoss = false)
+    }
+
+    /**
+     * Shared pause path. [fromFocusLoss] true = a transient interruption (call) paused
+     * us, so keep the focus request registered — that's what makes the system deliver
+     * AUDIOFOCUS_GAIN when the call ends, driving the auto-resume. False = a deliberate
+     * stop; release focus so other apps get clean gain events.
+     */
+    private fun pauseInternal(fromFocusLoss: Boolean) {
+        val mp = mediaPlayer ?: return
+        try {
+            if (mp.isPlaying) mp.pause()
+        } catch (e: Exception) {}
+        playbackActive = false
+        if (!fromFocusLoss) abandonAudioFocus()
+        listeners.forEach { it.onStateChanged(playbackActive, prepared) }
+        mainHandler.removeCallbacks(progressUpdater)
+
+        reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit("onAudioStateChange", Arguments.createMap().apply {
+                putBoolean("isPlaying", false)
+                currentUri?.let { putString("uri", it.toString()) }
+            })
+    }
+    
+    fun togglePlayback() {
+        if (playbackActive) pause() else resume()
+    }
+
+    fun seekTo(positionMs: Int) {
+        val mp = mediaPlayer ?: return
+        if (!prepared) return
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                mp.seekTo(positionMs.toLong(), MediaPlayer.SEEK_CLOSEST)
+            } else {
+                mp.seekTo(positionMs)
+            }
+            val duration = mp.duration
+            listeners.forEach { it.onProgressChanged(positionMs, duration) }
+            
+            reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                ?.emit("onAudioProgress", Arguments.createMap().apply {
+                    putInt("position", positionMs)
+                    putInt("duration", duration)
+                })
+        } catch (e: Exception) {}
+    }
+
+    fun release() {
+        mainHandler.removeCallbacks(progressUpdater)
+        playbackActive = false
+        prepared = false
+        abandonAudioFocus()
+        mediaPlayer?.let { mp ->
+            try { mp.stop() } catch (e: Exception) {}
+            try { mp.reset() } catch (e: Exception) {}
+            mp.release()
+        }
+        mediaPlayer = null
+        currentUri = null
+        currentTitle = ""
+        listeners.forEach { it.onSourceChanged(null) }
+        
+        reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit("onAudioClose", Arguments.createMap())
+    }
+}