@mleonard9/vin-scanner 0.2.5 → 0.2.7

package/README.md

@@ -102,8 +102,17 @@ type VinScannerEvent = {
 | `options.detection.preferBarcode` | boolean | Prefer barcode hits when selecting the best VIN | `true` |
 | `options.detection.validateChecksum` | boolean | Run VIN checksum validation | `true` |
 | `options.detection.emitDuplicates` | boolean | Emit unchanged payloads every frame | `false` for `'best'`, `true` for `'all'` |
+| `options.detection.maxFrameRate` | number | Max FPS budget for frame processing (drops surplus frames to avoid blocking) | `30` |
+| `options.detection.forceOrientation` | `'portrait' \| 'portrait-upside-down' \| 'landscape-left' \| 'landscape-right'` | Forces ML Kit to interpret every frame using the given orientation (useful when the UI is locked to portrait but the sensor reports landscape) | `null` |
 | `options.onResult` | `(result, event) => void` | Convenience callback when using `useVinScanner`; receives either the best candidate, all candidates, or `null` plus the raw event | `undefined` |
 
+### Advanced frame-processor controls
+
+- **Per-frame plugin overrides:** both barcode and text frame processor plugins accept per-frame arguments, so you can dynamically change ML Kit barcode formats or text recognition language without reinitializing the plugin. Call `barcodeScanner.scanBarcodes(frame, { 'pdf-417': true })` or `textScanner.scanText(frame, { language: 'japanese' })` inside your worklet to override the resolved defaults for a single frame.
+- **Orientation overrides:** If your UI is locked to portrait (e.g., iPad kiosks) but VisionCamera streams landscape buffers, set `detection.forceOrientation: 'portrait'`. The JS hook forwards that override to the native plugins so ML Kit always interprets frames with the requested rotation, eliminating the “upside-down unless I flip the paper” problem described in the [VisionCamera orientation guide](https://react-native-vision-camera.com/docs/guides/orientation).
+- **Shared bounding boxes:** native plugins now stream bounding box coordinates via zero-copy shared arrays, minimizing JSI serialization. The hook translates these buffers into the familiar `BoundingBox` structures before running VIN heuristics, so no API change is required.
+- **Orientation-safe processing:** the native plugins forward VisionCamera’s frame orientation metadata directly into ML Kit as recommended in the [VisionCamera orientation guide](https://react-native-vision-camera.com/docs/guides/orientation), ensuring portrait VIN scans stay upright.
+
 ### Hook-only usage
 
 If you prefer to configure `react-native-vision-camera` yourself, grab the frame processor from the hook:

package/android/src/main/java/com/visioncamerabarcodescanner/VisionCameraBarcodeScannerModule.kt

@@ -1,8 +1,6 @@
 package com.visioncamerabarcodescanner
 
 import android.media.Image
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
 import com.google.android.gms.tasks.Task
 import com.google.android.gms.tasks.Tasks
 import com.google.mlkit.vision.barcode.BarcodeScannerOptions
@@ -25,69 +23,113 @@ import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_EAN_13
 import com.google.mlkit.vision.common.InputImage
 import com.mrousavy.camera.frameprocessors.Frame
 import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.SharedArray
 import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.nio.ByteOrder
+import java.util.HashMap
 
-class VisionCameraBarcodeScannerModule(proxy : VisionCameraProxy, options: Map<String, Any>?): FrameProcessorPlugin() {
+private const val BOX_STRIDE = 6
 
-  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
-    try {
-     val optionsBuilder = BarcodeScannerOptions.Builder()
-      if (arguments?.get("code-128").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_128)
-      else if (arguments?.get("code-39").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_39)
-      else if (arguments?.get("code-93").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_93)
-      else if (arguments?.get("codabar").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODABAR)
-      else if (arguments?.get("ean-13").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_EAN_13)
-      else if (arguments?.get("ean-8").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_EAN_8)
-      else if (arguments?.get("itf").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_ITF)
-      else if (arguments?.get("upc-e").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_UPC_E)
-      else if (arguments?.get("upc-a").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_UPC_A)
-      else if (arguments?.get("qr").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_QR_CODE)
-      else if (arguments?.get("pdf-417").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_PDF417)
-      else if (arguments?.get("aztec").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_AZTEC)
-      else if (arguments?.get("data-matrix").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_DATA_MATRIX)
-      else if (arguments?.get("all").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_ALL_FORMATS)
-      else optionsBuilder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+class VisionCameraBarcodeScannerModule(
+  private val proxy : VisionCameraProxy,
+  options: Map<String, Any>?
+): FrameProcessorPlugin() {
+
+  private val initializerOptions: Map<String, Any> = options ?: emptyMap()
+
+  private fun mergedOptions(overrides: Map<String, Any>?): Map<String, Any> {
+    if (overrides == null || overrides.isEmpty()) {
+      return initializerOptions
+    }
+    val merged = HashMap(initializerOptions)
+    merged.putAll(overrides)
+    return merged
+  }
 
-      val scanner = BarcodeScanning.getClient(optionsBuilder.build())
+  private fun buildScannerOptions(effective: Map<String, Any>): BarcodeScannerOptions {
+    val builder = BarcodeScannerOptions.Builder()
+    when {
+      effective["code-128"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODE_128)
+      effective["code-39"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODE_39)
+      effective["code-93"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODE_93)
+      effective["codabar"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_CODABAR)
+      effective["ean-13"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_EAN_13)
+      effective["ean-8"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_EAN_8)
+      effective["itf"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_ITF)
+      effective["upc-e"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_UPC_E)
+      effective["upc-a"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_UPC_A)
+      effective["qr"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_QR_CODE)
+      effective["pdf-417"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_PDF417)
+      effective["aztec"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_AZTEC)
+      effective["data-matrix"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_DATA_MATRIX)
+      effective["all"].toString().toBoolean() -> builder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+      else -> builder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+    }
+    return builder.build()
+  }
+
+  private fun orientationToDegrees(orientation: String?): Int? {
+    return when (orientation) {
+      "portrait" -> 0
+      "portrait-upside-down" -> 180
+      "landscape-left" -> 90
+      "landscape-right" -> 270
+      else -> null
+    }
+  }
+
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
+    return try {
+      val options = mergedOptions(arguments)
+      val scanner = BarcodeScanning.getClient(buildScannerOptions(options))
       val mediaImage: Image = frame.image
-      val image = InputImage.fromMediaImage(mediaImage, frame.imageProxy.imageInfo.rotationDegrees)
+      val rotationOverride = orientationToDegrees(options["orientation"] as? String)
+      val rotationDegrees = rotationOverride ?: frame.imageProxy.imageInfo.rotationDegrees
+      val image = InputImage.fromMediaImage(mediaImage, rotationDegrees)
       val task: Task<List<Barcode>> = scanner.process(image)
       val barcodes: List<Barcode> = Tasks.await(task)
-      val array = WritableNativeArray()
-      for (barcode in barcodes) {
-        val map = WritableNativeMap()
-        val bounds = barcode.boundingBox
-        if (bounds != null) {
-          map.putInt("width",bounds.width())
-          map.putInt("height",bounds.height())
-          map.putInt("top",bounds.top)
-          map.putInt("bottom",bounds.bottom)
-          map.putInt("left",bounds.left)
-          map.putInt("right",bounds.right)
-        }
-        val rawValue = barcode.rawValue
-        map.putString("rawValue",rawValue)
-        val valueType = barcode.valueType
-        when (valueType) {
-          Barcode.TYPE_WIFI -> {
-            val ssid = barcode.wifi!!.ssid
-            map.putString("ssid",ssid)
-            val password = barcode.wifi!!.password
-            map.putString("password",password)
-          }
-          Barcode.TYPE_URL -> {
-            val title = barcode.url!!.title
-            map.putString("title",title)
-            val url = barcode.url!!.url
-            map.putString("url",url)
+
+      val detections = ArrayList<Map<String, Any?>>()
+      val sharedArray =
+        if (barcodes.isNotEmpty()) SharedArray(proxy, barcodes.size * BOX_STRIDE * java.lang.Float.BYTES)
+        else null
+      val floatBuffer = sharedArray?.byteBuffer
+        ?.order(ByteOrder.nativeOrder())
+        ?.asFloatBuffer()
+
+      barcodes.forEachIndexed { index, barcode ->
+        val detection = HashMap<String, Any?>()
+        detection["rawValue"] = barcode.rawValue
+        detection["displayValue"] = barcode.displayValue
+        detection["format"] = barcode.format
+        detection["boxIndex"] = index
+        floatBuffer?.let { buffer ->
+          val bounds = barcode.boundingBox
+          val floatIndex = index * BOX_STRIDE
+          if (bounds != null) {
+            buffer.put(floatIndex, bounds.top.toFloat())
+            buffer.put(floatIndex + 1, bounds.bottom.toFloat())
+            buffer.put(floatIndex + 2, bounds.left.toFloat())
+            buffer.put(floatIndex + 3, bounds.right.toFloat())
+            buffer.put(floatIndex + 4, bounds.width().toFloat())
+            buffer.put(floatIndex + 5, bounds.height().toFloat())
+          } else {
+            for (offset in 0 until BOX_STRIDE) {
+              buffer.put(floatIndex + offset, -1f)
+            }
           }
         }
-        array.pushMap(map)
+        detections.add(detection)
+      }
+
+      val response = HashMap<String, Any?>()
+      response["detections"] = detections
+      if (sharedArray != null) {
+        response["boxes"] = sharedArray
       }
-      return array.toArrayList()
+      response
     } catch (e: Exception) {
-       throw  Exception("Error processing barcode scanner: $e ")
+      throw Exception("Error processing barcode scanner: $e")
     }
   }
-
 }

package/android/src/main/java/com/visioncamerabarcodescanner/VisionCameraBarcodeScannerPackage.kt

@@ -10,10 +10,10 @@ import com.visioncameratextrecognition.VisionCameraTextRecognitionModule
 class VisionCameraBarcodeScannerPackage : ReactPackage {
   companion object {
     init {
-      FrameProcessorPluginRegistry.addFrameProcessorPlugin("scanBarcodes") {proxy,options ->
+      FrameProcessorPluginRegistry.addFrameProcessorPlugin("vinScannerBarcode") {proxy,options ->
         VisionCameraBarcodeScannerModule(proxy,options)
       }
-      FrameProcessorPluginRegistry.addFrameProcessorPlugin("scanText") { proxy, options ->
+      FrameProcessorPluginRegistry.addFrameProcessorPlugin("vinScannerText") { proxy, options ->
         VisionCameraTextRecognitionModule(proxy, options)
       }
     }

package/android/src/main/java/com/visioncameratextrecognition/VisionCameraTextRecognitionModule.kt

@@ -1,8 +1,6 @@
 package com.visioncameratextrecognition
 
 import android.media.Image
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
 import com.google.android.gms.tasks.Task
 import com.google.android.gms.tasks.Tasks
 import com.google.mlkit.vision.common.InputImage
@@ -14,114 +12,160 @@ 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.mrousavy.camera.frameprocessor.Frame
-import com.mrousavy.camera.frameprocessor.FrameProcessorPlugin
-import com.mrousavy.camera.frameprocessor.VisionCameraProxy
-import com.mrousavy.camera.types.Orientation
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.SharedArray
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.nio.ByteOrder
+import java.util.HashMap
 import java.util.ArrayList
 
+private const val TEXT_BOX_STRIDE = 12
 
-class VisionCameraTextRecognitionModule(proxy : VisionCameraProxy, options: Map<String, Any>?): FrameProcessorPlugin() {
-  private var recognizer: TextRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
-  private var language = options?.get("language").toString()
+class VisionCameraTextRecognitionModule(
+  private val proxy : VisionCameraProxy,
+  options: Map<String, Any>?
+): FrameProcessorPlugin() {
+  private var language = options?.get("language").toString().ifEmpty { "latin" }
+  private val recognizers = mutableMapOf<String, TextRecognizer>()
 
-  init {
-    recognizer = when (language) {
-      "latin" -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
-      "chinese" -> TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build())
-      "devanagari" -> TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build())
-      "japanese" -> TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build())
-      "korean" -> TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())
-      else -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+  private fun recognizerFor(languageCode: String): TextRecognizer {
+    return recognizers.getOrPut(languageCode) {
+      when (languageCode) {
+        "latin" -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+        "chinese" -> TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build())
+        "devanagari" -> TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build())
+        "japanese" -> TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build())
+        "korean" -> TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())
+        else -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+      }
+    }
+  }
+
+  private fun orientationToDegrees(orientation: String?): Int? {
+    return when (orientation) {
+      "portrait" -> 0
+      "portrait-upside-down" -> 180
+      "landscape-left" -> 90
+      "landscape-right" -> 270
+      else -> null
     }
   }
-  override fun callback(frame: Frame, arguments: Map<String, Any>?): ArrayList<Any> {
+
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
       try {
         val mediaImage: Image = frame.image
-        val orientation : Orientation = frame.orientation
-        val array = WritableNativeArray()
-        val image = InputImage.fromMediaImage(mediaImage, orientation.toDegrees())
+        val rotationOverride = orientationToDegrees(arguments?.get("orientation") as? String)
+        val rotationDegrees = rotationOverride ?: frame.imageProxy.imageInfo.rotationDegrees
+        val requestedLanguage = arguments?.get("language")?.toString()?.ifEmpty { null }
+        val effectiveLanguage = requestedLanguage ?: language
+        val recognizer = recognizerFor(effectiveLanguage)
+        val image = InputImage.fromMediaImage(mediaImage, rotationDegrees)
         val task: Task<Text> = recognizer.process(image)
         val result: Text? = Tasks.await(task)
-          val resultText = result?.text
-          for (block in result?.textBlocks!!) {
-            val map = WritableNativeMap()
-            map.putString("resultText",resultText)
-            val blockText = block.text
-            map.putString("blockText",blockText)
-            val blockCornerPoints = block.cornerPoints?.size
-            if (blockCornerPoints != null) {
-              map.putInt("size",blockCornerPoints)
-            }
-            val blockFrameBottom = block.boundingBox?.bottom
-            val blockFrameTop = block.boundingBox?.top
-            val blockFrameLeft = block.boundingBox?.left
-            val blockFrameRight = block.boundingBox?.right
-            if (blockFrameBottom != null) {
-              map.putInt("blockFrameBottom",blockFrameBottom)
-            }
-            if (blockFrameLeft != null) {
-              map.putInt("blockFrameLeft",blockFrameLeft)
-            }
-            if (blockFrameTop != null) {
-              map.putInt("blockFrameTop",blockFrameTop)
+        val resultText = result?.text
+        val detections = ArrayList<Map<String, Any?>>()
+        val boxValues = ArrayList<FloatArray>()
+
+        result?.textBlocks?.forEach { block ->
+          val blockBounds = block.boundingBox
+          if (block.lines.isEmpty()) {
+            val detection = HashMap<String, Any?>()
+            detection["resultText"] = resultText
+            detection["blockText"] = block.text
+            detection["boxIndex"] = boxValues.size
+            detections.add(detection)
+            boxValues.add(
+              floatArrayOf(
+                blockBounds?.top?.toFloat() ?: -1f,
+                blockBounds?.bottom?.toFloat() ?: -1f,
+                blockBounds?.left?.toFloat() ?: -1f,
+                blockBounds?.right?.toFloat() ?: -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+                -1f,
+              )
+            )
+          }
+          block.lines.forEach { line ->
+            if (line.elements.isEmpty()) {
+              val detection = HashMap<String, Any?>()
+              detection["resultText"] = resultText
+              detection["blockText"] = block.text
+              detection["lineText"] = line.text
+              detection["boxIndex"] = boxValues.size
+              detections.add(detection)
+              boxValues.add(
+                floatArrayOf(
+                  blockBounds?.top?.toFloat() ?: -1f,
+                  blockBounds?.bottom?.toFloat() ?: -1f,
+                  blockBounds?.left?.toFloat() ?: -1f,
+                  blockBounds?.right?.toFloat() ?: -1f,
+                  line.boundingBox?.top?.toFloat() ?: -1f,
+                  line.boundingBox?.bottom?.toFloat() ?: -1f,
+                  line.boundingBox?.left?.toFloat() ?: -1f,
+                  line.boundingBox?.right?.toFloat() ?: -1f,
+                  -1f,
+                  -1f,
+                  -1f,
+                  -1f,
+                )
+              )
             }
-            if (blockFrameRight != null) {
-              map.putInt("blockFrameRight",blockFrameRight)
+            line.elements.forEach { element ->
+              val detection = HashMap<String, Any?>()
+              detection["resultText"] = resultText
+              detection["blockText"] = block.text
+              detection["lineText"] = line.text
+              detection["elementText"] = element.text
+              detection["boxIndex"] = boxValues.size
+              detections.add(detection)
+              boxValues.add(
+                floatArrayOf(
+                  blockBounds?.top?.toFloat() ?: -1f,
+                  blockBounds?.bottom?.toFloat() ?: -1f,
+                  blockBounds?.left?.toFloat() ?: -1f,
+                  blockBounds?.right?.toFloat() ?: -1f,
+                  line.boundingBox?.top?.toFloat() ?: -1f,
+                  line.boundingBox?.bottom?.toFloat() ?: -1f,
+                  line.boundingBox?.left?.toFloat() ?: -1f,
+                  line.boundingBox?.right?.toFloat() ?: -1f,
+                  element.boundingBox?.top?.toFloat() ?: -1f,
+                  element.boundingBox?.bottom?.toFloat() ?: -1f,
+                  element.boundingBox?.left?.toFloat() ?: -1f,
+                  element.boundingBox?.right?.toFloat() ?: -1f,
+                )
+              )
             }
-            for (line in block.lines) {
-              val lineText = line.text
-              map.putString("lineText",lineText)
-              val lineCornerPoints = line.cornerPoints?.size
-              if (lineCornerPoints != null) {
-                map.putInt("size",lineCornerPoints)
-              }
-              val lineFrameBottom = line.boundingBox?.bottom
-              val lineFrameTop = line.boundingBox?.top
-              val lineFrameLeft = line.boundingBox?.left
-              val lineFrameRight = line.boundingBox?.right
-              if (lineFrameBottom != null) {
-                map.putInt("lineFrameBottom",lineFrameBottom)
-              }
-              if (lineFrameLeft != null) {
-                map.putInt("lineFrameLeft",lineFrameLeft)
-              }
-              if (lineFrameTop != null) {
-                map.putInt("lineFrameTop",lineFrameTop)
-              }
-              if (lineFrameRight != null) {
-                map.putInt("lineFrameRight",lineFrameRight)
-              }
-              for (element in line.elements) {
-                val elementText = element.text
-                map.putString("elementText",elementText)
-
-                val elementCornerPoints = line.cornerPoints?.size
-                if (elementCornerPoints != null) {
-                  map.putInt("size",elementCornerPoints)
-                }
-                val elementFrameBottom = line.boundingBox?.bottom
-                val elementFrameTop = line.boundingBox?.top
-                val elementFrameLeft = line.boundingBox?.left
-                val elementFrameRight = line.boundingBox?.right
-                if (elementFrameBottom != null) {
-                  map.putInt("elementFrameBottom",elementFrameBottom)
-                }
-                if (elementFrameLeft != null) {
-                  map.putInt("elementFrameLeft",elementFrameLeft)
-                }
-                if (elementFrameTop != null) {
-                  map.putInt("elementFrameTop",elementFrameTop)
-                }
-                if (elementFrameRight != null) {
-                  map.putInt("elementFrameRight",elementFrameRight)
-                }
-              }
-              array.pushMap(map)
+          }
+        }
 
+        val sharedArray =
+          if (boxValues.isNotEmpty()) SharedArray(proxy, boxValues.size * TEXT_BOX_STRIDE * java.lang.Float.BYTES)
+          else null
+        val floatBuffer = sharedArray?.byteBuffer
+          ?.order(ByteOrder.nativeOrder())
+          ?.asFloatBuffer()
+        floatBuffer?.let { buffer ->
+          boxValues.forEachIndexed { index, values ->
+            val floatIndex = index * TEXT_BOX_STRIDE
+            for (offset in 0 until TEXT_BOX_STRIDE) {
+              buffer.put(floatIndex + offset, values[offset])
             }
           }
-        return array.toArrayList()
+        }
+
+        val response = HashMap<String, Any?>()
+        response["detections"] = detections
+        if (sharedArray != null) {
+          response["boxes"] = sharedArray
+        }
+        return response
       } catch (e: Exception) {
        throw  Exception("Error processing text recognition: $e ")
       }