cronapp-plugin-mlkit 1.0.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "cronapp-plugin-mlkit",
+  "version": "1.0.0",
+  "description": "",
+  "cordova": {
+    "id": "cronapp-plugin-mlkit",
+    "platforms": [
+      "ios",
+      "android"
+    ]
+  },
+  "keywords": [
+    "cronapp",
+    "mlkit",
+    "ocr",
+    "ecosystem:cordova",
+    "cordova-ios",
+    "cordova-android"
+  ],
+  "author": "Cronapp Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git"
+  }
+}

package/plugin.xml

@@ -0,0 +1,65 @@
+<?xml version='1.0' encoding='utf-8'?>
+<plugin id="cronapp-plugin-mlkit" version="1.0.0" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
+    <name>CronappMLKitPlugin</name>
+
+    <js-module name="CronappMLKitPlugin" src="www/cronapp-mlkit.js">
+        <clobbers target="CronappMLKitPlugin" />
+    </js-module>
+    <platform name="ios">
+        <dependency id="cordova-plugin-add-swift-support" version="2.0.2"/>
+
+        <config-file target="config.xml" parent="/*">
+            <feature name="CronappMLKitPlugin">
+                <param name="ios-package" value="CronappMLKitPlugin" />
+                <param name="onload" value="true" />
+            </feature>
+        </config-file>
+
+        <source-file src="src/ios/CronappMLKitPlugin.swift" />
+        <source-file src="src/ios/CronappMLKitExtensions.swift" />
+
+        <podspec>
+            <config>
+                <source url="https://cdn.cocoapods.org/"/>
+            </config>
+            <pods use-frameworks="true">
+                <pod name="GoogleMLKit/TextRecognition"/>
+                <pod name="GoogleMLKit/BarcodeScanning"/>
+                <pod name="GoogleMLKit/ImageLabeling"/>
+                <pod name="GoogleMLKit/FaceDetection"/>
+            </pods>
+        </podspec>
+    </platform>
+
+    <platform name="android">
+        <dependency id="cordova-plugin-androidx" version="^2.0.0" />
+        <dependency id="cordova-plugin-androidx-adapter" version="^1.1.1" />
+
+        <config-file target="res/xml/config.xml" parent="/*">
+            <feature name="CronappMLKitPlugin">
+                <param name="android-package" value="io.cronapp.mlkit.CronappMLKitPlugin" />
+                <param name="onload" value="true" />
+            </feature>
+        </config-file>
+
+        <config-file target="AndroidManifest.xml" parent="/manifest/application">
+            <meta-data
+                android:name="com.google.mlkit.vision.DEPENDENCIES"
+                android:value="ocr" />
+        </config-file>
+
+        <source-file src="src/android/CronappMLKitPlugin.java" target-dir="io/cronapp/mlkit"/>
+        <source-file src="src/android/Utils.java" target-dir="io/cronapp/mlkit"/>
+
+        <preference name="MKLKIT_VERSION_TEXT_RECOGNITION" default="16.1.1"/>
+        <preference name="MKLKIT_VERSION_BARCODE" default="16.0.3"/>
+        <preference name="MKLKIT_VERSION_IMAGE_LABELLING" default="17.0.0"/>
+        <preference name="MKLKIT_VERSION_FACE" default="16.1.7"/>
+
+        <framework src="com.google.android.gms:play-services-mlkit-text-recognition:$MKLKIT_VERSION_TEXT_RECOGNITION"/>
+        <framework src="com.google.mlkit:barcode-scanning:$MKLKIT_VERSION_BARCODE"/>
+        <framework src="com.google.mlkit:image-labeling:$MKLKIT_VERSION_IMAGE_LABELLING"/>
+        <framework src="com.google.mlkit:face-detection:$MKLKIT_VERSION_FACE"/>
+
+    </platform>
+</plugin>

package/src/android/CronappMLKitPlugin.java

