mediversal-rn-image-intelligence 1.0.6

package/android/src/main/java/com/mediversalrnimagintelligence/ImageIntelligencePackage.kt

@@ -0,0 +1,20 @@
+package com.mediversalrnimagintelligence
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ImageIntelligencePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(
+            FaceDetectionModule(reactContext),
+            TextRecognitionModule(reactContext),
+            HandwritingRecognitionModule(reactContext)
+        )
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/java/com/mediversalrnimagintelligence/TextRecognitionModule.kt

@@ -0,0 +1,86 @@
+package com.mediversalrnimagintelligence
+
+import android.net.Uri
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import java.io.IOException
+
+class TextRecognitionModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String {
+        return "TextRecognitionModule"
+    }
+
+    @ReactMethod
+    fun recognizeText(imageUri: String, promise: Promise) {
+        try {
+            // Parse the image from URI
+            val image = parseImageFromUri(imageUri)
+            
+            // Get text recognizer instance
+            val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+
+            // Process the image
+            recognizer.process(image)
+                .addOnSuccessListener { visionText ->
+                    val result = Arguments.createMap()
+                    val text = visionText.text
+                    
+                    if (text.isNotEmpty()) {
+                        result.putString("text", text)
+                    } else {
+                        result.putString("text", "")
+                    }
+                    
+                    promise.resolve(result)
+                }
+                .addOnFailureListener { e ->
+                    val result = Arguments.createMap()
+                    result.putString("text", "")
+                    result.putString("error", e.message ?: "Text recognition failed")
+                    promise.resolve(result)
+                }
+
+        } catch (e: Exception) {
+            val result = Arguments.createMap()
+            result.putString("text", "")
+            result.putString("error", e.message ?: "Failed to process image")
+            promise.resolve(result)
+        }
+    }
+
+    private fun parseImageFromUri(uriString: String): InputImage {
+        val context = reactApplicationContext
+        
+        return try {
+            when {
+                uriString.startsWith("file://") -> {
+                    val uri = Uri.parse(uriString)
+                    InputImage.fromFilePath(context, uri)
+                }
+                uriString.startsWith("content://") -> {
+                    val uri = Uri.parse(uriString)
+                    InputImage.fromFilePath(context, uri)
+                }
+                uriString.startsWith("/") -> {
+                    // Absolute file path
+                    val uri = Uri.parse("file://$uriString")
+                    InputImage.fromFilePath(context, uri)
+                }
+                else -> {
+                    throw IOException("Unsupported URI format: $uriString")
+                }
+            }
+        } catch (e: IOException) {
+            throw IOException("Failed to load image from URI: ${e.message}")
+        }
+    }
+}

package/ios/FaceDetectionModule.m

