@trustchex/react-native-sdk 1.161.0

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/barcodescanner/BarcodeScannerFrameProcessorPlugin.kt

@@ -0,0 +1,301 @@
+package com.trustchex.reactnativesdk.visioncameraplugins.barcodescanner
+
+import android.graphics.ImageFormat
+import android.media.Image
+import android.util.Log
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.barcode.BarcodeScanner
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.common.InputImage
+import com.mrousavy.camera.core.FrameInvalidError
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.TimeUnit
+
+class BarcodeScannerFrameProcessorPlugin(
+        @Suppress("UNUSED_PARAMETER") proxy: VisionCameraProxy,
+        @Suppress("UNUSED_PARAMETER") options: Map<String, Any>?
+) : FrameProcessorPlugin() {
+
+  companion object {
+    private const val TAG = "BarcodeScannerFrameProcessorPlugin"
+    private var barcodeScanner: BarcodeScanner? = null
+    private var previousBarcodeScannerFormatsBitmap = -1
+  }
+
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any? {
+    Log.d(TAG, "callback called - Frame size: ${frame.width}x${frame.height}")
+
+    try {
+      val mediaImage: Image = frame.image
+
+      if (mediaImage.format != ImageFormat.YUV_420_888) {
+        Log.e(TAG, "Unsupported image format: ${mediaImage.format}. Only YUV_420_888 is supported.")
+        return emptyList<Map<String, Any>>()
+      }
+    } catch (e: FrameInvalidError) {
+      Log.e(TAG, "Received an invalid frame.")
+      return emptyList<Map<String, Any>>()
+    }
+
+    val inputImage = getInputImageFromFrame(frame)
+    if (inputImage == null) {
+      return emptyList<Map<String, Any>>()
+    }
+
+    val scanner = getBarcodeScannerClient(arguments)
+    val barcodes = mutableListOf<Map<String, Any>>()
+
+    try {
+      val barcodeList = Tasks.await(scanner.process(inputImage), 1000, TimeUnit.MILLISECONDS)
+      Log.d(TAG, "ML Kit returned ${barcodeList.size} barcodes")
+
+      barcodeList.forEach { barcode ->
+        Log.d(TAG, "Processing barcode: ${barcode.rawValue} (format: ${barcode.format})")
+        barcodes.add(convertBarcode(barcode))
+      }
+    } catch (e: ExecutionException) {
+      Log.e(TAG, "Error processing image for barcodes: ${e.message}")
+      return emptyList<Map<String, Any>>()
+    } catch (e: InterruptedException) {
+      Log.e(TAG, "Error processing image for barcodes: ${e.message}")
+      return emptyList<Map<String, Any>>()
+    }
+
+    Log.d(TAG, "Returning ${barcodes.size} processed barcodes")
+    return barcodes
+  }
+
+  private fun getInputImageFromFrame(frame: Frame): InputImage? {
+    return try {
+      val mediaImage: Image = frame.image
+      val orientation = getOrientation(frame.orientation)
+      InputImage.fromMediaImage(mediaImage, orientation)
+    } catch (e: FrameInvalidError) {
+      Log.e(TAG, "Received an invalid frame.")
+      null
+    }
+  }
+
+  @Synchronized
+  private fun getBarcodeScannerClient(arguments: Map<String, Any>?): BarcodeScanner {
+    val formatsBitmap = getFormatsBitmapFromParams(arguments)
+
+    if (barcodeScanner == null || previousBarcodeScannerFormatsBitmap != formatsBitmap) {
+      previousBarcodeScannerFormatsBitmap = formatsBitmap
+      val options = BarcodeScannerOptions.Builder().setBarcodeFormats(formatsBitmap).build()
+      barcodeScanner = BarcodeScanning.getClient(options)
+    }
+
+    return barcodeScanner!!
+  }
+
+  private fun getFormatsBitmapFromParams(arguments: Map<String, Any>?): Int {
+    if (arguments == null) return Barcode.FORMAT_ALL_FORMATS
+
+    val barcodeFormats = mutableSetOf<Int>()
+    val barcodeTypesObj = arguments["barcodeTypes"]
+
+    if (barcodeTypesObj is List<*>) {
+      barcodeTypesObj.forEach { type ->
+        val format = getFormat(type as? String)
+        if (format != null) {
+          barcodeFormats.add(format)
+        } else {
+          Log.e(TAG, "Unsupported barcode type: $type")
+        }
+      }
+    }
+
+    return if (barcodeFormats.isEmpty()) {
+      Barcode.FORMAT_ALL_FORMATS
+    } else {
+      barcodeFormatsToBitmap(barcodeFormats)
+    }
+  }
+
+  private fun barcodeFormatsToBitmap(barcodeFormats: Set<Int>): Int {
+    return barcodeFormats.fold(0) { acc, format -> acc or format }
+  }
+
+  private fun getFormat(type: String?): Int? {
+    return when (type) {
+      "code-128" -> Barcode.FORMAT_CODE_128
+      "code-39" -> Barcode.FORMAT_CODE_39
+      "code-93" -> Barcode.FORMAT_CODE_93
+      "data-matrix" -> Barcode.FORMAT_DATA_MATRIX
+      "ean-13" -> Barcode.FORMAT_EAN_13
+      "ean-8" -> Barcode.FORMAT_EAN_8
+      "upc-a" -> Barcode.FORMAT_UPC_A
+      "upc-e" -> Barcode.FORMAT_UPC_E
+      "qr" -> Barcode.FORMAT_QR_CODE
+      "aztec" -> Barcode.FORMAT_AZTEC
+      "codabar" -> Barcode.FORMAT_CODABAR
+      "itf" -> Barcode.FORMAT_ITF
+      "pdf-417" -> Barcode.FORMAT_PDF417
+      else -> null
+    }
+  }
+
+  private fun convertBarcode(barcode: Barcode): Map<String, Any> {
+    val map = mutableMapOf<String, Any>()
+
+    // Add the main value that JavaScript expects
+    barcode.rawValue?.let {
+      map["value"] = it
+      Log.d(TAG, "Converting barcode with value: $it")
+    }
+
+    // Add bounding box in the format expected by JavaScript
+    barcode.boundingBox?.let { bounds ->
+      Log.d(TAG, "Barcode bounding box: left=${bounds.left}, top=${bounds.top}, right=${bounds.right}, bottom=${bounds.bottom}")
+      val boundingBoxMap = mutableMapOf<String, Any>()
+      // Convert Android Rect to JavaScript format (origin + size)
+      val originMap = mutableMapOf<String, Any>()
+      originMap["x"] = bounds.left
+      originMap["y"] = bounds.top
+      boundingBoxMap["origin"] = originMap
+
+      val sizeMap = mutableMapOf<String, Any>()
+      sizeMap["width"] = bounds.right - bounds.left
+      sizeMap["height"] = bounds.bottom - bounds.top
+      boundingBoxMap["size"] = sizeMap
+
+      map["boundingBox"] = boundingBoxMap
+    } ?: run {
+      Log.d(TAG, "Barcode has no bounding box")
+    }
+
+    // Add corner points
+    barcode.cornerPoints?.let { corners ->
+      val cornerPointsList = mutableListOf<Map<String, Any>>()
+      corners.forEach { point ->
+        val pointMap = mutableMapOf<String, Any>()
+        pointMap["x"] = point.x
+        pointMap["y"] = point.y
+        cornerPointsList.add(pointMap)
+      }
+      map["cornerPoints"] = cornerPointsList
+    }
+
+    // Add display value
+    barcode.displayValue?.let { map["displayValue"] = it }
+
+    // Add raw value
+    barcode.rawValue?.let { map["rawValue"] = it }
+
+    // Add value type and format
+    map["type"] = barcode.valueType
+    map["format"] = barcode.format
+
+    // Add content based on value type
+    map["content"] = convertContent(barcode)
+
+    Log.d(TAG, "Converted barcode map keys: ${map.keys}")
+    return map
+  }
+
+  private fun convertContent(barcode: Barcode): Map<String, Any> {
+    val map = mutableMapOf<String, Any>()
+    map["type"] = barcode.valueType
+
+    when (barcode.valueType) {
+      Barcode.TYPE_UNKNOWN, Barcode.TYPE_ISBN, Barcode.TYPE_TEXT -> {
+        barcode.rawValue?.let { map["data"] = it }
+      }
+      Barcode.TYPE_CONTACT_INFO -> {
+        barcode.contactInfo?.let { contactInfo ->
+          val contactMap = mutableMapOf<String, Any>()
+          contactInfo.name?.let { name ->
+            val nameMap = mutableMapOf<String, Any>()
+            name.first?.let { nameMap["first"] = it }
+            name.formattedName?.let { nameMap["formattedName"] = it }
+            name.last?.let { nameMap["last"] = it }
+            name.middle?.let { nameMap["middle"] = it }
+            name.prefix?.let { nameMap["prefix"] = it }
+            name.pronunciation?.let { nameMap["pronunciation"] = it }
+            name.suffix?.let { nameMap["suffix"] = it }
+            contactMap["name"] = nameMap
+          }
+          contactInfo.organization?.let { contactMap["organization"] = it }
+          contactInfo.title?.let { contactMap["title"] = it }
+          // Add phones, emails, addresses if needed
+          map["data"] = contactMap
+        }
+      }
+      Barcode.TYPE_EMAIL -> {
+        barcode.email?.let { email ->
+          val emailMap = mutableMapOf<String, Any>()
+          email.address?.let { emailMap["address"] = it }
+          email.body?.let { emailMap["body"] = it }
+          email.subject?.let { emailMap["subject"] = it }
+          emailMap["type"] = email.type
+          map["data"] = emailMap
+        }
+      }
+      Barcode.TYPE_PHONE -> {
+        barcode.phone?.let { phone ->
+          val phoneMap = mutableMapOf<String, Any>()
+          phone.number?.let { phoneMap["number"] = it }
+          phoneMap["type"] = phone.type
+          map["data"] = phoneMap
+        }
+      }
+      Barcode.TYPE_SMS -> {
+        barcode.sms?.let { sms ->
+          val smsMap = mutableMapOf<String, Any>()
+          sms.message?.let { smsMap["message"] = it }
+          sms.phoneNumber?.let { smsMap["phoneNumber"] = it }
+          map["data"] = smsMap
+        }
+      }
+      Barcode.TYPE_URL -> {
+        barcode.url?.let { url ->
+          val urlMap = mutableMapOf<String, Any>()
+          url.title?.let { urlMap["title"] = it }
+          url.url?.let { urlMap["url"] = it }
+          map["data"] = urlMap
+        }
+      }
+      Barcode.TYPE_WIFI -> {
+        barcode.wifi?.let { wifi ->
+          val wifiMap = mutableMapOf<String, Any>()
+          wifiMap["encryptionType"] = wifi.encryptionType
+          wifi.password?.let { wifiMap["password"] = it }
+          wifi.ssid?.let { wifiMap["ssid"] = it }
+          map["data"] = wifiMap
+        }
+      }
+      Barcode.TYPE_GEO -> {
+        barcode.geoPoint?.let { geoPoint ->
+          val geoMap = mutableMapOf<String, Any>()
+          geoMap["lat"] = geoPoint.lat
+          geoMap["lng"] = geoPoint.lng
+          map["data"] = geoMap
+        }
+      }
+      else -> {
+        barcode.rawValue?.let { map["data"] = it }
+      }
+    }
+
+    return map
+  }
+
+  private fun getOrientation(orientation: com.mrousavy.camera.core.types.Orientation): Int {
+    return when (orientation) {
+      // device is landscape left
+      com.mrousavy.camera.core.types.Orientation.PORTRAIT -> 0
+      // device is portrait
+      com.mrousavy.camera.core.types.Orientation.LANDSCAPE_LEFT -> 270
+      // device is landscape right
+      com.mrousavy.camera.core.types.Orientation.PORTRAIT_UPSIDE_DOWN -> 180
+      // device is upside-down
+      com.mrousavy.camera.core.types.Orientation.LANDSCAPE_RIGHT -> 90
+    }
+  }
+}

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/cropper/BitmapUtils.kt

