@dariyd/react-native-document-scanner 2.0.13

package/android/build.gradle

@@ -0,0 +1,182 @@
+// android/build.gradle
+
+// based on:
+//
+// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
+//   previous location:
+//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/build.gradle
+//
+// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
+//   previous location:
+//   - https://github.com/facebook/react-native/blob/0.58-stable/local-cli/templates/HelloWorld/android/app/build.gradle
+
+// These defaults should reflect the SDK versions used by
+// the minimum React Native version supported.
+def DEFAULT_COMPILE_SDK_VERSION = 35
+def DEFAULT_BUILD_TOOLS_VERSION = '35.0.0'
+def DEFAULT_MIN_SDK_VERSION = 21
+def DEFAULT_TARGET_SDK_VERSION = 35
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'maven-publish'
+// Needed so RN Gradle plugin can run codegen for this library when newArchEnabled=true in the app
+apply plugin: 'com.facebook.react'
+
+buildscript {
+    // The Android Gradle plugin is only required when opening the android folder stand-alone.
+    // This avoids unnecessary downloads and potential conflicts when the library is included as a
+    // module dependency in an application project.
+    // ref: https://docs.gradle.org/current/userguide/tutorial_using_tasks.html#sec:build_script_external_dependencies
+    if (project == rootProject) {
+        repositories {
+            google()
+        }
+        dependencies {
+            // This should reflect the Gradle plugin version used by
+            // the minimum React Native version supported.
+            classpath 'com.android.tools.build:gradle:3.4.1'
+        }
+    }
+}
+
+android {
+    namespace "com.docscanner"
+    compileSdkVersion safeExtGet('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
+    buildToolsVersion safeExtGet('buildToolsVersion', DEFAULT_BUILD_TOOLS_VERSION)
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
+        targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
+        versionCode 1
+        versionName "1.0"
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", (findProperty("newArchEnabled") ?: "false")
+    }
+    
+    lintOptions {
+        abortOnError false
+    }
+}
+
+// Configure React Native codegen for this library
+react {
+    libraryName = "RNDocumentScannerSpec"
+    codegenJavaPackageName = "com.docscanner"
+}
+
+repositories {
+    // ref: https://www.baeldung.com/maven-local-repository
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$rootDir/../node_modules/react-native/android"
+    }
+    maven {
+        // Android JSC is installed from npm
+        url "$rootDir/../node_modules/jsc-android/dist"
+    }
+    google()
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+'  // From node_modules
+    implementation 'com.google.android.gms:play-services-mlkit-document-scanner:16.0.0-beta1'
+}
+
+afterEvaluate { project ->
+    // some Gradle build hooks ref:
+    // https://www.oreilly.com/library/view/gradle-beyond-the/9781449373801/ch03.html
+    task androidJavadoc(type: Javadoc) {
+        source = android.sourceSets.main.java.srcDirs
+        classpath += files(android.bootClasspath)
+        // Use a resolvable configuration when available; on some AGP setups
+        // (when this library is consumed from node_modules), a top-level
+        // 'compileClasspath' config may not exist. In that case, skip adding it.
+        def cc = project.configurations.findByName('compileClasspath')
+        if (cc != null) {
+            classpath += files(cc.asList())
+        } else {
+            logger.lifecycle("react-native-document-scanner: 'compileClasspath' not found; skipping extra Javadoc classpath setup.")
+        }
+        include '**/*.java'
+        
+        // Suppress warnings for missing documentation
+        options.addStringOption('Xdoclint:none', '-quiet')
+    }
+
+    task androidJavadocJar(type: Jar, dependsOn: androidJavadoc) {
+        archiveClassifier.set('javadoc')
+        from androidJavadoc.destinationDir
+    }
+
+    task androidSourcesJar(type: Jar) {
+        archiveClassifier.set('sources')
+        from android.sourceSets.main.java.srcDirs
+        include '**/*.java'
+    }
+
+    android.libraryVariants.all { variant ->
+        def name = variant.name.capitalize()
+        def javaCompileTask = variant.javaCompileProvider.get()
+
+        task "jar${name}"(type: Jar, dependsOn: javaCompileTask) {
+            from javaCompileTask.destinationDir
+        }
+    }
+}
+
+// Modern maven-publish plugin configuration
+def packageJson = new groovy.json.JsonSlurper().parseText(file('../package.json').text)
+
+afterEvaluate {
+    // Only configure publishing if the Android components expose a 'release' variant
+    def releaseComponent = components.findByName("release")
+    if (releaseComponent != null) {
+        publishing {
+            publications {
+                release(MavenPublication) {
+                    from releaseComponent
+                    
+                    groupId = 'com.docscanner'
+                    artifactId = packageJson.name
+                    version = packageJson.version
+                    
+                    artifact androidSourcesJar
+                    artifact androidJavadocJar
+                    
+                    pom {
+                        name = packageJson.title
+                        description = packageJson.description
+                        url = packageJson.repository.baseUrl
+                        
+                        licenses {
+                            license {
+                                name = packageJson.license
+                                url = packageJson.repository.baseUrl + '/blob/master/' + packageJson.licenseFilename
+                                distribution = 'repo'
+                            }
+                        }
+                        
+                        developers {
+                            developer {
+                                id = packageJson.author.name
+                                name = packageJson.author.name
+                            }
+                        }
+                    }
+                }
+            }
+            repositories {
+                maven {
+                    // Deploy to react-native-document-scanner/android/maven, ready to publish to npm
+                    url = uri("file://${projectDir}/../android/maven")
+                }
+            }
+        }
+    } else {
+        logger.lifecycle("react-native-document-scanner: Skipping maven-publish because no 'release' component is available (AGP too old or not applied).")
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<!-- AndroidManifest.xml -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.docscanner">
+
+    <!-- Required for ML Kit Document Scanner -->
+    <uses-permission android:name="android.permission.CAMERA" />
+
+</manifest>

package/android/src/main/java/com/docscanner/DocumentScannerModule.java

@@ -0,0 +1,261 @@
+// DocumentScannerModule.java
+
+package com.docscanner;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.Log;
+
+import androidx.activity.result.ActivityResult;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.IntentSenderRequest;
+import androidx.activity.result.contract.ActivityResultContracts;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import com.google.mlkit.vision.documentscanner.GmsDocumentScanner;
+import com.google.mlkit.vision.documentscanner.GmsDocumentScannerOptions;
+import com.google.mlkit.vision.documentscanner.GmsDocumentScanning;
+import com.google.mlkit.vision.documentscanner.GmsDocumentScanningResult;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.UUID;
+
+// For New Architecture: extend the generated spec base class
+// This class is generated by React Native Codegen based on src/NativeDocumentScanner.ts
+// and will be available when newArchEnabled=true
+@SuppressWarnings("KotlinInternalInJava")
+public class DocumentScannerModule extends com.docscanner.NativeDocumentScannerSpec {
+
+    public static final String NAME = "DocumentScanner";
+    private static final String TAG = "DocumentScannerModule";
+    private static final int DOCUMENT_SCAN_REQUEST = 1001;
+    
+    private final ReactApplicationContext reactContext;
+    private Callback scannerCallback;
+    private ReadableMap scannerOptions;
+
+    private final ActivityEventListener activityEventListener = new BaseActivityEventListener() {
+        @Override
+        public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+            if (requestCode == DOCUMENT_SCAN_REQUEST) {
+                handleScanResult(resultCode, data);
+            }
+        }
+    };
+
+    public DocumentScannerModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        reactContext.addActivityEventListener(activityEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    @Override
+    public void launchScanner(ReadableMap options, Callback callback) {
+        Activity currentActivity = getCurrentActivity();
+        
+        if (currentActivity == null) {
+            WritableMap errorResponse = new WritableNativeMap();
+            errorResponse.putBoolean("error", true);
+            errorResponse.putString("errorMessage", "Activity doesn't exist");
+            callback.invoke(errorResponse);
+            return;
+        }
+
+        scannerCallback = callback;
+        scannerOptions = options;
+
+        // Configure the scanner
+        GmsDocumentScannerOptions.Builder optionsBuilder = new GmsDocumentScannerOptions.Builder()
+                .setGalleryImportAllowed(false)
+                .setPageLimit(10)
+                .setResultFormats(GmsDocumentScannerOptions.RESULT_FORMAT_JPEG, GmsDocumentScannerOptions.RESULT_FORMAT_PDF)
+                .setScannerMode(GmsDocumentScannerOptions.SCANNER_MODE_FULL);
+
+        GmsDocumentScannerOptions scannerOptions = optionsBuilder.build();
+        GmsDocumentScanner scanner = GmsDocumentScanning.getClient(scannerOptions);
+
+        scanner.getStartScanIntent(currentActivity)
+                .addOnSuccessListener(intentSender -> {
+                    try {
+                        currentActivity.startIntentSenderForResult(
+                                intentSender,
+                                DOCUMENT_SCAN_REQUEST,
+                                null,
+                                0,
+                                0,
+                                0
+                        );
+                    } catch (Exception e) {
+                        Log.e(TAG, "Error starting scanner", e);
+                        WritableMap errorResponse = new WritableNativeMap();
+                        errorResponse.putBoolean("error", true);
+                        errorResponse.putString("errorMessage", e.getMessage());
+                        callback.invoke(errorResponse);
+                    }
+                })
+                .addOnFailureListener(e -> {
+                    Log.e(TAG, "Error getting scan intent", e);
+                    WritableMap errorResponse = new WritableNativeMap();
+                    errorResponse.putBoolean("error", true);
+                    errorResponse.putString("errorMessage", e.getMessage());
+                    callback.invoke(errorResponse);
+                });
+    }
+
+    private void handleScanResult(int resultCode, Intent data) {
+        if (scannerCallback == null) {
+            return;
+        }
+
+        if (resultCode == Activity.RESULT_CANCELED) {
+            WritableMap response = new WritableNativeMap();
+            response.putBoolean("didCancel", true);
+            scannerCallback.invoke(response);
+            scannerCallback = null;
+            return;
+        }
+
+        if (resultCode != Activity.RESULT_OK || data == null) {
+            WritableMap errorResponse = new WritableNativeMap();
+            errorResponse.putBoolean("error", true);
+            errorResponse.putString("errorMessage", "Scan failed");
+            scannerCallback.invoke(errorResponse);
+            scannerCallback = null;
+            return;
+        }
+
+        GmsDocumentScanningResult result = GmsDocumentScanningResult.fromActivityResultIntent(data);
+        if (result == null) {
+            WritableMap errorResponse = new WritableNativeMap();
+            errorResponse.putBoolean("error", true);
+            errorResponse.putString("errorMessage", "Failed to get scan result");
+            scannerCallback.invoke(errorResponse);
+            scannerCallback = null;
+            return;
+        }
+
+        WritableArray imagesArray = new WritableNativeArray();
+
+        // Process each scanned page
+        GmsDocumentScanningResult.Page[] pages = result.getPages().toArray(new GmsDocumentScanningResult.Page[0]);
+        for (GmsDocumentScanningResult.Page page : pages) {
+            Uri imageUri = page.getImageUri();
+            try {
+                WritableMap imageObject = processImage(imageUri);
+                if (imageObject != null) {
+                    imagesArray.pushMap(imageObject);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error processing image", e);
+            }
+        }
+
+        WritableMap response = new WritableNativeMap();
+        response.putArray("images", imagesArray);
+        scannerCallback.invoke(response);
+        scannerCallback = null;
+    }
+
+    private WritableMap processImage(Uri imageUri) throws IOException {
+        WritableMap imageObject = new WritableNativeMap();
+        
+        Activity currentActivity = getCurrentActivity();
+        if (currentActivity == null) {
+            return null;
+        }
+
+        // Read the image
+        InputStream inputStream = currentActivity.getContentResolver().openInputStream(imageUri);
+        if (inputStream == null) {
+            return null;
+        }
+
+        byte[] imageBytes = readBytes(inputStream);
+        inputStream.close();
+
+        // Decode bitmap to get dimensions
+        android.graphics.BitmapFactory.Options options = new android.graphics.BitmapFactory.Options();
+        options.inJustDecodeBounds = false;
+        Bitmap bitmap = android.graphics.BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length, options);
+        
+        if (bitmap == null) {
+            return null;
+        }
+
+        // Apply quality compression if needed
+        double quality = 1.0;
+        if (scannerOptions != null && scannerOptions.hasKey("quality")) {
+            quality = scannerOptions.getDouble("quality");
+        }
+
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        int qualityPercent = (int) (quality * 100);
+        bitmap.compress(Bitmap.CompressFormat.JPEG, qualityPercent, outputStream);
+        byte[] processedImageBytes = outputStream.toByteArray();
+        outputStream.close();
+
+        // Save to cache directory
+        String fileName = UUID.randomUUID().toString() + ".jpg";
+        File cacheDir = currentActivity.getCacheDir();
+        File imageFile = new File(cacheDir, fileName);
+        
+        FileOutputStream fileOutputStream = new FileOutputStream(imageFile);
+        fileOutputStream.write(processedImageBytes);
+        fileOutputStream.close();
+
+        // Build response
+        imageObject.putString("uri", Uri.fromFile(imageFile).toString());
+        imageObject.putString("fileName", fileName);
+        imageObject.putString("type", "image/jpeg");
+        imageObject.putInt("width", bitmap.getWidth());
+        imageObject.putInt("height", bitmap.getHeight());
+        imageObject.putInt("fileSize", processedImageBytes.length);
+
+        // Add base64 if requested
+        if (scannerOptions != null && scannerOptions.hasKey("includeBase64") && 
+            scannerOptions.getBoolean("includeBase64")) {
+            String base64 = Base64.encodeToString(processedImageBytes, Base64.NO_WRAP);
+            imageObject.putString("base64", base64);
+        }
+
+        bitmap.recycle();
+        
+        return imageObject;
+    }
+
+    private byte[] readBytes(InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
+        byte[] buffer = new byte[16384];
+        int len;
+        while ((len = inputStream.read(buffer)) != -1) {
+            byteBuffer.write(buffer, 0, len);
+        }
+        return byteBuffer.toByteArray();
+    }
+}
+
+

package/android/src/main/java/com/docscanner/DocumentScannerPackage.java

@@ -0,0 +1,49 @@
+// DocumentScannerPackage.java
+
+package com.docscanner;
+
+import androidx.annotation.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+public class DocumentScannerPackage extends TurboReactPackage {
+    
+    @Nullable
+    @Override
+    public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+        if (name.equals(DocumentScannerModule.NAME)) {
+            return new DocumentScannerModule(reactContext);
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> {
+            final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+            boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+            moduleInfos.put(
+                    DocumentScannerModule.NAME,
+                    new ReactModuleInfo(
+                            DocumentScannerModule.NAME,
+                            DocumentScannerModule.NAME,
+                            false, // canOverrideExistingModule
+                            false, // needsEagerInit
+                            true, // hasConstants
+                            false, // isCxxModule
+                            isTurboModule // isTurboModule
+                    ));
+            return moduleInfos;
+        };
+    }
+}
+
+

package/android/src/main/java/com/reactlibrary/DocumentScannerModule.java

@@ -0,0 +1 @@
+ 

package/android/src/main/java/com/reactlibrary/DocumentScannerPackage.java

@@ -0,0 +1 @@
+ 

package/assets/.gitkeep

@@ -0,0 +1,2 @@
+# This directory contains media assets for documentation (README screenshots, videos, etc.)
+

package/index.d.ts

@@ -0,0 +1,126 @@
+// Type definitions for react-native-document-scanner
+// Project: https://github.com/dariyd/react-native-document-scanner
+
+export interface ImageObject {
+  /**
+   * The base64 string of the image (only if includeBase64 option is true)
+   */
+  base64?: string;
+  
+  /**
+   * The file URI in app specific cache storage
+   */
+  uri: string;
+  
+  /**
+   * Image width in pixels
+   */
+  width: number;
+  
+  /**
+   * Image height in pixels
+   */
+  height: number;
+  
+  /**
+   * The file size in bytes
+   */
+  fileSize: number;
+  
+  /**
+   * The file MIME type (e.g., "image/jpeg")
+   */
+  type: string;
+  
+  /**
+   * The file name
+   */
+  fileName: string;
+}
+
+export interface ScanResult {
+  /**
+   * True if the user cancelled the scanning process
+   */
+  didCancel?: boolean;
+  
+  /**
+   * True if an error occurred
+   */
+  error?: boolean;
+  
+  /**
+   * Description of the error (for debug purposes only)
+   */
+  errorMessage?: string;
+  
+  /**
+   * Array of scanned images
+   */
+  images?: ImageObject[];
+}
+
+export interface ScanOptions {
+  /**
+   * Image quality from 0 to 1 (default: 1)
+   * Lower values reduce file size
+   * 
+   * @default 1
+   */
+  quality?: number;
+  
+  /**
+   * If true, includes base64 string of the image in the result
+   * Avoid using on large image files due to performance impact
+   * 
+   * @default false
+   */
+  includeBase64?: boolean;
+}
+
+/**
+ * Launch the document scanner
+ * 
+ * @param options - Scanner options
+ * @param callback - Optional callback function
+ * @returns Promise that resolves with the scan result
+ * 
+ * @example
+ * ```typescript
+ * import { launchScanner } from 'react-native-document-scanner';
+ * 
+ * // Basic usage
+ * const result = await launchScanner();
+ * 
+ * // With options
+ * const result = await launchScanner({
+ *   quality: 0.8,
+ *   includeBase64: false,
+ * });
+ * 
+ * // With callback
+ * launchScanner({ quality: 0.9 }, (result) => {
+ *   if (result.didCancel) {
+ *     console.log('User cancelled');
+ *   } else if (result.error) {
+ *     console.log('Error:', result.errorMessage);
+ *   } else {
+ *     console.log('Scanned images:', result.images);
+ *   }
+ * });
+ * ```
+ */
+export function launchScanner(
+  options?: ScanOptions,
+  callback?: (result: ScanResult) => void
+): Promise<ScanResult>;
+
+declare const DocumentScanner: {
+  launchScanner: (
+    options: ScanOptions,
+    callback: (result: ScanResult) => void
+  ) => void;
+};
+
+export default DocumentScanner;
+

package/index.js

@@ -0,0 +1,46 @@
+// main index.js
+
+import { NativeModules, Platform } from 'react-native';
+
+// Try to get the TurboModule (new architecture)
+let DocumentScannerModule;
+try {
+  DocumentScannerModule = require('./src/NativeDocumentScanner').default;
+} catch (e) {
+  // Fall back to old architecture
+  DocumentScannerModule = NativeModules.DocumentScanner;
+}
+
+// If still not available, try the old way
+if (!DocumentScannerModule) {
+  DocumentScannerModule = NativeModules.DocumentScanner;
+}
+
+export default DocumentScannerModule;
+
+const DEFAULT_OPTIONS = {
+  quality: 1,
+  includeBase64: false,
+};
+
+export function launchScanner(options = {}, callback) {
+  return new Promise((resolve, reject) => {
+    if (!DocumentScannerModule) {
+      const error = {
+        error: true,
+        errorMessage: 'DocumentScanner module is not available',
+      };
+      if (callback) callback(error);
+      reject(error);
+      return;
+    }
+
+    DocumentScannerModule.launchScanner(
+      {...DEFAULT_OPTIONS, ...options},
+      (result) => {
+        if (callback) callback(result);
+        resolve(result);
+      },
+    );
+  });  
+}