@@ -0,0 +1,16 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(FaceDetectionModule, NSObject)
+
+RCT_EXTERN_METHOD(detectFaces:(NSString *)imageUri
+                  mode:(NSString *)mode
+                  minFaceSize:(nonnull NSNumber *)minFaceSize
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/FaceDetectionModule.swift

@@ -0,0 +1,164 @@
+import Foundation
+import MLKitFaceDetection
+import MLKitVision
+
+@objc(FaceDetectionModule)
+class FaceDetectionModule: NSObject {
+    
+    @objc
+    func detectFaces(
+        _ imageUri: String,
+        mode: String,
+        minFaceSize: NSNumber,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                // Parse image from URI
+                guard let image = self.parseImageFromUri(imageUri) else {
+                    let result: [String: Any] = [
+                        "faces": [],
+                        "error": "Failed to load image from URI"
+                    ]
+                    DispatchQueue.main.async {
+                        resolve(result)
+                    }
+                    return
+                }
+                
+                let visionImage = VisionImage(image: image)
+                visionImage.orientation = image.imageOrientation
+                
+                // Configure face detector
+                let options = FaceDetectorOptions()
+                
+                if mode == "accurate" {
+                    options.performanceMode = .accurate
+                    options.landmarkMode = .all
+                    options.classificationMode = .all
+                    options.isTrackingEnabled = true
+                } else {
+                    options.performanceMode = .fast
+                    options.classificationMode = .all
+                }
+                
+                options.minFaceSize = CGFloat(truncating: minFaceSize)
+                
+                let faceDetector = FaceDetector.faceDetector(options: options)
+                
+                // Detect faces
+                faceDetector.process(visionImage) { faces, error in
+                    if let error = error {
+                        let result: [String: Any] = [
+                            "faces": [],
+                            "error": error.localizedDescription
+                        ]
+                        DispatchQueue.main.async {
+                            resolve(result)
+                        }
+                        return
+                    }
+                    
+                    guard let faces = faces, !faces.isEmpty else {
+                        let result: [String: Any] = ["faces": []]
+                        DispatchQueue.main.async {
+                            resolve(result)
+                        }
+                        return
+                    }
+                    
+                    // Convert faces to array of dictionaries
+                    let facesArray = faces.map { self.convertFaceToDict($0) }
+                    let result: [String: Any] = ["faces": facesArray]
+                    
+                    DispatchQueue.main.async {
+                        resolve(result)
+                    }
+                }
+                
+            } catch {
+                let result: [String: Any] = [
+                    "faces": [],
+                    "error": error.localizedDescription
+                ]
+                DispatchQueue.main.async {
+                    resolve(result)
+                }
+            }
+        }
+    }
+    
+    private func parseImageFromUri(_ uriString: String) -> UIImage? {
+        var path = uriString
+        
+        // Remove file:// prefix if present
+        if path.hasPrefix("file://") {
+            path = String(path.dropFirst(7))
+        }
+        
+        // Handle different URI formats
+        if path.hasPrefix("ph://") || path.hasPrefix("assets-library://") {
+            // Photo library assets - would need PHAsset loading
+            // For simplicity, return nil here (would need Photos framework integration)
+            return nil
+        }
+        
+        // Load from file path
+        if FileManager.default.fileExists(atPath: path) {
+            return UIImage(contentsOfFile: path)
+        }
+        
+        return nil
+    }
+    
+    private func convertFaceToDict(_ face: Face) -> [String: Any] {
+        var faceDict: [String: Any] = [:]
+        
+        // Bounding box
+        let frame = face.frame
+        let boundingBox: [String: Any] = [
+            "x": Int(frame.origin.x),
+            "y": Int(frame.origin.y),
+            "width": Int(frame.size.width),
+            "height": Int(frame.size.height)
+        ]
+        faceDict["boundingBox"] = boundingBox
+        
+        // Smiling probability
+        if face.hasSmilingProbability {
+            faceDict["smilingProbability"] = face.smilingProbability
+        }
+        
+        // Left eye open probability
+        if face.hasLeftEyeOpenProbability {
+            faceDict["leftEyeOpenProbability"] = face.leftEyeOpenProbability
+        }
+        
+        // Right eye open probability
+        if face.hasRightEyeOpenProbability {
+            faceDict["rightEyeOpenProbability"] = face.rightEyeOpenProbability
+        }
+        
+        // Head Euler angles
+        if face.hasHeadEulerAngleY {
+            faceDict["headEulerAngleY"] = face.headEulerAngleY
+        }
+        
+        if face.hasHeadEulerAngleZ {
+            faceDict["headEulerAngleZ"] = face.headEulerAngleZ
+        }
+        
+        // Tracking ID
+        if face.hasTrackingID {
+            faceDict["trackingId"] = face.trackingID
+        }
+        
+        return faceDict
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+}