@@ -0,0 +1,205 @@
+package com.trustchex.reactnativesdk.visioncameraplugins.cropper
+
+import android.annotation.TargetApi
+import android.graphics.*
+import android.media.Image
+import android.os.Build
+import android.util.Base64
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.mrousavy.camera.core.FrameInvalidError
+import com.mrousavy.camera.core.types.Orientation
+import com.mrousavy.camera.frameprocessors.Frame
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.ByteBuffer
+
+/** Utility class for bitmap conversions and operations */
+object BitmapUtils {
+  private const val TAG = "BitmapUtils"
+
+  /** Converts NV21 format byte buffer to bitmap */
+  fun getBitmap(data: ByteBuffer, metadata: FrameMetadata): Bitmap? {
+    data.rewind()
+    val imageInBuffer = ByteArray(data.limit())
+    data.get(imageInBuffer, 0, imageInBuffer.size)
+
+    return try {
+      val image = YuvImage(imageInBuffer, ImageFormat.NV21, metadata.width, metadata.height, null)
+      val stream = ByteArrayOutputStream()
+      image.compressToJpeg(Rect(0, 0, metadata.width, metadata.height), 80, stream)
+
+      val bmp = BitmapFactory.decodeByteArray(stream.toByteArray(), 0, stream.size())
+      stream.close()
+
+      rotateBitmap(bmp, metadata.rotation, false, false)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error: ${e.message}")
+      null
+    }
+  }
+
+  /** Converts a YUV_420_888 image from Vision Camera API to a bitmap */
+  @Throws(FrameInvalidError::class)
+  fun getBitmap(image: Frame): Bitmap {
+    val degree = getRotationDegreeFromOrientation(image.orientation)
+    val frameMetadata = FrameMetadata(width = image.width, height = image.height, rotation = degree)
+
+    val nv21Buffer = yuv420ThreePlanesToNV21(image.image.planes, image.width, image.height)
+    return getBitmap(nv21Buffer, frameMetadata)
+            ?: throw FrameInvalidError()
+  }
+
+  fun getRotationDegreeFromOrientation(orientation: Orientation): Int {
+    return when (orientation) {
+      Orientation.PORTRAIT -> 0
+      Orientation.LANDSCAPE_LEFT -> 270
+      Orientation.LANDSCAPE_RIGHT -> 90
+      Orientation.PORTRAIT_UPSIDE_DOWN -> 180
+    }
+  }
+
+  /** Rotates a bitmap if it is converted from a bytebuffer */
+  fun rotateBitmap(bitmap: Bitmap, rotationDegrees: Int, flipX: Boolean, flipY: Boolean): Bitmap {
+    val matrix = Matrix()
+
+    // Rotate the image back to straight
+    matrix.postRotate(rotationDegrees.toFloat())
+
+    // Mirror the image along the X or Y axis
+    matrix.postScale(if (flipX) -1.0f else 1.0f, if (flipY) -1.0f else 1.0f)
+
+    val rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+
+    // Recycle the old bitmap if it has changed
+    if (rotatedBitmap != bitmap) {
+      bitmap.recycle()
+    }
+
+    return rotatedBitmap
+  }
+
+  /** Converts YUV_420_888 to NV21 bytebuffer */
+  @RequiresApi(Build.VERSION_CODES.KITKAT)
+  private fun yuv420ThreePlanesToNV21(
+          yuv420888planes: Array<Image.Plane>,
+          width: Int,
+          height: Int
+  ): ByteBuffer {
+    val imageSize = width * height
+    val out = ByteArray(imageSize + 2 * (imageSize / 4))
+
+    if (areUVPlanesNV21(yuv420888planes, width, height)) {
+      // Copy the Y values
+      yuv420888planes[0].buffer.get(out, 0, imageSize)
+
+      val uBuffer = yuv420888planes[1].buffer
+      val vBuffer = yuv420888planes[2].buffer
+
+      // Get the first V value from the V buffer, since the U buffer does not contain it
+      vBuffer.get(out, imageSize, 1)
+      // Copy the first U value and the remaining VU values from the U buffer
+      uBuffer.get(out, imageSize + 1, 2 * imageSize / 4 - 1)
+    } else {
+      // Fallback to copying the UV values one by one, which is slower but also works
+      // Unpack Y
+      unpackPlane(yuv420888planes[0], width, height, out, 0, 1)
+      // Unpack U
+      unpackPlane(yuv420888planes[1], width, height, out, imageSize + 1, 2)
+      // Unpack V
+      unpackPlane(yuv420888planes[2], width, height, out, imageSize, 2)
+    }
+
+    return ByteBuffer.wrap(out)
+  }
+
+  /** Checks if the UV plane buffers of a YUV_420_888 image are in the NV21 format */
+  @RequiresApi(Build.VERSION_CODES.KITKAT)
+  private fun areUVPlanesNV21(planes: Array<Image.Plane>, width: Int, height: Int): Boolean {
+    val imageSize = width * height
+
+    val uBuffer = planes[1].buffer
+    val vBuffer = planes[2].buffer
+
+    // Backup buffer properties
+    val vBufferPosition = vBuffer.position()
+    val uBufferLimit = uBuffer.limit()
+
+    // Advance the V buffer by 1 byte, since the U buffer will not contain the first V value
+    vBuffer.position(vBufferPosition + 1)
+    // Chop off the last byte of the U buffer, since the V buffer will not contain the last U value
+    uBuffer.limit(uBufferLimit - 1)
+
+    // Check that the buffers are equal and have the expected number of elements
+    val areNV21 =
+            (vBuffer.remaining() == (2 * imageSize / 4 - 2)) && (vBuffer.compareTo(uBuffer) == 0)
+
+    // Restore buffers to their initial state
+    vBuffer.position(vBufferPosition)
+    uBuffer.limit(uBufferLimit)
+
+    return areNV21
+  }
+
+  /** Unpack an image plane into a byte array */
+  @TargetApi(Build.VERSION_CODES.KITKAT)
+  private fun unpackPlane(
+          plane: Image.Plane,
+          width: Int,
+          height: Int,
+          out: ByteArray,
+          offset: Int,
+          pixelStride: Int
+  ) {
+    val buffer = plane.buffer
+    buffer.rewind()
+
+    // Compute the size of the current plane
+    // We assume that it has the aspect ratio as the original image
+    val numRow = (buffer.limit() + plane.rowStride - 1) / plane.rowStride
+    if (numRow == 0) {
+      return
+    }
+    val scaleFactor = height / numRow
+    val numCol = width / scaleFactor
+
+    // Extract the data in the output buffer
+    var outputPos = offset
+    var rowStart = 0
+    for (row in 0 until numRow) {
+      var inputPos = rowStart
+      for (col in 0 until numCol) {
+        out[outputPos] = buffer.get(inputPos)
+        outputPos += pixelStride
+        inputPos += plane.pixelStride
+      }
+      rowStart += plane.rowStride
+    }
+  }
+
+  fun base642Bitmap(base64: String): Bitmap {
+    val decode = Base64.decode(base64, Base64.DEFAULT)
+    return BitmapFactory.decodeByteArray(decode, 0, decode.size)
+  }
+
+  fun bitmap2Base64(bitmap: Bitmap): String {
+    val outputStream = ByteArrayOutputStream()
+    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream)
+    return Base64.encodeToString(outputStream.toByteArray(), Base64.DEFAULT)
+  }
+
+  fun saveImage(bmp: Bitmap, dir: File, fileName: String): String {
+    val file = File(dir, fileName)
+    return try {
+      val fos = FileOutputStream(file)
+      bmp.compress(Bitmap.CompressFormat.JPEG, 100, fos)
+      fos.flush()
+      fos.close()
+      file.absolutePath
+    } catch (e: Exception) {
+      e.printStackTrace()
+      ""
+    }
+  }
+}

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/cropper/CropperPlugin.kt

