@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/android/src/main/java/com/trustchex/reactnativesdk/mlkit/MLKitModule.kt

@@ -0,0 +1,245 @@
+package com.trustchex.reactnativesdk.mlkit
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Base64
+import com.facebook.react.bridge.*
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import com.google.mlkit.vision.face.FaceDetection
+import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanner
+
+class MLKitModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName() = "MLKitModule"
+
+    private val textRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+    private val faceDetector = FaceDetection.getClient(
+        FaceDetectorOptions.Builder()
+            .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+            .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
+            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
+            .setMinFaceSize(0.1f)
+            .enableTracking()
+            .build()
+    )
+    private val barcodeScanner = BarcodeScanning.getClient(
+        BarcodeScannerOptions.Builder()
+            .setBarcodeFormats(Barcode.FORMAT_PDF417, Barcode.FORMAT_QR_CODE)
+            .build()
+    )
+
+    @ReactMethod
+    fun recognizeText(base64Image: String, promise: Promise) {
+        try {
+            val image = base64ToInputImage(base64Image)
+
+            textRecognizer.process(image)
+                .addOnSuccessListener { result ->
+                    val blocks = Arguments.createArray()
+
+                    for (block in result.textBlocks) {
+                        val blockMap = Arguments.createMap()
+                        blockMap.putString("text", block.text)
+
+                        val boundingBox = block.boundingBox
+                        if (boundingBox != null) {
+                            val box = Arguments.createMap()
+                            box.putInt("left", boundingBox.left)
+                            box.putInt("top", boundingBox.top)
+                            box.putInt("right", boundingBox.right)
+                            box.putInt("bottom", boundingBox.bottom)
+                            blockMap.putMap("boundingBox", box)
+                        }
+
+                        val cornerPoints = Arguments.createArray()
+                        block.cornerPoints?.forEach { point ->
+                            val pointMap = Arguments.createMap()
+                            pointMap.putInt("x", point.x)
+                            pointMap.putInt("y", point.y)
+                            cornerPoints.pushMap(pointMap)
+                        }
+                        blockMap.putArray("cornerPoints", cornerPoints)
+
+                        blocks.pushMap(blockMap)
+                    }
+
+                    promise.resolve(blocks)
+                }
+                .addOnFailureListener { e ->
+                    promise.reject("TEXT_RECOGNITION_ERROR", e.message)
+                }
+        } catch (e: Exception) {
+            promise.reject("TEXT_RECOGNITION_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun detectFaces(base64Image: String, promise: Promise) {
+        try {
+            val image = base64ToInputImage(base64Image)
+
+            faceDetector.process(image)
+                .addOnSuccessListener { faces ->
+                    val facesArray = Arguments.createArray()
+
+                    for (face in faces) {
+                        val faceMap = Arguments.createMap()
+
+                        val boundingBox = face.boundingBox
+                        val box = Arguments.createMap()
+                        box.putInt("left", boundingBox.left)
+                        box.putInt("top", boundingBox.top)
+                        box.putInt("right", boundingBox.right)
+                        box.putInt("bottom", boundingBox.bottom)
+                        box.putInt("width", boundingBox.width())
+                        box.putInt("height", boundingBox.height())
+                        faceMap.putMap("boundingBox", box)
+
+                        face.headEulerAngleY?.let { faceMap.putDouble("headEulerAngleY", it.toDouble()) }
+                        face.headEulerAngleZ?.let { faceMap.putDouble("headEulerAngleZ", it.toDouble()) }
+                        face.trackingId?.let { faceMap.putInt("trackingId", it) }
+
+                        facesArray.pushMap(faceMap)
+                    }
+
+                    promise.resolve(facesArray)
+                }
+                .addOnFailureListener { e ->
+                    promise.reject("FACE_DETECTION_ERROR", e.message)
+                }
+        } catch (e: Exception) {
+            promise.reject("FACE_DETECTION_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun scanBarcodes(base64Image: String, promise: Promise) {
+        try {
+            val image = base64ToInputImage(base64Image)
+
+            barcodeScanner.process(image)
+                .addOnSuccessListener { barcodes ->
+                    val barcodesArray = Arguments.createArray()
+
+                    for (barcode in barcodes) {
+                        val barcodeMap = Arguments.createMap()
+                        barcodeMap.putString("rawValue", barcode.rawValue)
+                        barcodeMap.putString("displayValue", barcode.displayValue)
+                        barcodeMap.putInt("format", barcode.format)
+
+                        val boundingBox = barcode.boundingBox
+                        if (boundingBox != null) {
+                            val box = Arguments.createMap()
+                            box.putInt("left", boundingBox.left)
+                            box.putInt("top", boundingBox.top)
+                            box.putInt("right", boundingBox.right)
+                            box.putInt("bottom", boundingBox.bottom)
+                            barcodeMap.putMap("boundingBox", box)
+                        }
+
+                        val cornerPoints = Arguments.createArray()
+                        barcode.cornerPoints?.forEach { point ->
+                            val pointMap = Arguments.createMap()
+                            pointMap.putInt("x", point.x)
+                            pointMap.putInt("y", point.y)
+                            cornerPoints.pushMap(pointMap)
+                        }
+                        barcodeMap.putArray("cornerPoints", cornerPoints)
+
+                        barcodesArray.pushMap(barcodeMap)
+                    }
+
+                    promise.resolve(barcodesArray)
+                }
+                .addOnFailureListener { e ->
+                    promise.reject("BARCODE_SCANNING_ERROR", e.message)
+                }
+        } catch (e: Exception) {
+            promise.reject("BARCODE_SCANNING_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun calculateBrightness(yPlaneBase64: String, width: Int, height: Int, promise: Promise) {
+        try {
+            val yPlane = Base64.decode(yPlaneBase64, Base64.NO_WRAP)
+            var sum = 0L
+            var count = 0
+            val totalPixels = width * height
+            val step = Math.max(1, totalPixels / 1000) // Sample ~1000 pixels
+
+            for (i in 0 until yPlane.size step step) {
+                sum += yPlane[i].toInt() and 0xFF
+                count++
+            }
+
+            val average = if (count > 0) sum.toDouble() / count else 0.0
+            promise.resolve(average)
+        } catch (e: Exception) {
+            promise.reject("BRIGHTNESS_CALCULATION_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun calculateBlur(yPlaneBase64: String, width: Int, height: Int, promise: Promise) {
+        try {
+            val yPlane = Base64.decode(yPlaneBase64, Base64.NO_WRAP)
+
+            // Laplacian variance for blur detection (matches Flutter implementation)
+            var sum = 0.0
+            var sumSq = 0.0
+            var count = 0
+
+            // Apply Laplacian kernel (simplified 3x3)
+            for (y in 1 until height - 1 step 4) { // Sample every 4th row for performance
+                for (x in 1 until width - 1 step 4) { // Sample every 4th column
+                    val idx = y * width + x
+                    if (idx + width + 1 < yPlane.size && idx - width - 1 >= 0) {
+                        val center = yPlane[idx].toInt() and 0xFF
+                        val top = yPlane[idx - width].toInt() and 0xFF
+                        val bottom = yPlane[idx + width].toInt() and 0xFF
+                        val left = yPlane[idx - 1].toInt() and 0xFF
+                        val right = yPlane[idx + 1].toInt() and 0xFF
+
+                        // Laplacian: 4*center - (top + bottom + left + right)
+                        val laplacian = 4 * center - (top + bottom + left + right)
+                        val value = laplacian.toDouble()
+
+                        sum += value
+                        sumSq += value * value
+                        count++
+                    }
+                }
+            }
+
+            if (count > 0) {
+                val mean = sum / count
+                val variance = (sumSq / count) - (mean * mean)
+                promise.resolve(variance)
+            } else {
+                promise.resolve(0.0)
+            }
+        } catch (e: Exception) {
+            promise.reject("BLUR_CALCULATION_ERROR", e.message)
+        }
+    }
+
+    private fun base64ToInputImage(base64: String): InputImage {
+        val imageBytes = Base64.decode(base64, Base64.NO_WRAP)
+        val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
+        return InputImage.fromBitmap(bitmap, 0)
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        textRecognizer.close()
+        faceDetector.close()
+        barcodeScanner.close()
+    }
+}