react-native-ensys-camera-x 1.0.7

package/android/build.gradle

@@ -0,0 +1,135 @@
+buildscript {
+  ext.CustomCamera = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return CustomCamera[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.customcamera"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+
+    // Ship R8/ProGuard keep rules inside the AAR so any consuming app's release
+    // (minified) build automatically protects this library's native module, the
+    // React Native bridge entry points, and the Gson model classes. Without this,
+    // R8 in the consuming app can strip/rename them, crashing after capture and on
+    // relaunch (Gson upload-state recovery runs at startup).
+    consumerProguardFiles "consumer-rules.pro"
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  testOptions {
+    // The PowerPoint colour/geometry maths is deliberately written free of android.graphics so
+    // it can be verified on a bare JVM; no Robolectric or Android resources are needed.
+    unitTests.includeAndroidResources = false
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  // Test-only: never enters the AAR, so the library stays dependency-free for consumers.
+  testImplementation "junit:junit:4.13.2"
+
+  implementation "com.facebook.react:react-android"
+  implementation "androidx.activity:activity:1.9.3"
+  implementation "androidx.camera:camera-camera2:1.4.2"
+  implementation "androidx.camera:camera-lifecycle:1.4.2"
+  implementation "androidx.camera:camera-view:1.4.2"
+  implementation "androidx.camera:camera-video:1.4.2"
+  implementation "androidx.lifecycle:lifecycle-runtime:2.8.7"
+  implementation "androidx.recyclerview:recyclerview:1.4.0"
+  // Used directly by UploadService.kt (NotificationCompat/NotificationManagerCompat
+  // for the upload progress/success/failure notifications, and OkHttp for the
+  // multipart upload requests). These were previously resolved only transitively
+  // through react-android/androidx.camera; declaring them explicitly keeps the
+  // upload+notification feature from silently breaking if that transitive graph
+  // ever changes in a future dependency upgrade.
+  implementation "androidx.core:core:1.13.1"
+  implementation "com.squareup.okhttp3:okhttp:4.12.0"
+  // Gson for JSON serialization
+  implementation "com.google.code.gson:gson:2.10.1"
+
+  // Keystore-backed encrypted key storage for the SQLCipher database passphrase.
+  // Used by SecureKeyModule.kt (EncryptedSharedPreferences + MasterKey) so the
+  // database encryption key is generated on-device and sealed by the Android
+  // Keystore rather than shipped in the JS bundle.
+  implementation "androidx.security:security-crypto:1.1.0-alpha06"
+
+  // SQLCipher for the NATIVE compression cache (CompressionCacheStore.kt): a separate
+  // encrypted compression_cache.db, opened in Kotlin and keyed with the same
+  // Keystore-sealed passphrase SecureKeyModule mints for the JS media_secure.db.
+  //
+  // These are the EXACT coordinates the JS driver react-native-sqlcipher@0.0.4 already
+  // pulls into the app (classes net.sqlcipher.database.*). Matching them means Gradle
+  // resolves a single version — one libsqlcipher.so and no duplicate classes — so the
+  // app's existing packagingOptions.pickFirst for libcrypto/libssl/libc++_shared is all
+  // the packaging config needed. Do NOT bump to the newer `sqlcipher-android` artifact:
+  // a different coordinate would ship a second SQLCipher runtime and a risky .so pickFirst.
+  implementation "net.zetetic:android-database-sqlcipher:4.3.0@aar"
+  implementation "androidx.sqlite:sqlite:2.0.1"
+
+  // Image editing (text / stickers / emoji / brush / filters)
+  // NOTE: Updated to 3.1.0 to support Kotlin 2.0. The library package remains ja.burhanrashid52.photoeditor.*
+  // and exposes exactly the API this module uses (saveAsFile -> SaveFileResult, setFilterEffect,
+  // addText/addImage, clearAllViews, OnPhotoEditorListener, setClipSourceImage/setDeleteView).
+  api "com.burhanrashid52:photoeditor:3.1.0"
+  // Cropping
+  api "com.vanniktech:android-image-cropper:4.6.0"
+
+  // Barcode / QR scanning (BarcodeScannerActivity.kt). Bundled variant ships the
+  // detection model inside the app, so scanning works fully offline with no
+  // Google Play Services model download. Do NOT swap for the
+  // com.google.android.gms:play-services-mlkit-barcode-scanning variant, which
+  // downloads the model at runtime.
+  implementation "com.google.mlkit:barcode-scanning:17.3.0"
+  implementation "androidx.localbroadcastmanager:localbroadcastmanager:1.1.0"
+}

package/android/consumer-rules.pro

@@ -0,0 +1,47 @@
+# ============================================================================
+# Consumer R8 / ProGuard rules for react-native-custom-camera
+#
+# These rules are packaged INSIDE the published AAR (via `consumerProguardFiles`
+# in android/build.gradle) and are automatically applied by R8 in any app that
+# consumes this library. The library itself is not minified (an AAR ships plain
+# bytecode); the CONSUMING app's release build is what runs R8, so this file is
+# the only place the library can protect its own classes there.
+#
+# Without these rules, a release build with minify enabled can strip or rename
+# the classes this library reaches reflectively (the React Native bridge) or
+# reflectively (de)serializes (Gson) — which crashes after capture and, because
+# upload-state recovery runs in Activity.onCreate, on app relaunch.
+# ============================================================================
+
+# --- This library's own classes -------------------------------------------
+# The native module, ReactPackage, view manager, Activity, foreground Service
+# and the Gson model classes are entry points reached from React Native, the
+# Android manifest, or Gson reflection. Keeping the (small) package intact — and
+# unobfuscated — guarantees all of those survive minification in the consuming
+# app. Both rules are needed: -keep protects the classes, -keepclassmembers
+# protects fields/methods (Gson maps JSON keys to field names by reflection).
+-keep class com.customcamera.** { *; }
+-keepclassmembers class com.customcamera.** { *; }
+
+# --- Gson reflective (de)serialization ------------------------------------
+# UploadService.UploadState (has a List<String> field) and NotificationHistoryItem
+# are (de)serialized via Gson — UploadState at startup in recoverUploadStateIfNeeded().
+# Gson needs the generic Signature to reconstruct parameterized types like
+# List<String>, and the annotation/inner-class attributes to resolve the nested
+# model classes. The models themselves are already covered by the com.customcamera.**
+# keep above; these attributes are the missing piece R8 would otherwise drop.
+-keepattributes Signature,*Annotation*,EnclosingMethod,InnerClasses
+
+# --- React Native bridge reflection (defensive) ---------------------------
+# React Native invokes @ReactMethod / @ReactProp members and instantiates
+# @ReactModule classes by reflection. React Native ships its own keep rules for
+# these, but declaring them here keeps this library self-contained across RN
+# versions and consuming-app configurations.
+-keepclassmembers,allowobfuscation class * {
+    @com.facebook.react.bridge.ReactMethod <methods>;
+}
+-keep,allowobfuscation @com.facebook.react.module.annotations.ReactModule class * { *; }
+-keepclassmembers,allowobfuscation class * {
+    @com.facebook.react.uimanager.annotations.ReactProp <methods>;
+    @com.facebook.react.uimanager.annotations.ReactPropGroup <methods>;
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,72 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Every runtime permission below is requested JUST-IN-TIME by the feature that needs it
+       (see CustomCameraActivity); declaring one here never means it is asked for at launch. -->
+
+  <!-- Requested when the camera opens — the ONLY permission the camera launch asks for. -->
+  <uses-permission android:name="android.permission.CAMERA" />
+  <!-- Requested when the first video recording starts (a denial records a silent clip). -->
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <!-- Requested when the user first opens the gallery (bottom-left thumbnail / swipe up). -->
+  <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
+  <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+  <!-- Requested on demand when the gallery's "Audio" filter is first selected (Android 13+). -->
+  <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
+  <!-- Never requested directly: it is the system's "selected photos" outcome of the media
+       request above, and is accepted as partial gallery access. -->
+  <uses-permission android:name="android.permission.READ_MEDIA_VISUAL_USER_SELECTED" />
+  <!-- Pre-Android 13 form of the same on-demand gallery request. -->
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+  <!-- Install-time (normal) permission, no runtime prompt. Used by the in-editor GIF picker to
+       fetch GIFs from the configured provider (GIPHY/Tenor). The picker degrades to a "no
+       connection" state when offline; nothing else in the plugin performs network I/O at launch. -->
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <!-- TEMPORARILY DISABLED: system upload notifications are replaced by the in-app
+       progress banner ("onUploadProgress" events from UploadService). To re-enable,
+       uncomment this AND flip UploadService.SYSTEM_NOTIFICATIONS_ENABLED to true.
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  -->
+
+  <uses-feature android:name="android.hardware.camera.any" android:required="false" />
+
+  <queries>
+    <intent>
+      <action android:name="android.media.action.IMAGE_CAPTURE" />
+    </intent>
+  </queries>
+
+  <application>
+    <activity
+      android:name=".CustomCameraActivity"
+      android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+      android:exported="false"
+      android:screenOrientation="portrait"
+      android:theme="@android:style/Theme.Material.NoActionBar.Fullscreen" />
+
+    <activity
+      android:name=".BarcodeScannerActivity"
+      android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+      android:exported="false"
+      android:screenOrientation="portrait"
+      android:theme="@android:style/Theme.Material.NoActionBar.Fullscreen" />
+
+    <service
+      android:name=".UploadService"
+      android:foregroundServiceType="dataSync"
+      android:exported="false" />
+
+    <!-- Exposes edited/shared media files via content:// URIs for sharing and result returns -->
+    <provider
+      android:name=".CustomCameraFileProvider"
+      android:authorities="${applicationId}.camera.fileprovider"
+      android:exported="false"
+      android:grantUriPermissions="true">
+      <meta-data
+        android:name="android.support.FILE_PROVIDER_PATHS"
+        android:resource="@xml/file_paths" />
+    </provider>
+  </application>
+</manifest>

package/android/src/main/java/android/print/PdfPrint.java

@@ -0,0 +1,51 @@
+package android.print;
+
+import android.os.CancellationSignal;
+import android.os.ParcelFileDescriptor;
+
+public class PdfPrint {
+
+    public interface PdfPrintCallback {
+        void onSuccess();
+        void onFailure(String error);
+    }
+
+    public static void print(final PrintDocumentAdapter adapter, final PrintAttributes attributes, final ParcelFileDescriptor fd, final CancellationSignal signal, final PdfPrintCallback callback) {
+        adapter.onLayout(null, attributes, null, new PrintDocumentAdapter.LayoutResultCallback() {
+            @Override
+            public void onLayoutFinished(PrintDocumentInfo info, boolean changed) {
+                adapter.onWrite(
+                        new PageRange[]{PageRange.ALL_PAGES},
+                        fd,
+                        signal,
+                        new PrintDocumentAdapter.WriteResultCallback() {
+                            @Override
+                            public void onWriteFinished(PageRange[] pages) {
+                                callback.onSuccess();
+                            }
+
+                            @Override
+                            public void onWriteFailed(CharSequence error) {
+                                callback.onFailure(error != null ? error.toString() : "Write failed");
+                            }
+
+                            @Override
+                            public void onWriteCancelled() {
+                                callback.onFailure("Write cancelled");
+                            }
+                        }
+                );
+            }
+
+            @Override
+            public void onLayoutFailed(CharSequence error) {
+                callback.onFailure(error != null ? error.toString() : "Layout failed");
+            }
+
+            @Override
+            public void onLayoutCancelled() {
+                callback.onFailure("Layout cancelled");
+            }
+        }, null);
+    }
+}

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

@@ -0,0 +1,199 @@
+package com.customcamera
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.ImageDecoder
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.widget.ImageView
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import java.io.File
+import java.util.concurrent.Executors
+
+/**
+ * ReactNative view manager for animated images (GIF) in the full-screen media viewer.
+ *
+ * ReactNative's own `<Image>` renders only a static first frame for a GIF on Android unless the
+ * host app adds Fresco's `animated-gif` decoder — a dependency every consumer of this library
+ * would have to add for themselves. Decoding here instead keeps the AAR dependency-free and
+ * makes animation work out of the box for every consumer.
+ *
+ * Mirrors [NativeVideoViewManager]'s prop contract exactly, because the viewer drives both the
+ * same way: `src` with a same-src guard so a recycled FlatList cell never shows the previous
+ * item, and `active` so only the currently-visible page animates.
+ */
+class AnimatedImageViewManager : SimpleViewManager<AnimatedImageView>() {
+  override fun getName() = "NativeAnimatedImageView"
+
+  override fun createViewInstance(reactContext: ThemedReactContext): AnimatedImageView =
+    AnimatedImageView(reactContext)
+
+  override fun onDropViewInstance(view: AnimatedImageView) {
+    view.release()
+    super.onDropViewInstance(view)
+  }
+
+  @ReactProp(name = "src")
+  fun setSrc(view: AnimatedImageView, src: String?) {
+    view.setSource(src)
+  }
+
+  /**
+   * Whether this slide is the currently-visible page. Deactivating stops the animation and
+   * leaves the frame it stopped on, so an off-screen or recycled cell never burns CPU
+   * animating something the user cannot see.
+   *
+   * Defaults to true so a single-image consumer that never sets it just animates.
+   */
+  @ReactProp(name = "active", defaultBoolean = true)
+  fun setActive(view: AnimatedImageView, active: Boolean) {
+    view.setActive(active)
+  }
+
+  /** `contain` (default) or `cover`, matching the `resizeMode` names used on the JS side. */
+  @ReactProp(name = "resizeMode")
+  fun setResizeMode(view: AnimatedImageView, resizeMode: String?) {
+    view.setResizeMode(resizeMode)
+  }
+}
+
+/**
+ * An [ImageView] that decodes and plays an animated image, falling back to a static first
+ * frame wherever animation is unavailable.
+ *
+ * [ImageDecoder] and `AnimatedImageDrawable` are API 28+. This library's minSdk is 24, so on
+ * API 24-27 the view decodes the first frame with BitmapFactory — the same frame the grid and
+ * strip thumbnails already show. The image is still displayed correctly and the underlying
+ * file is untouched either way; only the animation is absent on those versions.
+ */
+class AnimatedImageView(context: Context) : ImageView(context) {
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  // Decoding reads and inflates a whole animated image, which must never run on the main
+  // thread during a swipe. A single-thread executor also serialises decodes, so a fast swipe
+  // through several slides can't run N decodes in parallel and spike memory.
+  private val decodeExecutor = Executors.newSingleThreadExecutor()
+
+  private var currentSrc: String? = null
+  private var isActive = true
+
+  /**
+   * Incremented on every source change. A decode that finishes after its source has been
+   * replaced (fast swipe, cell recycled) compares its captured value against this and drops
+   * its result instead of painting the wrong image into the cell.
+   */
+  private var decodeGeneration = 0
+
+  init {
+    scaleType = ScaleType.FIT_CENTER
+  }
+
+  fun setSource(src: String?) {
+    if (src == currentSrc) return
+    currentSrc = src
+    decodeGeneration++
+    val generation = decodeGeneration
+
+    stopAnimation()
+    setImageDrawable(null)
+
+    if (src.isNullOrEmpty()) return
+
+    decodeExecutor.execute {
+      val drawable = decode(src)
+      mainHandler.post {
+        if (generation != decodeGeneration) {
+          // A newer source won the race — discard this result rather than flashing it.
+          return@post
+        }
+        if (drawable == null) return@post
+        setImageDrawable(drawable)
+        if (isActive) startAnimation()
+      }
+    }
+  }
+
+  fun setActive(active: Boolean) {
+    if (isActive == active) return
+    isActive = active
+    if (active) startAnimation() else stopAnimation()
+  }
+
+  fun setResizeMode(resizeMode: String?) {
+    scaleType = if (resizeMode == "cover") ScaleType.CENTER_CROP else ScaleType.FIT_CENTER
+  }
+
+  /** Stop animating and drop the decoded frames; called when ReactNative discards the view. */
+  fun release() {
+    decodeGeneration++
+    stopAnimation()
+    setImageDrawable(null)
+    decodeExecutor.shutdownNow()
+  }
+
+  override fun onDetachedFromWindow() {
+    stopAnimation()
+    super.onDetachedFromWindow()
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    if (isActive) startAnimation()
+  }
+
+  private fun startAnimation() {
+    (drawable as? Animatable)?.let { if (!it.isRunning) it.start() }
+  }
+
+  private fun stopAnimation() {
+    (drawable as? Animatable)?.let { if (it.isRunning) it.stop() }
+  }
+
+  /**
+   * Decode [src] into an animated drawable where the platform supports it, else a static
+   * first-frame bitmap drawable. Any failure returns null and leaves the cell empty rather
+   * than crashing the viewer.
+   */
+  private fun decode(src: String): Drawable? {
+    val uri = runCatching { Uri.parse(src) }.getOrNull() ?: return null
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      runCatching {
+        val source = imageDecoderSource(uri) ?: return@runCatching null
+        ImageDecoder.decodeDrawable(source)
+      }.getOrNull()?.let { return it }
+    }
+
+    return decodeStaticFrame(uri)?.let { android.graphics.drawable.BitmapDrawable(resources, it) }
+  }
+
+  @androidx.annotation.RequiresApi(Build.VERSION_CODES.P)
+  private fun imageDecoderSource(uri: Uri): ImageDecoder.Source? {
+    // A plain path or file:// URI is read directly; going through the resolver for a file the
+    // app already owns would only add an IPC round trip.
+    val path = if (uri.scheme == null || uri.scheme == "file") uri.path else null
+    if (path != null) {
+      val file = File(path)
+      if (file.exists()) return ImageDecoder.createSource(file)
+    }
+    return ImageDecoder.createSource(context.contentResolver, uri)
+  }
+
+  private fun decodeStaticFrame(uri: Uri): Bitmap? =
+    runCatching {
+      val path = if (uri.scheme == null || uri.scheme == "file") uri.path else null
+      if (path != null && File(path).exists()) {
+        return@runCatching BitmapFactory.decodeFile(path)
+      }
+      context.contentResolver.openInputStream(uri)?.use { stream ->
+        BitmapFactory.decodeStream(stream)
+      }
+    }.getOrNull()
+}