@@ -0,0 +1,231 @@
+package io.cronapp.mlkit;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Base64;
+
+import com.google.android.gms.tasks.OnFailureListener;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.mlkit.vision.barcode.Barcode;
+import com.google.mlkit.vision.barcode.BarcodeScanner;
+import com.google.mlkit.vision.barcode.BarcodeScanning;
+import com.google.mlkit.vision.common.InputImage;
+import com.google.mlkit.vision.face.Face;
+import com.google.mlkit.vision.face.FaceDetection;
+import com.google.mlkit.vision.face.FaceDetector;
+import com.google.mlkit.vision.face.FaceDetectorOptions;
+import com.google.mlkit.vision.label.ImageLabel;
+import com.google.mlkit.vision.label.ImageLabeler;
+import com.google.mlkit.vision.label.ImageLabeling;
+import com.google.mlkit.vision.label.defaults.ImageLabelerOptions;
+import com.google.mlkit.vision.text.Text;
+import com.google.mlkit.vision.text.TextRecognition;
+import com.google.mlkit.vision.text.TextRecognizer;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+
+public class CronappMLKitPlugin extends CordovaPlugin {
+
+  protected static Context applicationContext = null;
+  private static Activity cordovaActivity = null;
+
+  @Override
+  protected void pluginInitialize() {
+    super.pluginInitialize();
+    cordovaActivity = this.cordova.getActivity();
+    applicationContext = cordovaActivity.getApplicationContext();
+  }
+
+  @Override
+  public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+    if (action.equals("onDeviceTextRecognizer")) {
+      String message = args.getString(0);
+      this.onDeviceTextRecognizer(message, callbackContext);
+      return true;
+    } else if (action.equals("barcodeDetector")) {
+      String message = args.getString(0);
+      this.barcodeDetector(message, callbackContext);
+      return true;
+    } else if (action.equals("imageLabeler")) {
+      String message = args.getString(0);
+      this.imageLabeler(message, callbackContext);
+      return true;
+    } else if (action.equals("faceDetector")) {
+      String message = args.getString(0);
+      JSONObject options = args.getJSONObject(1);
+      this.faceDetector(message, options, callbackContext);
+      return true;
+    }
+    return false;
+  }
+
+  private void onDeviceTextRecognizer(String message, CallbackContext callbackContext) {
+    if (message != null && message.length() > 0) {
+      try {
+        InputImage image = getImage(message);
+        TextRecognizer recognizer = TextRecognition.getClient();
+        recognizer.process(image)
+            .addOnSuccessListener(new OnSuccessListener<Text>() {
+              @Override
+              public void onSuccess(Text firebaseVisionText) {
+                try {
+                  JSONObject text = Utils.parseText(image, firebaseVisionText);
+                  callbackContext.success(text);
+                } catch (Exception e) {
+                  callbackContext.error(e.getLocalizedMessage());
+                }
+              }
+            })
+            .addOnFailureListener(new OnFailureListener() {
+              @Override
+              public void onFailure(@NonNull Exception e) {
+                callbackContext.error(e.getLocalizedMessage());
+              }
+            });
+      } catch (Exception e) {
+        callbackContext.error(e.getLocalizedMessage());
+      }
+    } else {
+      callbackContext.error("Expected one non-empty string argument.");
+    }
+  }
+
+  private void barcodeDetector(String message, CallbackContext callbackContext) {
+    if (message != null && message.length() > 0) {
+      try {
+        InputImage image = getImage(message);
+        BarcodeScanner detector = BarcodeScanning.getClient();
+        detector.process(image)
+            .addOnSuccessListener(new OnSuccessListener<List<Barcode>>() {
+              @Override
+              public void onSuccess(List<Barcode> firebaseVisionBarcodes) {
+                try {
+                  JSONArray barcodes = Utils.parseBarcodes(image, firebaseVisionBarcodes);
+                  callbackContext.success(barcodes);
+                } catch (Exception e) {
+                  callbackContext.error(e.getLocalizedMessage());
+                }
+              }
+            })
+            .addOnFailureListener(new OnFailureListener() {
+              @Override
+              public void onFailure(@NonNull Exception e) {
+                callbackContext.error(e.getLocalizedMessage());
+              }
+            });
+      } catch (Exception e) {
+        callbackContext.error(e.getLocalizedMessage());
+      }
+    } else {
+      callbackContext.error("Expected one non-empty string argument.");
+    }
+  }
+
+  private void imageLabeler(String message, CallbackContext callbackContext) {
+    if (message != null && message.length() > 0) {
+      try {
+        InputImage image = getImage(message);
+        ImageLabeler detector = ImageLabeling.getClient(ImageLabelerOptions.DEFAULT_OPTIONS);
+        detector.process(image)
+            .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
+              @Override
+              public void onSuccess(List<ImageLabel> imageLabels) {
+                try {
+                  JSONArray imageLabels1 = Utils.parseImageLabels(imageLabels);
+                  callbackContext.success(imageLabels1);
+                } catch (Exception e) {
+                  callbackContext.error(e.getLocalizedMessage());
+                }
+              }
+            })
+            .addOnFailureListener(new OnFailureListener() {
+              @Override
+              public void onFailure(@NonNull Exception e) {
+                callbackContext.error(e.getLocalizedMessage());
+              }
+            });
+      } catch (Exception e) {
+        callbackContext.error(e.getLocalizedMessage());
+      }
+    } else {
+      callbackContext.error("Expected one non-empty string argument.");
+    }
+  }
+
+  private void faceDetector(String message, JSONObject options, CallbackContext callbackContext) {
+    if (message != null && message.length() > 0) {
+      try {
+        InputImage image = getImage(message);
+        FaceDetectorOptions faceDetectorOptions = new FaceDetectorOptions.Builder()
+            .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
+
+            .build();
+        FaceDetector detector = FaceDetection.getClient(faceDetectorOptions);
+        detector.process(image)
+            .addOnSuccessListener(new OnSuccessListener<List<Face>>() {
+              @Override
+              public void onSuccess(List<Face> faces) {
+                try {
+                  JSONArray imageLabels1 = Utils.parseFaces(faces);
+                  callbackContext.success(imageLabels1);
+                } catch (Exception e) {
+                  callbackContext.error(e.getLocalizedMessage());
+                }
+              }
+            })
+            .addOnFailureListener(new OnFailureListener() {
+              @Override
+              public void onFailure(@NonNull Exception e) {
+                callbackContext.error(e.getLocalizedMessage());
+              }
+            });
+      } catch (Exception e) {
+        callbackContext.error(e.getLocalizedMessage());
+      }
+    } else {
+      callbackContext.error("Expected one non-empty string argument.");
+    }
+  }
+
+  private byte[] toBytes(InputStream stream) throws IOException {
+    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+
+    int nRead;
+    byte[] data = new byte[16384];
+
+    while ((nRead = stream.read(data, 0, data.length)) != -1) {
+      buffer.write(data, 0, nRead);
+    }
+
+    return buffer.toByteArray();
+  }
+
+  private InputImage getImage(String message) throws IOException {
+    if (message.contains("data:")) {
+      message = message
+          .replace("data:image/png;base64,", "")
+          .replace("data:image/jpeg;base64,", "");
+      byte[] decodedString = Base64.decode(message, Base64.DEFAULT);
+      Bitmap bitMap = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
+      InputImage image = InputImage.fromBitmap(bitMap, 0);
+      return image;
+    } else {
+      Uri uri = Uri.parse("/sdcard/Download/face.jpg");
+      InputImage image = InputImage.fromFilePath(applicationContext, uri);
+      return image;
+    }
+  }
+}