@@ -0,0 +1,72 @@
+package com.trustchex.reactnativesdk.visioncameraplugins.cropper
+
+import android.graphics.Bitmap
+import android.util.Log
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+
+class CropperPlugin(private val proxy: VisionCameraProxy, options: Map<String, Any>?) :
+        FrameProcessorPlugin() {
+
+  companion object {
+    var frameTaken: Bitmap? = null
+
+    fun getBitmap(): Bitmap? {
+      return try {
+        frameTaken
+      } catch (e: Exception) {
+        null
+      }
+    }
+  }
+
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): HashMap<String, Any?>? {
+    val result = HashMap<String, Any?>()
+
+    try {
+      var bitmap = BitmapUtils.getBitmap(frame)
+
+      // Handle crop region if provided
+      arguments?.get("cropRegion")?.let { cropRegionObj ->
+        @Suppress("UNCHECKED_CAST")
+        val cropRegion = cropRegionObj as? Map<String, Any> ?: return@let
+        val left = ((cropRegion["left"] as? Double ?: 0.0) / 100.0 * bitmap.width).toInt()
+        val top = ((cropRegion["top"] as? Double ?: 0.0) / 100.0 * bitmap.height).toInt()
+        val width = ((cropRegion["width"] as? Double ?: 100.0) / 100.0 * bitmap.width).toInt()
+        val height = ((cropRegion["height"] as? Double ?: 100.0) / 100.0 * bitmap.height).toInt()
+
+        bitmap = Bitmap.createBitmap(bitmap, left, top, width, height, null, false)
+      }
+
+      // Include base64 if requested
+      arguments?.get("includeImageBase64")?.let { includeBase64 ->
+        if (includeBase64 as? Boolean == true) {
+          result["base64"] = BitmapUtils.bitmap2Base64(bitmap)
+        }
+      }
+
+      // Save bitmap in memory if requested
+      arguments?.get("saveBitmap")?.let { saveBitmap ->
+        if (saveBitmap as? Boolean == true) {
+          frameTaken = bitmap
+        }
+      }
+
+      // Save as file if requested
+      arguments?.get("saveAsFile")?.let { saveAsFile ->
+        if (saveAsFile as? Boolean == true) {
+          val cacheDir = proxy.context.cacheDir
+          val fileName = "${System.currentTimeMillis()}.jpg"
+          val path = BitmapUtils.saveImage(bitmap, cacheDir, fileName)
+          result["path"] = path
+        }
+      }
+    } catch (e: Exception) {
+      Log.e("Cropper", "Error processing frame: ${e.message}")
+      throw RuntimeException(e)
+    }
+
+    return result
+  }
+}

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/cropper/FrameMetadata.kt

@@ -0,0 +1,4 @@
+package com.trustchex.reactnativesdk.visioncameraplugins.cropper
+
+/** Data class to hold frame metadata information */
+data class FrameMetadata(val width: Int, val height: Int, val rotation: Int)