react-native-text-reader 1.5.0 → 2.0.0

package/README.md

@@ -1,7 +1,6 @@
 # `react-native-text-reader`
 
-A simple React Native library for extracting text from images using native iOS (Vision Framework) and Android (ML Kit) capabilities.
-
+A React Native library for extracting text from images using native iOS (Vision Framework) and Android (ML Kit) capabilities.
 
 ## Table of Contents
 
@@ -9,92 +8,120 @@ A simple React Native library for extracting text from images using native iOS (
 - [Platform Setup](#platform-setup)
   - [iOS](#ios)
   - [Android](#android)
+  - [Expo](#expo)
 - [Usage](#usage)
   - [Basic Example](#basic-example)
+  - [Detailed Result](#detailed-result)
 - [Options](#options)
 - [ScriptOptions Enum](#scriptoptions-enum)
 - [Contributing](#contributing)
 - [License](#license)
 
-### NOTE:
- I currently do not work extensively with React Native, so this project may not receive frequent updates. However, if anyone is interested in contributing, please feel free to reach out!
-
 ## Installation
 
-Install the package using npm or yarn:
+Install the package with your preferred package manager:
 
 ```bash
 npm install react-native-text-reader
 ```
 
-or
+```bash
+pnpm add react-native-text-reader
+```
 
 ```bash
 yarn add react-native-text-reader
 ```
 
-After installing the package, make sure to link the native dependencies:
+The published package is package-manager agnostic. Use whichever tool your app already uses.
 
 ### iOS
 
-If you're using iOS, run the following command to install the necessary native modules:
-
 ```bash
-cd ios/ && pod install
+cd ios && pod install
 ```
 
 ### Android
 
-No additional steps are required for Android.
+No additional manual steps are required. Autolinking handles native setup.
 
----
+## Expo
 
-## Usage
+This library uses custom native code (Vision + ML Kit), so it does **not** work in **Expo Go**.
+
+It **does** work with Expo development builds and EAS Build (tested with **Expo SDK 56**):
+
+```bash
+npx expo install react-native-text-reader expo-dev-client
+```
+
+Add the config plugin to your `app.json`:
+
+```json
+{
+  "expo": {
+    "plugins": ["react-native-text-reader"]
+  }
+}
+```
+
+Then create native projects and run a dev build:
 
-To use the text reader, import it and call the `read` method with the image path and options.
+```bash
+npx expo prebuild
+npx expo run:ios
+# or
+npx expo run:android
+```
+
+## Usage
 
 ### Basic Example
 
-```javascript
+```typescript
 import TextReader, { ScriptOptions } from 'react-native-text-reader';
 
-const imagePath = 'path/to/your/image.jpg';
-const options = {
-  visionIgnoreThreshold: 0.5, // iOS only
-  script: ScriptOptions.LATIN, // Android only
-};
-
-const readTextFromImage = async () => {
-  try {
-    const text = await TextReader.read(imagePath, options);
-    console.log('Extracted text:', text);
-  } catch (error) {
-    console.error('Error reading text:', error);
-  }
-};
+const imagePath = 'file:///path/to/your/image.jpg';
 
-readTextFromImage();
+const lines = await TextReader.read(imagePath, {
+  visionIgnoreThreshold: 0.5, // iOS
+  confidenceThreshold: 0.5, // Android
+  script: ScriptOptions.LATIN, // Android
+});
 
+console.log('Extracted lines:', lines);
 ```
 
----
+`read()` returns `Promise<string[]>` — one entry per detected line.
 
-## Options
+### Detailed Result
 
-### `Options`
+```typescript
+const result = await TextReader.readDetailed(imagePath, {
+  script: ScriptOptions.LATIN,
+});
 
-| Property                  | Type              | Description                                          |
-|--------------------------|-------------------|------------------------------------------------------|
-| `visionIgnoreThreshold`  | `number`          | The confidence threshold for iOS (default: 0.0)     |
-| `script`                 | `ScriptOptions`   | The language script for Android (default: `LATIN`)  |
+console.log(result.fullText);
+console.log(result.lines);
+console.log(result.details); // confidence, frame, languages
+```
 
----
+## Options
 
-## ScriptOptions
+| Property | Type | Platform | Description |
+|----------|------|----------|-------------|
+| `visionIgnoreThreshold` | `number` | iOS | Confidence threshold (default: `0`) |
+| `confidenceThreshold` | `number` | Android | Confidence threshold (default: `0`) |
+| `script` | `ScriptOptions` | Android | Script model (default: `LATIN`) |
+| `recognitionLevel` | `'fast' \| 'accurate'` | iOS | Speed vs accuracy (default: `accurate`) |
+| `recognitionLanguages` | `string[]` | iOS | Language hints, e.g. `['en-US']` |
+| `customWords` | `string[]` | iOS | Domain vocabulary hints |
+| `useLanguageCorrection` | `boolean` | iOS | Enable language correction |
+| `minimumTextHeight` | `number` | iOS | Ignore text smaller than this fraction |
 
-The `ScriptOptions` enum allows you to specify different language scripts for Android:
+## ScriptOptions
 
-```javascript
+```typescript
 export enum ScriptOptions {
   LATIN = 'Latin',
   CHINESE = 'Chinese',
@@ -104,14 +131,10 @@ export enum ScriptOptions {
 }
 ```
 
----
-
 ## Contributing
 
-Contributions are welcome! Please submit a pull request or open an issue for any enhancements or bugs.
-
----
+See [CONTRIBUTING.md](CONTRIBUTING.md). Development in this repository uses **pnpm**.
 
 ## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+MIT — see [LICENSE](LICENSE).

package/android/gradle.properties

@@ -1,5 +1,5 @@
-TextReader_kotlinVersion=1.9.10
-TextReader_minSdkVersion=21
-TextReader_targetSdkVersion=34
-TextReader_compileSdkVersion=34
+TextReader_kotlinVersion=2.0.21
+TextReader_minSdkVersion=23
+TextReader_targetSdkVersion=35
+TextReader_compileSdkVersion=35
 TextReader_ndkversion=25.1.8937393

package/android/src/main/java/com/textreader/TextReaderModule.kt

@@ -1,20 +1,13 @@
 package com.textreader
 
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
-
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
 import android.graphics.Point
 import android.graphics.Rect
 import android.net.Uri
-import android.graphics.BitmapFactory
-import android.graphics.Bitmap
 import androidx.annotation.NonNull
 import androidx.annotation.Nullable
 import com.facebook.react.bridge.*
-import com.google.android.gms.tasks.OnFailureListener
-import com.google.android.gms.tasks.OnSuccessListener
 import com.google.mlkit.vision.common.InputImage
 import com.google.mlkit.vision.text.Text
 import com.google.mlkit.vision.text.TextRecognition
@@ -25,127 +18,220 @@ import com.google.mlkit.vision.text.devanagari.DevanagariTextRecognizerOptions
 import com.google.mlkit.vision.text.japanese.JapaneseTextRecognizerOptions
 import com.google.mlkit.vision.text.korean.KoreanTextRecognizerOptions
 import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
 import java.io.IOException
+import java.net.HttpURLConnection
 import java.net.URL
 
 class TextReaderModule(reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
-    override fun getName(): String {
-        return "TextReader"
+
+  companion object {
+    private const val HTTP_CONNECT_TIMEOUT_MS = 10_000
+    private const val HTTP_READ_TIMEOUT_MS = 10_000
+    private const val MAX_IMAGE_BYTES = 20 * 1024 * 1024
+  }
+
+  override fun getName(): String = "TextReader"
+
+  @Throws(IOException::class)
+  private fun getInputImage(reactContext: ReactApplicationContext, url: String): InputImage {
+    return if (url.contains("http://") || url.contains("https://")) {
+      val connection = URL(url).openConnection() as HttpURLConnection
+      connection.connectTimeout = HTTP_CONNECT_TIMEOUT_MS
+      connection.readTimeout = HTTP_READ_TIMEOUT_MS
+      connection.connect()
+
+      val contentLength = connection.contentLength
+      if (contentLength > MAX_IMAGE_BYTES) {
+        connection.disconnect()
+        throw IOException("Remote image exceeds maximum allowed size.")
+      }
+
+      val image: Bitmap? = connection.inputStream.use { stream ->
+        BitmapFactory.decodeStream(stream)
+      }
+      connection.disconnect()
+
+      if (image == null) {
+        throw IOException("Failed to decode remote image.")
+      }
+
+      InputImage.fromBitmap(image, 0)
+    } else {
+      val uri = Uri.parse(url)
+      InputImage.fromFilePath(reactContext, uri)
     }
+  }
 
-    @Throws(IOException::class)
-    private fun getInputImage(reactContext: ReactApplicationContext, url: String): InputImage {
-        return if (url.contains("http://") || url.contains("https://")) {
-            val urlInput = URL(url)
-            val image: Bitmap = BitmapFactory.decodeStream(urlInput.openConnection().getInputStream())
-            InputImage.fromBitmap(image, 0)
-        } else {
-            val uri = Uri.parse(url)
-            InputImage.fromFilePath(reactContext, uri)
-        }
+  private fun rectToMap(rect: Rect): WritableMap {
+    return Arguments.createMap().apply {
+      putInt("width", rect.width())
+      putInt("height", rect.height())
+      putInt("top", rect.top)
+      putInt("left", rect.left)
     }
+  }
 
-    private fun rectToMap(rect: Rect): WritableMap {
-        return Arguments.createMap().apply {
-            putInt("width", rect.width())
-            putInt("height", rect.height())
-            putInt("top", rect.top)
-            putInt("left", rect.left)
-        }
+  private fun cornerPointsToMap(points: Array<Point>): WritableArray {
+    return Arguments.createArray().apply {
+      points.forEach { point ->
+        pushMap(Arguments.createMap().apply {
+          putInt("x", point.x)
+          putInt("y", point.y)
+        })
+      }
     }
+  }
 
-    private fun cornerPointsToMap(points: Array<Point>): WritableArray {
-        return Arguments.createArray().apply {
-            points.forEach { point ->
-                pushMap(Arguments.createMap().apply {
-                    putInt("x", point.x)
-                    putInt("y", point.y)
-                })
-            }
-        }
+  private fun langToMap(lang: String): WritableArray {
+    return Arguments.createArray().apply {
+      pushMap(Arguments.createMap().apply {
+        putString("languageCode", lang)
+      })
     }
+  }
 
-    private fun langToMap(lang: String): WritableArray {
-        return Arguments.createArray().apply {
-            pushMap(Arguments.createMap().apply {
-                putString("languageCode", lang)
-            })
-        }
+  private fun lineConfidence(line: Text.Line): Float {
+    val elements = line.elements
+    if (elements.isEmpty()) return 1.0f
+    return elements.map { element ->
+      try {
+        val method = element.javaClass.getMethod("getConfidence")
+        (method.invoke(element) as? Float) ?: 1.0f
+      } catch (_: Exception) {
+        1.0f
+      }
+    }.average().toFloat()
+  }
+
+  private fun lineToMap(line: Text.Line): WritableMap {
+    return Arguments.createMap().apply {
+      putString("text", line.text)
+      putDouble("confidence", lineConfidence(line).toDouble())
+      line.boundingBox?.let { putMap("frame", rectToMap(it)) }
+      line.cornerPoints?.let { putArray("cornerPoints", cornerPointsToMap(it)) }
+      putArray("recognizedLanguages", langToMap(line.recognizedLanguage))
+
+      val elementsArray = Arguments.createArray()
+      line.elements.forEach { element ->
+        elementsArray.pushMap(Arguments.createMap().apply {
+          putString("text", element.text)
+          element.boundingBox?.let { putMap("frame", rectToMap(it)) }
+          element.cornerPoints?.let { putArray("cornerPoints", cornerPointsToMap(it)) }
+        })
+      }
+      putArray("elements", elementsArray)
     }
+  }
 
-    private fun lineToMap(line: Text.Line): WritableMap {
-        return Arguments.createMap().apply {
-            putString("text", line.text)
-            line.boundingBox?.let { putMap("frame", rectToMap(it)) }
-            line.cornerPoints?.let { putArray("cornerPoints", cornerPointsToMap(it)) }
-            putArray("recognizedLanguages", langToMap(line.recognizedLanguage))
-
-            val elementsArray = Arguments.createArray()
-            line.elements.forEach { element ->
-                elementsArray.pushMap(Arguments.createMap().apply {
-                    putString("text", element.text)
-                    element.boundingBox?.let { putMap("frame", rectToMap(it)) }
-                    element.cornerPoints?.let { putArray("cornerPoints", cornerPointsToMap(it)) }
-                })
-            }
-            putArray("elements", elementsArray)
-        }
+  private fun blockToMap(block: Text.TextBlock): WritableMap {
+    return Arguments.createMap().apply {
+      putString("text", block.text)
+      block.boundingBox?.let { putMap("frame", rectToMap(it)) }
+      block.cornerPoints?.let { putArray("cornerPoints", cornerPointsToMap(it)) }
+
+      val linesArray = Arguments.createArray()
+      block.lines.forEach { line ->
+        linesArray.pushMap(lineToMap(line))
+      }
+      putArray("lines", linesArray)
+      putArray("recognizedLanguages", langToMap(block.recognizedLanguage))
+    }
+  }
+
+  @NonNull
+  private fun getScriptTextRecognizerOptions(@Nullable script: String?): TextRecognizerOptionsInterface {
+    return when (script) {
+      "Chinese" -> ChineseTextRecognizerOptions.Builder().build()
+      "Devanagari" -> DevanagariTextRecognizerOptions.Builder().build()
+      "Japanese" -> JapaneseTextRecognizerOptions.Builder().build()
+      "Korean" -> KoreanTextRecognizerOptions.Builder().build()
+      else -> TextRecognizerOptions.DEFAULT_OPTIONS
     }
+  }
 
-    private fun blockToMap(block: Text.TextBlock): WritableMap {
-        return Arguments.createMap().apply {
-            putString("text", block.text)
-            block.boundingBox?.let { putMap("frame", rectToMap(it)) }
-            block.cornerPoints?.let { putArray("cornerPoints", cornerPointsToMap(it)) }
+  private fun sortedLines(visionText: Text, confidenceThreshold: Float): List<Text.Line> {
+    return visionText.textBlocks
+      .flatMap { block -> block.lines }
+      .filter { line -> lineConfidence(line) >= confidenceThreshold }
+      .sortedWith(compareBy({ it.boundingBox?.top ?: 0 }, { it.boundingBox?.left ?: 0 }))
+  }
+
+  private fun processImage(
+    url: String,
+    options: ReadableMap?,
+    detailed: Boolean,
+    promise: Promise
+  ) {
+    if (url.isEmpty()) {
+      promise.reject("ERR_EMPTY_PATH", "Image path cannot be empty.")
+      return
+    }
 
+    val script = options?.getString("script")
+    val confidenceThreshold = if (options != null && options.hasKey("confidenceThreshold")) {
+      options.getDouble("confidenceThreshold").toFloat()
+    } else {
+      0.0f
+    }
+
+    val recognizer: TextRecognizer = TextRecognition.getClient(getScriptTextRecognizerOptions(script))
+
+    try {
+      val image = getInputImage(reactApplicationContext, url)
+      recognizer.process(image)
+        .addOnSuccessListener { visionText ->
+          val lines = sortedLines(visionText, confidenceThreshold)
+          if (detailed) {
+            promise.resolve(buildDetailedResult(visionText, lines))
+          } else {
             val linesArray = Arguments.createArray()
-            block.lines.forEach { line ->
-                linesArray.pushMap(lineToMap(line))
-            }
-            putArray("lines", linesArray)
-            putArray("recognizedLanguages", langToMap(block.recognizedLanguage))
+            lines.forEach { line -> linesArray.pushString(line.text) }
+            promise.resolve(linesArray)
+          }
+        }
+        .addOnFailureListener { e ->
+          promise.reject("ERR_OCR", "Text recognition failed: ${e.message}", e)
+        }
+        .addOnCompleteListener {
+          recognizer.close()
         }
+    } catch (e: IOException) {
+      recognizer.close()
+      promise.reject("ERR_IMAGE_LOADING", "Failed to load image: ${e.message}", e)
+    } catch (e: Exception) {
+      recognizer.close()
+      promise.reject("ERR_IMAGE_PROCESSING", "Failed to process image: ${e.message}", e)
     }
+  }
 
-    @NonNull
-    private fun getScriptTextRecognizerOptions(@Nullable script: String?): TextRecognizerOptionsInterface {
-        return when (script) {
-            "Chinese" -> ChineseTextRecognizerOptions.Builder().build()
-            "Devanagari" -> DevanagariTextRecognizerOptions.Builder().build()
-            "Japanese" -> JapaneseTextRecognizerOptions.Builder().build()
-            "Korean" -> KoreanTextRecognizerOptions.Builder().build()
-            else -> TextRecognizerOptions.DEFAULT_OPTIONS
-        }
+  private fun buildDetailedResult(visionText: Text, lines: List<Text.Line>): WritableMap {
+    val lineTexts = lines.map { it.text }
+    val detailsArray = Arguments.createArray()
+    lines.forEach { line ->
+      detailsArray.pushMap(lineToMap(line))
     }
-    
-    @ReactMethod
-    fun read(url: String, options: ReadableMap?, promise: Promise) {
-        try {
-            val script = options?.getString("script")
-
-            val image = getInputImage(reactApplicationContext, url)
-            val options = getScriptTextRecognizerOptions(script)
-
-            val recognizer: TextRecognizer = TextRecognition.getClient(options)
-
-            recognizer.process(image)
-                .addOnSuccessListener { visionText ->
-                    val linesArray = Arguments.createArray()
-                    visionText.textBlocks.forEach { block ->
-                        block.lines.forEach { line ->
-                            linesArray.pushString(line.text)
-                        }
-                    }
-                    promise.resolve(linesArray)
-                }
-                .addOnFailureListener { e ->
-                    e.printStackTrace()
-                    promise.reject("Text recognition failed", e)
-                }
-        } catch (e: IOException) {
-            e.printStackTrace()
-            promise.reject("Text recognition failed", e)
-        }
+
+    return Arguments.createMap().apply {
+      putString("fullText", visionText.text)
+      putArray("lines", Arguments.createArray().apply {
+        lineTexts.forEach { pushString(it) }
+      })
+      putArray("details", detailsArray)
     }
-}
+  }
+
+  @ReactMethod
+  fun read(url: String, options: ReadableMap?, promise: Promise) {
+    processImage(url, options, detailed = false, promise = promise)
+  }
+
+  @ReactMethod
+  fun readDetailed(url: String, options: ReadableMap?, promise: Promise) {
+    processImage(url, options, detailed = true, promise = promise)
+  }
+}

package/app.plugin.js

@@ -0,0 +1,15 @@
+const { createRunOncePlugin } = require('expo/config-plugins');
+
+/**
+ * Ensures react-native-text-reader is configured for Expo development builds.
+ * Requires expo-dev-client — does not work in Expo Go.
+ */
+function withReactNativeTextReader(config) {
+  return config;
+}
+
+module.exports = createRunOncePlugin(
+  withReactNativeTextReader,
+  'react-native-text-reader',
+  '2.0.0'
+);

package/ios/TextReader.mm

@@ -8,6 +8,12 @@ RCT_EXTERN_METHOD(read
                   : (RCTPromiseResolveBlock)resolve withRejecter
                   : (RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(readDetailed
+                  : (NSString *)imgPath withOptions
+                  : (NSDictionary *)options withResolver
+                  : (RCTPromiseResolveBlock)resolve withRejecter
+                  : (RCTPromiseRejectBlock)reject)
+
 + (BOOL)requiresMainQueueSetup
 {
   return NO;