package/src/android/Utils.java

@@ -0,0 +1,299 @@
+package io.cronapp.mlkit;
+
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.text.TextUtils;
+
+import com.google.mlkit.vision.barcode.Barcode;
+import com.google.mlkit.vision.common.InputImage;
+import com.google.mlkit.vision.face.Face;
+import com.google.mlkit.vision.label.ImageLabel;
+import com.google.mlkit.vision.text.Text;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.util.List;
+import java.util.Locale;
+
+
+public class Utils {
+  public static JSONObject parseText(InputImage image, Text text) throws Exception {
+    JSONArray blocks = new JSONArray();
+    for (Text.TextBlock textBlock : text.getTextBlocks()) {
+      JSONArray lines = new JSONArray();
+      for (Text.Line line : textBlock.getLines()) {
+        JSONArray elements = new JSONArray();
+        for (Text.Element element : line.getElements()) {
+          JSONObject elementObject = new JSONObject();
+          elementObject.put("cornerPoints", parsePoints(element.getCornerPoints()));
+          elementObject.put("text", element.getText());
+          elementObject.put("frame", parseBoundingBox(element.getBoundingBox()));
+          elementObject.put("recognizedLanguages", element.getRecognizedLanguage());
+          elements.put(elementObject);
+        }
+        JSONObject lineObject = new JSONObject();
+        lineObject.put("cornerPoints", parsePoints(line.getCornerPoints()));
+        lineObject.put("text", line.getText());
+        lineObject.put("frame", parseBoundingBox(line.getBoundingBox()));
+        lineObject.put("recognizedLanguages", line.getRecognizedLanguage());
+        lineObject.put("elements", elements);
+        lines.put(lineObject);
+      }
+      JSONObject block = new JSONObject();
+      block.put("cornerPoints", parsePoints(textBlock.getCornerPoints()));
+      block.put("text", textBlock.getText());
+      block.put("frame", parseBoundingBox(textBlock.getBoundingBox()));
+      block.put("recognizedLanguages", textBlock.getRecognizedLanguage());
+      block.put("lines", lines);
+      blocks.put(block);
+    }
+
+    JSONObject result = new JSONObject();
+    result.put("text", text.getText());
+    result.put("blocks", blocks);
+    result.put("imageWidth", image.getWidth());
+    result.put("imageHeight", image.getHeight());
+
+    return result;
+  }
+
+  public static JSONArray parseBarcodes(InputImage image, List<Barcode> barcodes) throws Exception {
+    JSONArray array = new JSONArray();
+    for (Barcode barcode : barcodes) {
+
+      JSONObject barcodeMap = new JSONObject();
+      barcodeMap.put("valueType", barcode.getValueType());
+      barcodeMap.put("format", barcode.getFormat());
+      barcodeMap.put("rawValue", barcode.getRawValue());
+      barcodeMap.put("displayValue", barcode.getDisplayValue());
+      barcodeMap.put("cornerPoints", parsePoints(barcode.getCornerPoints()));
+      barcodeMap.put("boundingBox", barcode.getBoundingBox());
+      barcodeMap.put("imageWidth", image.getWidth());
+      barcodeMap.put("imageHeight", image.getHeight());
+
+
+      if (barcode.getEmail() != null) {
+        JSONObject email = new JSONObject();
+        email.put("address", barcode.getEmail().getAddress());
+        email.put("body", barcode.getEmail().getBody());
+        email.put("subject", barcode.getEmail().getSubject());
+        email.put("type", barcode.getEmail().getType());
+        barcodeMap.put("email", email);
+      }
+
+      if (barcode.getPhone() != null) {
+        JSONObject phone = new JSONObject();
+        phone.put("number", barcode.getPhone().getNumber());
+        phone.put("type", barcode.getPhone().getType());
+        barcodeMap.put("phone", phone);
+      }
+
+      if (barcode.getSms() != null) {
+        JSONObject sms = new JSONObject();
+        sms.put("phoneNumber", barcode.getSms().getPhoneNumber());
+        sms.put("message", barcode.getSms().getMessage());
+        barcodeMap.put("sms", sms);
+      }
+
+      if (barcode.getUrl() != null) {
+        JSONObject url = new JSONObject();
+        url.put("title", barcode.getUrl().getTitle());
+        url.put("url", barcode.getUrl().getUrl());
+        barcodeMap.put("url", url);
+      }
+
+      if (barcode.getWifi() != null) {
+        JSONObject wifi = new JSONObject();
+        wifi.put("ssid", barcode.getWifi().getSsid());
+        wifi.put("password", barcode.getWifi().getPassword());
+        wifi.put("type", barcode.getWifi().getEncryptionType());
+        barcodeMap.put("wifi", wifi);
+      }
+
+      if (barcode.getGeoPoint() != null) {
+        JSONObject geoPoint = new JSONObject();
+        geoPoint.put("latitude", barcode.getGeoPoint().getLat());
+        geoPoint.put("longitude", barcode.getGeoPoint().getLng());
+        barcodeMap.put("geoPoint", geoPoint);
+      }
+
+      if (barcode.getCalendarEvent() != null) {
+        JSONObject calendarEvent = new JSONObject();
+        calendarEvent.put("eventDescription", barcode.getCalendarEvent().getDescription());
+        calendarEvent.put("location", barcode.getCalendarEvent().getLocation());
+        calendarEvent.put("organizer", barcode.getCalendarEvent().getOrganizer());
+        calendarEvent.put("status", barcode.getCalendarEvent().getStatus());
+        calendarEvent.put("summary", barcode.getCalendarEvent().getSummary());
+        calendarEvent.put("start", toISOString(barcode.getCalendarEvent().getStart()));
+        calendarEvent.put("end", toISOString(barcode.getCalendarEvent().getEnd()));
+        barcodeMap.put("calendarEvent", calendarEvent);
+      }
+
+      if (barcode.getContactInfo() != null) {
+        JSONObject contactInfo = new JSONObject();
+        contactInfo.put("title", barcode.getContactInfo().getTitle());
+        contactInfo.put("name", barcode.getContactInfo().getName().getFormattedName());
+        contactInfo.put("addresses", parseAddresses(barcode.getContactInfo().getAddresses()));
+        contactInfo.put("phones", parsePhones(barcode.getContactInfo().getPhones()));
+        contactInfo.put("emails", parseEmails(barcode.getContactInfo().getEmails()));
+        contactInfo.put("organization", barcode.getContactInfo().getOrganization());
+        contactInfo.put("urls", TextUtils.join(",", barcode.getContactInfo().getUrls()));
+        barcodeMap.put("contactInfo", contactInfo);
+      }
+
+      if (barcode.getDriverLicense() != null) {
+        JSONObject driverLicense = new JSONObject();
+        driverLicense.put("firstName", barcode.getDriverLicense().getFirstName());
+        driverLicense.put("middleName", barcode.getDriverLicense().getMiddleName());
+        driverLicense.put("lastName", barcode.getDriverLicense().getLastName());
+        driverLicense.put("gender", barcode.getDriverLicense().getGender());
+        driverLicense.put("addressCity", barcode.getDriverLicense().getAddressCity());
+        driverLicense.put("addressState", barcode.getDriverLicense().getAddressState());
+        driverLicense.put("addressStreet", barcode.getDriverLicense().getAddressStreet());
+        driverLicense.put("addressZip", barcode.getDriverLicense().getAddressZip());
+        driverLicense.put("birthDate", barcode.getDriverLicense().getBirthDate());
+        driverLicense.put("documentType", barcode.getDriverLicense().getDocumentType());
+        driverLicense.put("licenseNumber", barcode.getDriverLicense().getLicenseNumber());
+        driverLicense.put("expiryDate", barcode.getDriverLicense().getExpiryDate());
+        driverLicense.put("issuingDate", barcode.getDriverLicense().getIssueDate());
+        driverLicense.put("issuingCountry", barcode.getDriverLicense().getIssuingCountry());
+        barcodeMap.put("driverLicense", driverLicense);
+      }
+
+      array.put(barcodeMap);
+    }
+    return array;
+  }
+
+  public static JSONArray parseImageLabels(List<ImageLabel> imageLabels) throws Exception {
+    JSONArray array = new JSONArray();
+    for (ImageLabel imageLabel : imageLabels) {
+
+      JSONObject imageLabelMap = new JSONObject();
+      imageLabelMap.put("text", imageLabel.getText());
+      imageLabelMap.put("confidence", imageLabel.getConfidence());
+      imageLabelMap.put("index", imageLabel.getIndex());
+
+      array.put(imageLabelMap);
+    }
+    return array;
+  }
+
+  public static JSONArray parseFaces(List<Face> faces) throws Exception {
+    JSONArray array = new JSONArray();
+    for (Face face : faces) {
+
+      array.put(FaceToJsonConverter.faceToJson(face));
+    }
+    return array;
+  }
+
+  private static JSONArray parsePhones(List<Barcode.Phone> phones) throws Exception {
+    JSONArray array = new JSONArray();
+    for (Barcode.Phone phone : phones) {
+
+      JSONObject phoneMap = new JSONObject();
+      phoneMap.put("number", phone.getNumber());
+      phoneMap.put("type", phone.getType());
+
+      array.put(phoneMap);
+    }
+    return array;
+  }
+
+  private static JSONArray parseAddresses(List<Barcode.Address> addresses) throws Exception {
+    JSONArray array = new JSONArray();
+    for (Barcode.Address address : addresses) {
+
+      JSONObject addressMap = new JSONObject();
+      addressMap.put("addressLine", TextUtils.join(",", address.getAddressLines()));
+      addressMap.put("type", address.getType());
+
+      array.put(addressMap);
+    }
+    return array;
+  }
+
+  private static JSONArray parseEmails(List<Barcode.Email> emails) throws Exception {
+    JSONArray array = new JSONArray();
+    for (Barcode.Email email : emails) {
+
+      JSONObject emailMap = new JSONObject();
+      emailMap.put("address", email.getAddress());
+      emailMap.put("body", email.getBody());
+      emailMap.put("subject", email.getSubject());
+      emailMap.put("type", email.getType());
+
+      array.put(emailMap);
+    }
+    return array;
+  }
+
+  private static JSONArray parsePoints(Point[] points) throws Exception {
+    JSONArray array = new JSONArray();
+    for (Point point : points) {
+
+      JSONObject pointMap = new JSONObject();
+      pointMap.put("x", point.x);
+      pointMap.put("y", point.y);
+      array.put(pointMap);
+    }
+    return array;
+  }
+
+  private static JSONObject parseBoundingBox(Rect rect) throws Exception {
+    JSONObject rectMap = new JSONObject();
+    rectMap.put("x", rect.left);
+    rectMap.put("y", rect.top);
+    rectMap.put("width", rect.width());
+    rectMap.put("height", rect.height());
+
+    return rectMap;
+  }
+
+  private static String toISOString(Barcode.CalendarDateTime date) {
+    return String.format(Locale.getDefault(), "%d-%02d-%02dT%02d:%02d:%02d",
+        date.getYear(), date.getMonth(), date.getDay(),
+        date.getHours(), date.getMinutes(), date.getSeconds());
+  }
+
+  public static JSONObject parseFaces(Face face) {
+
+    JSONObject faceData = new JSONObject();
+
+    try {
+      faceData.put("faceId", face.getTrackingId());
+      JSONObject boundingBox = new JSONObject();
+      boundingBox.put("left", face.getBoundingBox().left);
+      boundingBox.put("top", face.getBoundingBox().top);
+      boundingBox.put("right", face.getBoundingBox().right);
+      boundingBox.put("bottom", face.getBoundingBox().bottom);
+      faceData.put("boundingBox", boundingBox);
+      faceData.put("headEulerAngleX", face.getHeadEulerAngleX());
+      faceData.put("headEulerAngleY", face.getHeadEulerAngleY());
+      faceData.put("headEulerAngleZ", face.getHeadEulerAngleZ());
+
+      faceData.put("smilingProbability", face.getSmilingProbability());
+
+      faceData.put("rightEyeOpenProbability", face.getRightEyeOpenProbability());
+
+      faceData.put("leftEyeOpenProbability", face.getLeftEyeOpenProbability());
+
+      JSONArray landmarksArray = new JSONArray();
+      for (FaceLandmark landmark : face.getAllLandmarks()) {
+        JSONObject landmarkData = new JSONObject();
+        landmarkData.put("type", landmark.getLandmarkType());
+        landmarkData.put("x", landmark.getPosition().x);
+        landmarkData.put("y", landmark.getPosition().y);
+        landmarksArray.put(landmarkData);
+      }
+      faceData.put("landmarks", landmarksArray);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    return faceData;
+
+  }
+}

package/src/ios/CronappMLKitExtensions.swift

@@ -0,0 +1,231 @@
+import MLKitTextRecognition
+import MLKitBarcodeScanning
+import MLKitImageLabeling
+import MLKitFaceDetection
+import UIKit
+
+extension Text {
+    func toJSON(with image: UIImage) -> [AnyHashable: Any] {
+        let blocksParsed = blocks.compactMap { (block) -> Any? in
+            let lines = block.lines.compactMap { (line) -> Any? in
+                let elements = line.elements.compactMap { (element) -> Any? in
+                    return [
+                        "cornerPoints": element.cornerPoints.toJSON() as Any,
+                        "text": element.text,
+                        "frame": element.frame.toJSON() as Any
+                    ]
+                }
+                return [
+                    "cornerPoints": line.cornerPoints.toJSON() as Any,
+                    "text": line.text,
+                    "frame": line.frame.toJSON() as Any,
+                    "recognizedLanguages": line.recognizedLanguages.compactMap({$0.languageCode}),
+                    "elements": elements
+                ]
+            }
+            return [
+                "cornerPoints": block.cornerPoints.toJSON() as Any,
+                "text": block.text,
+                "frame": block.frame.toJSON() as Any,
+                "recognizedLanguages": block.recognizedLanguages.compactMap({$0.languageCode}),
+                "lines": lines
+            ]
+        }
+
+        return [
+            "text": text,
+            "blocks": blocksParsed,
+            "imageWidth": image.size.width,
+            "imageHeight": image.size.height
+        ]
+    }
+}
+
+extension Face {
+    func toJSON(with image: UIImage) -> [AnyHashable: Any] {
+        var response: [AnyHashable: Any] = [:]
+
+        response["faceId"] = trackingID
+
+        let boundingBox = [
+            "x": frame.origin.x,
+            "y": frame.origin.y,
+            "width": frame.size.width,
+            "height": frame.size.height
+        ]
+        response["boundingBox"] = boundingBox
+
+        response["headEulerAngleX"] = headEulerAngleX
+        response["headEulerAngleY"] = headEulerAngleY
+        response["headEulerAngleZ"] = headEulerAngleZ
+
+        response["smilingProbability"] = smilingProbability ?? -1
+        response["leftEyeOpenProbability"] = leftEyeOpenProbability ?? -1
+        response["rightEyeOpenProbability"] = rightEyeOpenProbability ?? -1
+
+        var landmarksArray: [[AnyHashable: Any]] = []
+        for landmark in landmarks {
+            var landmarkData: [AnyHashable: Any] = [:]
+            landmarkData["type"] = landmark.type.rawValue
+            landmarkData["x"] = landmark.position.x
+            landmarkData["y"] = landmark.position.y
+
+            landmarksArray.append(landmarkData)
+        }
+        response["landmarks"] = landmarksArray
+
+        return response
+    }
+}
+extension Barcode {
+    func toJSON(with image: UIImage) -> [AnyHashable: Any] {
+        var response = [
+            "valueType": valueType.rawValue,
+            "format": format.rawValue,
+            "rawValue" : rawValue as Any,
+            "displayValue" : displayValue as Any,
+            "cornerPoints" : cornerPoints?.toJSON() as Any,
+            "imageWidth": image.size.width,
+            "imageHeight": image.size.height
+        ]
+        if let email = email {
+            response["email"] = [
+                "address" : email.address as Any,
+                "body" : email.body as Any,
+                "subject" : email.subject as Any,
+                "type" : email.type.rawValue as Any
+            ]
+        }
+        if let phone = phone {
+            response["phone"] = [
+                "number" : phone.number as Any,
+                "type" : phone.type.rawValue as Any
+            ]
+        }
+        if let sms = sms {
+            response["sms"] = [
+                "phoneNumber": sms.phoneNumber as Any,
+                "message": sms.message as Any
+            ]
+        }
+        if let url = url {
+            response["url"] = [
+                "title": url.title as Any,
+                "url": url.url as Any
+            ]
+        }
+        if let wifi = wifi {
+            response["wifi"] = [
+                "ssid" : wifi.ssid as Any,
+                "password" : wifi.password as Any,
+                "type" : wifi.type.rawValue as Any
+            ]
+        }
+        if let geoPoint = geoPoint {
+            response["geoPoint"] = [
+                "latitude" : geoPoint.latitude as Any,
+                "longitude" : geoPoint.longitude as Any
+            ]
+        }
+        if let calendarEvent = calendarEvent {
+            response["calendarEvent"] = [
+                "eventDescription": calendarEvent.eventDescription as Any,
+                "location": calendarEvent.location as Any,
+                "organizer": calendarEvent.organizer as Any,
+                "status": calendarEvent.status as Any,
+                "summary": calendarEvent.summary as Any,
+                "start": calendarEvent.start?.toISOString() as Any,
+                "end": calendarEvent.end?.toISOString() as Any
+            ]
+        }
+
+        if let contactInfo = contactInfo {
+            response["contactInfo"] = [
+                "title": contactInfo.jobTitle as Any,
+                "name": contactInfo.name?.formattedName as Any,
+                "addresses": contactInfo.addresses?.compactMap({ (address) -> [String: Any]? in
+                    return [
+                        "addressLine" : address.addressLines?.joined(separator: ",") as Any,
+                        "type" : address.type.rawValue
+                    ]
+                }) as Any,
+                "phones": contactInfo.phones?.compactMap({ (phone) -> [String: Any]? in
+                    return [
+                        "number": phone.number as Any,
+                        "type": phone.type.rawValue
+                    ]
+                }) as Any,
+                "emails": contactInfo.emails?.compactMap({ (email) -> [String: Any]? in
+                    return [
+                        "address": email.address as Any,
+                        "body": email.body as Any,
+                        "type": email.type.rawValue
+                    ]
+                }) as Any,
+                "organization": contactInfo.organization as Any,
+                "urls": contactInfo.urls?.joined(separator: ",") as Any
+            ]
+        }
+
+
+        if let driverLicense = driverLicense {
+            response["driverLicense"] = [
+                "firstName": driverLicense.firstName as Any,
+                "middleName": driverLicense.middleName as Any,
+                "lastName": driverLicense.lastName as Any,
+                "gender": driverLicense.gender as Any,
+                "addressCity": driverLicense.addressCity as Any,
+                "addressState": driverLicense.addressState as Any,
+                "addressStreet": driverLicense.addressStreet as Any,
+                "addressZip": driverLicense.addressZip as Any,
+                "birthDate": driverLicense.birthDate as Any,
+                "documentType": driverLicense.documentType as Any,
+                "licenseNumber": driverLicense.licenseNumber as Any,
+                "expiryDate": driverLicense.expiryDate as Any,
+                "issuingDate": driverLicense.issuingDate as Any,
+                "issuingCountry": driverLicense.issuingCountry as Any
+            ]
+        }
+        return response
+    }
+}
+
+extension ImageLabel {
+    func toJSON() -> [String: Any] {
+        return [
+            "text": text,
+            "index": index,
+            "confidence": confidence
+        ]
+    }
+}
+
+extension Date {
+    func toISOString() -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss"
+        return formatter.string(from: self)
+    }
+}
+
+extension CGRect {
+    func toJSON() -> [AnyHashable: Any] {
+        return [
+            "x" : origin.x,
+            "y" : origin.y,
+            "width": size.width,
+            "height": size.height
+        ]
+    }
+}
+
+extension Array where Element: NSValue {
+    func toJSON() -> [[AnyHashable: Any]] {
+        return self.compactMap({
+            [
+                "x" : ($0 as! CGPoint).x,
+                "y" : ($0 as! CGPoint).y
+            ]
+        })
+    }
+}

