@trustchex/react-native-sdk 1.161.0

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/facedetector/FaceDetectorFrameProcessorPlugin.kt

@@ -0,0 +1,303 @@
+package com.trustchex.reactnativesdk.visioncameraplugins.facedetector
+
+import android.graphics.Rect
+import android.util.Log
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.face.*
+import com.mrousavy.camera.core.FrameInvalidError
+import com.mrousavy.camera.core.types.Orientation
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+
+class FaceDetectorFrameProcessorPlugin(options: Map<String, Any>?) :
+        FrameProcessorPlugin() {
+
+  // Detection properties
+  private var autoScale = false
+  private var faceDetector: FaceDetector? = null
+  private var runLandmarks = false
+  private var runClassifications = false
+  private var runContours = false
+  private var trackingEnabled = false
+  private var windowWidth = 1.0
+  private var windowHeight = 1.0
+
+  init {
+    // Handle auto scaling and window dimensions
+    autoScale = options?.get("autoScale").toString() == "true"
+    windowWidth = (options?.get("windowWidth") ?: 1.0) as Double
+    windowHeight = (options?.get("windowHeight") ?: 1.0) as Double
+
+    // Initialize faceDetector on creation
+    var performanceModeValue = FaceDetectorOptions.PERFORMANCE_MODE_FAST
+    var landmarkModeValue = FaceDetectorOptions.LANDMARK_MODE_NONE
+    var classificationModeValue = FaceDetectorOptions.CLASSIFICATION_MODE_NONE
+    var contourModeValue = FaceDetectorOptions.CONTOUR_MODE_NONE
+
+    if (options?.get("performanceMode").toString() == "accurate") {
+      performanceModeValue = FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE
+    }
+
+    if (options?.get("landmarkMode").toString() == "all") {
+      runLandmarks = true
+      landmarkModeValue = FaceDetectorOptions.LANDMARK_MODE_ALL
+    }
+
+    if (options?.get("classificationMode").toString() == "all") {
+      runClassifications = true
+      classificationModeValue = FaceDetectorOptions.CLASSIFICATION_MODE_ALL
+    }
+
+    if (options?.get("contourMode").toString() == "all") {
+      runContours = true
+      contourModeValue = FaceDetectorOptions.CONTOUR_MODE_ALL
+    }
+
+    val minFaceSize: Double = (options?.get("minFaceSize") ?: 0.15) as Double
+    val optionsBuilder = FaceDetectorOptions.Builder()
+      .setPerformanceMode(performanceModeValue)
+      .setLandmarkMode(landmarkModeValue)
+      .setContourMode(contourModeValue)
+      .setClassificationMode(classificationModeValue)
+      .setMinFaceSize(minFaceSize.toFloat())
+
+    if (options?.get("trackingEnabled").toString() == "true") {
+      trackingEnabled = true
+      optionsBuilder.enableTracking()
+    }
+
+    faceDetector = FaceDetection.getClient(optionsBuilder.build())
+  }
+
+  override fun callback(frame: Frame, params: Map<String, Any>?): Any {
+    val result = ArrayList<Map<String, Any>>()
+
+    try {
+      val orientation = getOrientation(frame.orientation)
+      val image = InputImage.fromMediaImage(frame.image, orientation)
+      // We need to invert sizes as frame is always -90deg rotated
+      val width = image.height.toDouble()
+      val height = image.width.toDouble()
+      val scaleX = if(autoScale) windowWidth / width else 1.0
+      val scaleY = if(autoScale) windowHeight / height else 1.0
+
+      val task = faceDetector!!.process(image)
+      val faces = Tasks.await(task)
+
+      Log.d(TAG, "Detected ${faces.size} faces")
+
+      faces.forEach { face ->
+        val map: MutableMap<String, Any> = HashMap()
+
+        if (runLandmarks) {
+          map["landmarks"] = processLandmarks(face, scaleX, scaleY)
+        }
+
+        if (runClassifications) {
+          map["leftEyeOpenProbability"] = face.leftEyeOpenProbability?.toDouble() ?: -1
+          map["rightEyeOpenProbability"] = face.rightEyeOpenProbability?.toDouble() ?: -1
+          map["smilingProbability"] = face.smilingProbability?.toDouble() ?: -1
+        }
+
+        if (runContours) {
+          map["contours"] = processFaceContours(face, scaleX, scaleY)
+        }
+
+        if (trackingEnabled) {
+          map["trackingId"] = face.trackingId ?: -1
+        }
+
+        map["rollAngle"] = face.headEulerAngleZ.toDouble()
+        map["pitchAngle"] = face.headEulerAngleX.toDouble()
+        map["yawAngle"] = face.headEulerAngleY.toDouble()
+        map["bounds"] = processBoundingBox(
+          face.boundingBox,
+          width,
+          height,
+          frame.orientation,
+          scaleX,
+          scaleY
+        )
+        result.add(map)
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error processing face detection: ", e)
+    } catch (e: FrameInvalidError) {
+      Log.e(TAG, "Frame invalid error: ", e)
+    }
+
+    return result
+  }
+
+  private fun processBoundingBox(
+    boundingBox: Rect,
+    sourceWidth: Double,
+    sourceHeight: Double,
+    orientation: Orientation,
+    scaleX: Double,
+    scaleY: Double
+  ): Map<String, Any> {
+    val bounds: MutableMap<String, Any> = HashMap()
+    val width = boundingBox.width().toDouble() * scaleX
+    val height = boundingBox.height().toDouble() * scaleY
+    val x = boundingBox.left.toDouble() * scaleX
+    val y = boundingBox.top.toDouble() * scaleY
+
+    when(orientation) {
+      Orientation.PORTRAIT -> {
+        // device is landscape left
+        bounds["x"] = (-y + sourceWidth * scaleX) - width
+        bounds["y"] = (-x + sourceHeight * scaleY) - height
+      }
+      Orientation.LANDSCAPE_LEFT -> {
+        // device is portrait
+        bounds["x"] = (-x + sourceWidth * scaleX) - width
+        bounds["y"] = y
+      }
+      Orientation.PORTRAIT_UPSIDE_DOWN -> {
+        // device is landscape right
+        bounds["x"] = y
+        bounds["y"] = x
+      }
+      Orientation.LANDSCAPE_RIGHT -> {
+        // device is upside down
+        bounds["x"] = x
+        bounds["y"] = (-y + sourceHeight * scaleY) - height
+      }
+    }
+
+    bounds["width"] = width
+    bounds["height"] = height
+    return bounds
+  }
+
+  private fun processLandmarks(
+    face: Face,
+    scaleX: Double,
+    scaleY: Double
+  ): Map<String, Any> {
+    val faceLandmarksTypes = intArrayOf(
+      FaceLandmark.LEFT_CHEEK,
+      FaceLandmark.LEFT_EAR,
+      FaceLandmark.LEFT_EYE,
+      FaceLandmark.MOUTH_BOTTOM,
+      FaceLandmark.MOUTH_LEFT,
+      FaceLandmark.MOUTH_RIGHT,
+      FaceLandmark.NOSE_BASE,
+      FaceLandmark.RIGHT_CHEEK,
+      FaceLandmark.RIGHT_EAR,
+      FaceLandmark.RIGHT_EYE
+    )
+    val faceLandmarksTypesStrings = arrayOf(
+      "LEFT_CHEEK",
+      "LEFT_EAR",
+      "LEFT_EYE",
+      "MOUTH_BOTTOM",
+      "MOUTH_LEFT",
+      "MOUTH_RIGHT",
+      "NOSE_BASE",
+      "RIGHT_CHEEK",
+      "RIGHT_EAR",
+      "RIGHT_EYE"
+    )
+    val faceLandmarksTypesMap: MutableMap<String, Any> = HashMap()
+    for (i in faceLandmarksTypesStrings.indices) {
+      val landmark = face.getLandmark(faceLandmarksTypes[i])
+      val landmarkName = faceLandmarksTypesStrings[i]
+      Log.d(TAG, "Getting '$landmarkName' landmark")
+      if (landmark == null) {
+        Log.d(TAG, "Landmark '$landmarkName' is null - going next")
+        continue
+      }
+      val point = landmark.position
+      val currentPointsMap: MutableMap<String, Double> = HashMap()
+      currentPointsMap["x"] = point.x.toDouble() * scaleX
+      currentPointsMap["y"] = point.y.toDouble() * scaleY
+      faceLandmarksTypesMap[landmarkName] = currentPointsMap
+    }
+
+    return faceLandmarksTypesMap
+  }
+
+  private fun processFaceContours(
+    face: Face,
+    scaleX: Double,
+    scaleY: Double
+  ): Map<String, Any> {
+    val faceContoursTypes = intArrayOf(
+      FaceContour.FACE,
+      FaceContour.LEFT_CHEEK,
+      FaceContour.LEFT_EYE,
+      FaceContour.LEFT_EYEBROW_BOTTOM,
+      FaceContour.LEFT_EYEBROW_TOP,
+      FaceContour.LOWER_LIP_BOTTOM,
+      FaceContour.LOWER_LIP_TOP,
+      FaceContour.NOSE_BOTTOM,
+      FaceContour.NOSE_BRIDGE,
+      FaceContour.RIGHT_CHEEK,
+      FaceContour.RIGHT_EYE,
+      FaceContour.RIGHT_EYEBROW_BOTTOM,
+      FaceContour.RIGHT_EYEBROW_TOP,
+      FaceContour.UPPER_LIP_BOTTOM,
+      FaceContour.UPPER_LIP_TOP
+    )
+    val faceContoursTypesStrings = arrayOf(
+      "FACE",
+      "LEFT_CHEEK",
+      "LEFT_EYE",
+      "LEFT_EYEBROW_BOTTOM",
+      "LEFT_EYEBROW_TOP",
+      "LOWER_LIP_BOTTOM",
+      "LOWER_LIP_TOP",
+      "NOSE_BOTTOM",
+      "NOSE_BRIDGE",
+      "RIGHT_CHEEK",
+      "RIGHT_EYE",
+      "RIGHT_EYEBROW_BOTTOM",
+      "RIGHT_EYEBROW_TOP",
+      "UPPER_LIP_BOTTOM",
+      "UPPER_LIP_TOP"
+    )
+    val faceContoursTypesMap: MutableMap<String, Any> = HashMap()
+    for (i in faceContoursTypesStrings.indices) {
+      val contour = face.getContour(faceContoursTypes[i])
+      val contourName = faceContoursTypesStrings[i]
+      Log.d(TAG, "Getting '$contourName' contour")
+      if (contour == null) {
+        Log.d(TAG, "Face contour '$contourName' is null - going next")
+        continue
+      }
+      val points = contour.points
+      val pointsMap: MutableMap<String, Map<String, Double>> = HashMap()
+      for (j in points.indices) {
+        val currentPointsMap: MutableMap<String, Double> = HashMap()
+        currentPointsMap["x"] = points[j].x.toDouble() * scaleX
+        currentPointsMap["y"] = points[j].y.toDouble() * scaleY
+        pointsMap[j.toString()] = currentPointsMap
+      }
+
+      faceContoursTypesMap[contourName] = pointsMap
+    }
+    return faceContoursTypesMap
+  }
+
+  private fun getOrientation(
+    orientation: Orientation
+  ): Int {
+    return when (orientation) {
+      // device is landscape left
+      Orientation.PORTRAIT -> 0
+      // device is portrait
+      Orientation.LANDSCAPE_LEFT -> 270
+      // device is landscape right
+      Orientation.PORTRAIT_UPSIDE_DOWN -> 180
+      // device is upside-down
+      Orientation.LANDSCAPE_RIGHT -> 90
+    }
+  }
+
+  companion object {
+    private const val TAG = "FaceDetectorFrameProcessorPlugin"
+  }
+}

package/android/src/main/java/com/trustchex/reactnativesdk/visioncameraplugins/textrecognition/TextRecognitionFrameProcessorPlugin.kt

@@ -0,0 +1,115 @@
+package com.trustchex.reactnativesdk.visioncameraplugins.textrecognition
+
+import android.graphics.Point
+import android.graphics.Rect
+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
+import com.google.mlkit.vision.text.Text
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+import java.util.HashMap
+
+class TextRecognitionFrameProcessorPlugin(proxy: VisionCameraProxy, options: Map<String, Any>?) :
+    FrameProcessorPlugin() {
+
+    private var recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+
+    override fun callback(frame: Frame, arguments: Map<String, Any>?): HashMap<String, Any?>? {
+        val data = WritableNativeMap()
+        val mediaImage: Image = frame.image
+        val image =
+            InputImage.fromMediaImage(mediaImage, frame.imageProxy.imageInfo.rotationDegrees)
+        val task: Task<Text> = recognizer.process(image)
+        try {
+            val text: Text = Tasks.await(task)
+            if (text.text.isEmpty()) {
+                return WritableNativeMap().toHashMap()
+            }
+            data.putString("resultText", text.text)
+            data.putArray("blocks", getBlocks(text.textBlocks))
+            return data.toHashMap()
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return null
+        }
+    }
+
+    companion object {
+        fun getBlocks(blocks: MutableList<Text.TextBlock>): WritableNativeArray {
+            val blockArray = WritableNativeArray()
+            blocks.forEach { block ->
+                val blockMap = WritableNativeMap().apply {
+                    putString("blockText", block.text)
+                    putArray("blockCornerPoints", block.cornerPoints?.let { getCornerPoints(it) })
+                    putMap("blockFrame", getFrame(block.boundingBox))
+                    putArray("lines", getLines(block.lines))
+                }
+                blockArray.pushMap(blockMap)
+            }
+            return blockArray
+        }
+
+        private fun getLines(lines: MutableList<Text.Line>): WritableNativeArray {
+            val lineArray = WritableNativeArray()
+            lines.forEach { line ->
+                val lineMap = WritableNativeMap().apply {
+                    putString("lineText", line.text)
+                    putArray("lineCornerPoints", line.cornerPoints?.let { getCornerPoints(it) })
+                    putMap("lineFrame", getFrame(line.boundingBox))
+                    putArray(
+                        "lineLanguages",
+                        WritableNativeArray().apply { pushString(line.recognizedLanguage) })
+                    putArray("elements", getElements(line.elements))
+                }
+                lineArray.pushMap(lineMap)
+            }
+            return lineArray
+        }
+
+        private fun getElements(elements: MutableList<Text.Element>): WritableNativeArray {
+            val elementArray = WritableNativeArray()
+            elements.forEach { element ->
+                val elementMap = WritableNativeMap().apply {
+                    putString("elementText", element.text)
+                    putArray(
+                        "elementCornerPoints",
+                        element.cornerPoints?.let { getCornerPoints(it) })
+                    putMap("elementFrame", getFrame(element.boundingBox))
+                }
+                elementArray.pushMap(elementMap)
+            }
+            return elementArray
+        }
+
+        private fun getCornerPoints(points: Array<Point>): WritableNativeArray {
+            val cornerPoints = WritableNativeArray()
+            points.forEach { point ->
+                cornerPoints.pushMap(WritableNativeMap().apply {
+                    putInt("x", point.x)
+                    putInt("y", point.y)
+                })
+            }
+            return cornerPoints
+        }
+
+        private fun getFrame(boundingBox: Rect?): WritableNativeMap {
+            return WritableNativeMap().apply {
+                boundingBox?.let {
+                    putDouble("x", it.exactCenterX().toDouble())
+                    putDouble("y", it.exactCenterY().toDouble())
+                    putInt("width", it.width())
+                    putInt("height", it.height())
+                    putInt("boundingCenterX", it.centerX())
+                    putInt("boundingCenterY", it.centerY())
+                }
+            }
+        }
+    }
+}

package/ios/TrustchexSDK.h

@@ -0,0 +1,5 @@
+#import <TrustchexSDKSpec/TrustchexSDKSpec.h>
+
+@interface TrustchexSDK : NSObject <NativeTrustchexSDKSpec>
+
+@end

package/ios/TrustchexSDK.mm

@@ -0,0 +1,28 @@
+#import "TrustchexSDK.h"
+#import <UIKit/UIKit.h>
+
+@implementation TrustchexSDK
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+- (void)enableKeepAwake {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [UIApplication sharedApplication].idleTimerDisabled = YES;
+  });
+}
+
+- (void)disableKeepAwake {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [UIApplication sharedApplication].idleTimerDisabled = NO;
+  });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeTrustchexSDKSpecJSI>(params);
+}
+
+@end

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin.mm

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import <VisionCamera/Frame.h>
+
+#if __has_include("TrustchexSDK/TrustchexSDK-Swift.h")
+#import "TrustchexSDK/TrustchexSDK-Swift.h"
+#else
+#import "TrustchexSDK-Swift.h"
+#endif
+
+@interface BarcodeScannerFrameProcessorPlugin (FrameProcessorPluginLoader)
+@end
+
+@implementation BarcodeScannerFrameProcessorPlugin (FrameProcessorPluginLoader)
++ (void)load {
+  [FrameProcessorPluginRegistry addFrameProcessorPlugin:@"scanCodes"
+                                        withInitializer:^FrameProcessorPlugin*(VisionCameraProxyHolder* proxy, NSDictionary* options) {
+    return [[BarcodeScannerFrameProcessorPlugin alloc] initWithProxy:proxy withOptions:options];
+  }];
+}
+@end