package/ios/HandwritingRecognitionModule.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(HandwritingRecognitionModule, NSObject)
+
+RCT_EXTERN_METHOD(recognizeHandwriting:(NSString *)imageUri
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/HandwritingRecognitionModule.swift

@@ -0,0 +1,53 @@
+import Foundation
+import MLKitDigitalInkRecognition
+import MLKitVision
+
+@objc(HandwritingRecognitionModule)
+class HandwritingRecognitionModule: NSObject {
+    
+    @objc
+    func recognizeHandwriting(
+        _ imageUri: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            // Note: Digital Ink Recognition in ML Kit is designed for real-time stroke data,
+            // not static images. For production use with static images, you would need to:
+            // 1. Use a different API (like Cloud Vision API's handwriting detection)
+            // 2. Or pre-process the image to extract strokes
+            //
+            // For this implementation, we'll provide a graceful fallback indicating
+            // that handwriting recognition from static images is not fully supported
+            // by the on-device Digital Ink API.
+            
+            let result: [String: Any] = [
+                "text": "",
+                "error": "Digital Ink Recognition requires stroke data, not static images. " +
+                        "For handwriting in static images, consider using Cloud Vision API or " +
+                        "preprocessing to extract stroke information."
+            ]
+            resolve(result)
+            
+            // Alternative implementation note:
+            // If you have stroke data (from a drawing canvas), the proper implementation would be:
+            // 1. Create an Ink object from strokes
+            // 2. Get recognizer with appropriate model identifier
+            // 3. Call recognizer.recognize(ink)
+            //
+            // Example (commented out as it requires stroke data):
+            // let identifier = DigitalInkRecognitionModelIdentifier(forLanguageTag: "en-US")
+            // let model = DigitalInkRecognitionModel.modelIdentifier(identifier!)
+            // let options = DigitalInkRecognizerOptions(model: model)
+            // let recognizer = DigitalInkRecognizer.digitalInkRecognizer(options: options)
+            // recognizer.recognize(ink: ink) { result, error in
+            //     // Process recognition candidates
+            // }
+        }
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+}

package/ios/TextRecognitionModule.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(TextRecognitionModule, NSObject)
+
+RCT_EXTERN_METHOD(recognizeText:(NSString *)imageUri
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/TextRecognitionModule.swift

@@ -0,0 +1,102 @@
+import Foundation
+import MLKitTextRecognition
+import MLKitVision
+
+@objc(TextRecognitionModule)
+class TextRecognitionModule: NSObject {
+    
+    @objc
+    func recognizeText(
+        _ imageUri: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                // Parse image from URI
+                guard let image = self.parseImageFromUri(imageUri) else {
+                    let result: [String: Any] = [
+                        "text": "",
+                        "error": "Failed to load image from URI"
+                    ]
+                    DispatchQueue.main.async {
+                        resolve(result)
+                    }
+                    return
+                }
+                
+                let visionImage = VisionImage(image: image)
+                visionImage.orientation = image.imageOrientation
+                
+                // Create text recognizer
+                let options = TextRecognizerOptions()
+                let textRecognizer = TextRecognizer.textRecognizer(options: options)
+                
+                // Recognize text
+                textRecognizer.process(visionImage) { result, error in
+                    if let error = error {
+                        let errorResult: [String: Any] = [
+                            "text": "",
+                            "error": error.localizedDescription
+                        ]
+                        DispatchQueue.main.async {
+                            resolve(errorResult)
+                        }
+                        return
+                    }
+                    
+                    guard let result = result else {
+                        let emptyResult: [String: Any] = ["text": ""]
+                        DispatchQueue.main.async {
+                            resolve(emptyResult)
+                        }
+                        return
+                    }
+                    
+                    let recognizedText = result.text
+                    let successResult: [String: Any] = ["text": recognizedText]
+                    
+                    DispatchQueue.main.async {
+                        resolve(successResult)
+                    }
+                }
+                
+            } catch {
+                let result: [String: Any] = [
+                    "text": "",
+                    "error": error.localizedDescription
+                ]
+                DispatchQueue.main.async {
+                    resolve(result)
+                }
+            }
+        }
+    }
+    
+    private func parseImageFromUri(_ uriString: String) -> UIImage? {
+        var path = uriString
+        
+        // Remove file:// prefix if present
+        if path.hasPrefix("file://") {
+            path = String(path.dropFirst(7))
+        }
+        
+        // Handle different URI formats
+        if path.hasPrefix("ph://") || path.hasPrefix("assets-library://") {
+            // Photo library assets - would need PHAsset loading
+            return nil
+        }
+        
+        // Load from file path
+        if FileManager.default.fileExists(atPath: path) {
+            return UIImage(contentsOfFile: path)
+        }
+        
+        return nil
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+}

package/lib/commonjs/NativeFaceDetectionModule.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+/**
+ * Face Detection TurboModule Specification
+ */
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('FaceDetectionModule');
+//# sourceMappingURL=NativeFaceDetectionModule.js.map

package/lib/commonjs/NativeFaceDetectionModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeFaceDetectionModule.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAGA;AACA;AACA;AAFA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAWeC,gCAAmB,CAACC,YAAY,CAC7C,qBACF,CAAC","ignoreList":[]}

package/lib/commonjs/NativeHandwritingRecognitionModule.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+/**
+ * Handwriting Recognition TurboModule Specification
+ */
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('HandwritingRecognitionModule');
+//# sourceMappingURL=NativeHandwritingRecognitionModule.js.map

package/lib/commonjs/NativeHandwritingRecognitionModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeHandwritingRecognitionModule.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAGA;AACA;AACA;AAFA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GASeC,gCAAmB,CAACC,YAAY,CAC7C,8BACF,CAAC","ignoreList":[]}

package/lib/commonjs/NativeTextRecognitionModule.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+/**
+ * Text Recognition TurboModule Specification
+ */
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('TextRecognitionModule');
+//# sourceMappingURL=NativeTextRecognitionModule.js.map

package/lib/commonjs/NativeTextRecognitionModule.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeTextRecognitionModule.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAGA;AACA;AACA;AAFA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAOeC,gCAAmB,CAACC,YAAY,CAC7C,uBACF,CAAC","ignoreList":[]}