package/src/ios/CronappMLKitPlugin.swift

@@ -0,0 +1,163 @@
+import MLKitTextRecognition
+import MLKitBarcodeScanning
+import MLKitImageLabeling
+import MLKitFaceDetection
+import MLKitVision
+import UIKit
+
+@objc(CronappMLKitPlugin)
+class CronappMLKitPlugin: CDVPlugin {
+
+    @objc(onDeviceTextRecognizer:)
+    func onDeviceTextRecognizer(command: CDVInvokedUrlCommand) {
+        guard let imageURL = command.arguments.first as? String else {
+            let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: "Image URL required")
+            self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            return
+        }
+        getImage(imageURL: imageURL) { (image, error) in
+            if let error = error {
+                let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            } else {
+                let textRecognizer = TextRecognizer.textRecognizer()
+                let visionImage = VisionImage(image: image!)
+                textRecognizer.process(visionImage) { (text, error) in
+                    if let error = error {
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    } else {
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: text?.toJSON(with: image!))
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    }
+                }
+            }
+        }
+    }
+
+
+    @objc(faceDetector:)
+    func faceDetector(command: CDVInvokedUrlCommand) {
+        guard let imageURL = command.arguments.first as? String else {
+            let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: "Image URL required")
+            self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            return
+        }
+        getImage(imageURL: imageURL) { (image, error) in
+            if let error = error {
+                let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            } else {
+                let faceDetector = FaceDetector.faceDetector()
+                let visionImage = VisionImage(image: image!)
+                faceDetector.process(visionImage) { (faces, error) in
+                    if let error = error {
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    } else {
+                        let barcodesDict = faces?.compactMap({ $0.toJSON(with: image!) })
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: barcodesDict)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    }
+                }
+            }
+        }
+    }
+
+    @objc(barcodeDetector:)
+    func barcodeDetector(command: CDVInvokedUrlCommand) {
+        guard let imageURL = command.arguments.first as? String else {
+            let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: "Image URL required")
+            self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            return
+        }
+        getImage(imageURL: imageURL) { (image, error) in
+            if let error = error {
+                let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            } else {
+                let barcodeDetector = BarcodeScanner.barcodeScanner()
+                let visionImage = VisionImage(image: image!)
+                barcodeDetector.process(visionImage) { (barcodes, error) in
+                    if let error = error {
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    } else {
+                        let barcodesDict = barcodes?.compactMap({ $0.toJSON(with: image!) })
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: barcodesDict)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    }
+                }
+            }
+        }
+    }
+
+    @objc(imageLabeler:)
+    func imageLabeler(command: CDVInvokedUrlCommand) {
+        guard let imageURL = command.arguments.first as? String else {
+            let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: "Image URL required")
+            self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            return
+        }
+        getImage(imageURL: imageURL) { (image, error) in
+            if let error = error {
+                let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+            } else {
+                let options = ImageLabelerOptions()
+                options.confidenceThreshold = 0.7
+                let imageLabeler = ImageLabeler.imageLabeler(options: options)
+                let visionImage = VisionImage(image: image!)
+                imageLabeler.process(visionImage) { (labels, error) in
+                    if let error = error {
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_ERROR, messageAs: error.localizedDescription)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    } else {
+                        let labelsDict = labels?.compactMap({$0.toJSON()})
+                        let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: labelsDict)
+                        self.commandDelegate.send(pluginResult, callbackId: command.callbackId)
+                    }
+                }
+            }
+        }
+    }
+
+    private func getImage(imageURL: String, _ completion: @escaping (_ image: UIImage?, _ error: Error?) -> Void) {
+        if imageURL.contains("data:") {
+            guard let data = Data(base64Encoded: imageURL
+                                    .replacingOccurrences(of: "data:image/jpeg;base64,", with: "")
+                                    .replacingOccurrences(of: "data:image/png;base64,", with: "")),
+                  let image = UIImage(data: data) else {
+                let error = NSError(domain: "cronapp-plugin-mlkit",
+                                    code: -1,
+                                    userInfo: [NSLocalizedDescriptionKey : "Base64ImageError"])
+                completion(nil, error)
+                return
+            }
+            completion(image, nil)
+        } else {
+            guard let url = URL(string: imageURL) else {
+                let error = NSError(domain: "cronapp-plugin-mlkit",
+                                    code: -1,
+                                    userInfo: [NSLocalizedDescriptionKey : "URLImageError"])
+                completion(nil, error)
+                return
+            }
+            URLSession.shared.dataTask(with: url) { (data, response, error) in
+                if let error = error {
+                    completion(nil, error)
+                } else {
+                    guard let data = data, let image = UIImage(data: data) else {
+                        let error = NSError(domain: "cronapp-plugin-mlkit",
+                                            code: -1,
+                                            userInfo: [NSLocalizedDescriptionKey : "DownloadImageError"])
+                        completion(nil, error)
+                        return
+                    }
+                    completion(image, nil)
+                }
+            }
+            .resume()
+        }
+    }
+}

package/www/cronapp-mlkit.js

@@ -0,0 +1,17 @@
+var exec = require('cordova/exec');
+
+exports.onDeviceTextRecognizer = function (image, success, error) {
+    exec(success, error,'CronappMLKitPlugin', 'onDeviceTextRecognizer', [image])
+}
+
+exports.barcodeDetector = function (image, success, error) {
+    exec(success, error,'CronappMLKitPlugin', 'barcodeDetector', [image])
+}
+
+exports.imageLabeler = function (image, success, error) {
+    exec(success, error,'CronappMLKitPlugin', 'imageLabeler', [image])
+}
+
+exports.faceDetector = function (image, options, success, error) {
+  exec(success, error,'CronappMLKitPlugin', 'faceDetector', [image, options])
+}