package/ios/VisionCameraPlugins/BarcodeScanner/BarcodeScannerFrameProcessorPlugin.swift

@@ -0,0 +1,172 @@
+import Foundation
+import VisionCamera
+import Vision
+
+@objc(BarcodeScannerFrameProcessorPlugin)
+public class BarcodeScannerFrameProcessorPlugin: FrameProcessorPlugin {
+
+    public override func callback(_ frame: Frame, withArguments arguments: [AnyHashable: Any]?) -> Any? {
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(frame.buffer) else {
+            return []
+        }
+
+        let visionImage = VNImageRequestHandler(cvPixelBuffer: imageBuffer, orientation: .up, options: [:])
+
+        // Configure barcode types
+        var symbologies: [VNBarcodeSymbology] = [
+            .aztec, .code128, .code39, .code93, .dataMatrix,
+            .ean13, .ean8, .i2of5, .pdf417, .qr, .upce, .codabar
+        ]
+
+        // Filter by specified barcode types if provided
+        if let arguments = arguments,
+           let barcodeTypes = arguments["barcodeTypes"] as? [String] {
+            symbologies = barcodeTypes.compactMap { type in
+                switch type {
+                case "aztec":
+                    return .aztec
+                case "codabar":
+                    return .codabar
+                case "code-128":
+                    return .code128
+                case "code-39":
+                    return .code39
+                case "code-93":
+                    return .code93
+                case "data-matrix":
+                    return .dataMatrix
+                case "ean-13":
+                    return .ean13
+                case "ean-8":
+                    return .ean8
+                case "itf":
+                    return .i2of5
+                case "pdf-417":
+                    return .pdf417
+                case "qr":
+                    return .qr
+                case "upc-e":
+                    return .upce
+                default:
+                    return nil
+                }
+            }
+        }
+
+        let request = VNDetectBarcodesRequest { [weak self] request, error in
+            // This callback runs asynchronously
+        }
+        request.symbologies = symbologies
+
+        var detectedBarcodes: [VNBarcodeObservation] = []
+
+        do {
+            try visionImage.perform([request])
+            detectedBarcodes = request.results as? [VNBarcodeObservation] ?? []
+        } catch {
+            return []
+        }
+
+        let result = detectedBarcodes.map { barcode -> [String: Any] in
+            var barcodeDict: [String: Any] = [:]
+
+            // Add barcode value
+            barcodeDict["value"] = barcode.payloadStringValue
+
+            // Add barcode type
+            let type: String
+            switch barcode.symbology {
+            case .aztec:
+                type = "aztec"
+            case .codabar:
+                type = "codabar"
+            case .code128:
+                type = "code-128"
+            case .code39:
+                type = "code-39"
+            case .code93:
+                type = "code-93"
+            case .dataMatrix:
+                type = "data-matrix"
+            case .ean13:
+                type = "ean-13"
+            case .ean8:
+                type = "ean-8"
+            case .i2of5, .i2of5Checksum, .itf14:
+                type = "itf"
+            case .pdf417:
+                type = "pdf-417"
+            case .qr:
+                type = "qr"
+            case .upce:
+                type = "upc-e"
+            default:
+                type = "unknown"
+            }
+            barcodeDict["type"] = type
+
+            // Convert bounding box to our format
+            let boundingBox = barcode.boundingBox
+            let imageSize = CGSize(width: CVPixelBufferGetWidth(imageBuffer), height: CVPixelBufferGetHeight(imageBuffer))
+
+            // Vision framework uses normalized coordinates (0-1), convert to pixel coordinates
+            let origin = CGPoint(
+                x: boundingBox.origin.x * imageSize.width,
+                y: (1 - boundingBox.origin.y - boundingBox.size.height) * imageSize.height // Flip Y coordinate
+            )
+            let size = CGSize(
+                width: boundingBox.size.width * imageSize.width,
+                height: boundingBox.size.height * imageSize.height
+            )
+
+            barcodeDict["boundingBox"] = [
+                "origin": [
+                    "x": origin.x,
+                    "y": origin.y
+                ],
+                "size": [
+                    "width": size.width,
+                    "height": size.height
+                ]
+            ]
+
+            // Convert corner points to our format
+            let topLeft = CGPoint(
+                x: barcode.topLeft.x * imageSize.width,
+                y: (1 - barcode.topLeft.y) * imageSize.height
+            )
+            let topRight = CGPoint(
+                x: barcode.topRight.x * imageSize.width,
+                y: (1 - barcode.topRight.y) * imageSize.height
+            )
+            let bottomLeft = CGPoint(
+                x: barcode.bottomLeft.x * imageSize.width,
+                y: (1 - barcode.bottomLeft.y) * imageSize.height
+            )
+            let bottomRight = CGPoint(
+                x: barcode.bottomRight.x * imageSize.width,
+                y: (1 - barcode.bottomRight.y) * imageSize.height
+            )
+
+            barcodeDict["cornerPoints"] = [
+                ["x": topLeft.x, "y": topLeft.y],
+                ["x": topRight.x, "y": topRight.y],
+                ["x": bottomRight.x, "y": bottomRight.y],
+                ["x": bottomLeft.x, "y": bottomLeft.y]
+            ]
+
+            // Add native data
+            var nativeDict: [String: Any] = [:]
+
+            if let descriptor = barcode.barcodeDescriptor {
+                nativeDict["descriptor"] = descriptor
+            }
+
+            barcodeDict["native"] = nativeDict
+
+            return barcodeDict
+        }
+
+        return result
+    }
+}

package/ios/VisionCameraPlugins/Cropper/Cropper-Bridging-Header.h

@@ -0,0 +1,13 @@
+//
+//  VisionCameraCropper-Bridging-Header.h
+//  TrustchexSDK
+//
+
+#ifndef VisionCameraCropper_Bridging_Header_h
+#define VisionCameraCropper_Bridging_Header_h
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#endif /* VisionCameraCropper_Bridging_Header_h */

package/ios/VisionCameraPlugins/Cropper/Cropper.h

@@ -0,0 +1,20 @@
+//
+//  VisionCameraCropper.h
+//  TrustchexSDK
+//
+
+#ifndef VisionCameraCropper_h
+#define VisionCameraCropper_h
+
+#import <React/RCTBridgeModule.h>
+#import <UIKit/UIKit.h>
+
+@interface VisionCameraCropper : NSObject <RCTBridgeModule>
+
++ (UIImage *)rotateImage:(UIImage *)image degree:(float)degree;
++ (NSString *)getBase64FromImage:(UIImage *)image;
++ (UIImage *)convertBase64ToImage:(NSString *)base64String;
+
+@end
+
+#endif /* VisionCameraCropper_h */