accurascan_kyc 0.1.0

package/android/build.gradle

@@ -0,0 +1,118 @@
+buildscript {
+  repositories {
+    google()
+    mavenLocal()
+    mavenCentral()
+    jcenter()
+    maven { url 'https://jitpack.io' }
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["AccurascanKyc_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AccurascanKyc_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+        debug {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+      packagingOptions {
+        pickFirst 'lib/arm64-v8a/libcrypto.so'
+        pickFirst 'lib/arm64-v8a/libssl.so'
+
+        pickFirst 'lib/armeabi-v7a/libcrypto.so'
+        pickFirst 'lib/armeabi-v7a/libssl.so'
+
+        pickFirst 'lib/x86/libcrypto.so'
+        pickFirst 'lib/x86/libssl.so'
+
+        pickFirst 'lib/x86_64/libcrypto.so'
+        pickFirst 'lib/x86_64/libssl.so'
+    }
+  splits {
+      abi {
+          reset()
+          universalApk false  // If true, also generate a universal APK
+          // include "armeabi-v7a", "x86", "arm64-v8a", "x86_64"
+          include "armeabi-v7a", "x86"
+      }
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+   implementation 'androidx.appcompat:appcompat:1.6.0'
+   implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
+      // For Accura OCR SDK
+    implementation 'com.github.accurascan:AccuraOCR:5.1.0'
+    // For Accura Face match
+    implementation 'com.github.accurascan:AccuraFaceMatch:3.2.0'
+    // for liveness
+    implementation 'com.github.accurascan:Liveness-Android:3.2.0'
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "AccurascanKyc"
+    codegenJavaPackageName = "com.accurascankyc"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+AccurascanKyc_kotlinVersion=1.7.0
+AccurascanKyc_minSdkVersion=21
+AccurascanKyc_targetSdkVersion=31
+AccurascanKyc_compileSdkVersion=31
+AccurascanKyc_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.accurascankyc">
+
+  <application>
+
+    <activity android:name="com.accurascankyc.ActivityFaceMatch"
+      android:theme="@style/FaceMatchTheme"/>
+
+    <activity android:name="com.accurascankyc.OcrActivity"
+      android:theme="@style/AppTheme"
+      android:screenOrientation="locked"/>
+
+    <activity android:name="com.accurascankyc.OcrResultActivity"
+      android:screenOrientation="locked"
+      android:theme="@style/AppThemeActionBar"/>
+  </application>
+
+</manifest>

package/android/src/main/java/com/accurascankyc/AccurascanKycModule.java

@@ -0,0 +1,507 @@
+package com.accurascankyc;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+
+import android.os.Build;
+import android.content.Context;
+import com.accurascan.ocr.mrz.model.BarcodeFormat;
+import com.accurascan.ocr.mrz.model.ContryModel;
+import com.accurascan.ocr.mrz.util.AccuraLog;
+import com.androidnetworking.AndroidNetworking;
+import com.docrecog.scan.MRZDocumentType;
+import com.docrecog.scan.RecogEngine;
+import com.docrecog.scan.RecogType;
+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.ReadableArray;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.Callback;
+
+import android.Manifest;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.util.Base64;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+
+@ReactModule(name = AccurascanKycModule.NAME)
+public class AccurascanKycModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "AccurascanKyc";
+  public static Bitmap face1 = null;
+  public static Bitmap face2 = null;
+  public static Callback onResult = null;
+
+  public static JSONObject accuraErrorConfg = new JSONObject();
+  public static JSONObject accuraTitleMsg = new JSONObject();
+  public static JSONObject accuraConfigs = new JSONObject();
+  private String bType;
+
+  public AccurascanKycModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+  public static String getSaltString() {
+    String SALTCHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+    StringBuilder salt = new StringBuilder();
+    Random rnd = new Random();
+    while (salt.length() < 18) { // length of the random string.
+      int index = (int) (rnd.nextFloat() * SALTCHARS.length());
+      salt.append(SALTCHARS.charAt(index));
+    }
+    return salt.toString();
+  }
+
+  public static Bitmap getBitmap(ContentResolver cr, Uri url)
+    throws FileNotFoundException, IOException {
+    InputStream input = cr.openInputStream(url);
+    Bitmap bitmap = BitmapFactory.decodeStream(input);
+    input.close();
+    return bitmap;
+  }
+
+  public static Bitmap getBase64ToBitmap(String base64Image) {
+
+    byte[] decodedString = Base64.decode(base64Image, Base64.DEFAULT);
+    Bitmap decodedByte = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
+    return decodedByte;
+  }
+
+  public static String getImageUri(Bitmap bitmap, String name, String path) {
+    OutputStream fOut = null;
+    File file = new File(path, getSaltString() + "_" + name + ".jpg");
+    try {
+      fOut = new FileOutputStream(file);
+    } catch (FileNotFoundException e) {
+      e.printStackTrace();
+    }
+    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fOut);
+    try {
+      fOut.flush(); // Not really required
+      fOut.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+    return "file://"+file.getAbsolutePath();
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  @ReactMethod
+  public void multiply(double a, double b, Promise promise) {
+    promise.resolve(a * b);
+  }
+
+  @ReactMethod
+  public boolean getMetaData( Callback callbackContext ) throws JSONException {
+
+    onResult = callbackContext;
+    RecogEngine recogEngine = new RecogEngine();
+    AccuraLog.enableLogs(false);
+    recogEngine.setDialog(false);
+    JSONObject results = new JSONObject();
+    RecogEngine.SDKModel sdkModel = recogEngine.initEngine(getReactApplicationContext());
+    if (sdkModel.i >= 0) {
+      AndroidNetworking.initialize(getReactApplicationContext(), UnsafeOkHttpClient.getUnsafeOkHttpClient());
+      results.put("sdk_version", recogEngine.getVersion());
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !isPermissionsGranted(getCurrentActivity())) {
+        requestCameraPermission();
+      }
+
+      results.put("isValid", true);
+      // if OCR enable then get card list
+      if (sdkModel.isOCREnable) {
+        results.put("isOCR", true);
+        List<ContryModel> modelList = recogEngine.getCardList(getCurrentActivity());
+        JSONArray countries = new JSONArray();
+        for (int i = 0; i < modelList.size(); i++) {
+          JSONObject country = new JSONObject();
+          country.put("name", modelList.get(i).getCountry_name());
+          country.put("id", modelList.get(i).getCountry_id());
+          JSONArray cards = new JSONArray();
+          List<ContryModel.CardModel> cardList = modelList.get(i).getCards();
+          for (int j = 0; j < cardList.size(); j++) {
+            JSONObject card = new JSONObject();
+            card.put("name", cardList.get(j).getCard_name());
+            card.put("id", cardList.get(j).getCard_id());
+            card.put("type", cardList.get(j).getCard_type());
+            cards.put(card);
+          }
+          country.put("cards", cards);
+          countries.put(country);
+        }
+        results.put("countries", countries);
+      }
+      results.put("isOCREnable", sdkModel.isOCREnable);
+      results.put("isBarcode", sdkModel.isAllBarcodeEnable);
+      if (sdkModel.isAllBarcodeEnable) {
+        List<BarcodeFormat> CODE_NAMES = BarcodeFormat.getList();
+        JSONArray barcodes = new JSONArray();
+        for (int i = 0; i < CODE_NAMES.size(); i++) {
+          JSONObject barcode = new JSONObject();
+          barcode.put("name", CODE_NAMES.get(i).barcodeTitle);
+          barcode.put("type", CODE_NAMES.get(i).formatsType);
+          barcodes.put(barcode);
+        }
+        results.put("barcodes", barcodes);
+      }
+      results.put("isBankCard", sdkModel.isBankCardEnable);
+      results.put("isMRZ", sdkModel.isMRZEnable);
+
+    } else {
+      results.put("isValid", false);
+    }
+    callbackContext.invoke(null, results.toString());
+    return true;
+  }
+
+  @ReactMethod
+  public boolean setupAccuraConfig(ReadableArray argsNew, Callback result) throws JSONException {
+
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+    RecogEngine recogEngine = new RecogEngine();
+
+    accuraConfigs = args.getJSONObject(0);
+    accuraErrorConfg = args.getJSONObject(1);
+    accuraTitleMsg = args.getJSONObject(2);
+
+    OcrActivity.accuraErrorConfg = accuraErrorConfg;
+    OcrActivity.accuraTitleMsg = accuraTitleMsg;
+    if (accuraConfigs.has("setFaceBlurPercentage")){
+      recogEngine.setFaceBlurPercentage(getCurrentActivity(), accuraConfigs.getInt("setFaceBlurPercentage"));
+    }else{
+      recogEngine.setFaceBlurPercentage(getCurrentActivity(),70);
+    }
+    if (accuraConfigs.has("setHologramDetection")){
+      recogEngine.SetHologramDetection(getCurrentActivity(),accuraConfigs.getBoolean("setHologramDetection"));
+    }else {
+      recogEngine.SetHologramDetection(getCurrentActivity(),true);
+    }
+    if (accuraConfigs.has("setLowLightTolerance")){
+      recogEngine.setLowLightTolerance(getCurrentActivity(),accuraConfigs.getInt("setLowLightTolerance"));
+    }else {
+      recogEngine.setLowLightTolerance(getCurrentActivity(),39);
+    }if (accuraConfigs.has("setMotionThreshold")){
+      recogEngine.setMotionThreshold(getCurrentActivity(),accuraConfigs.getInt("setMotionThreshold"));
+    }else {
+      recogEngine.setMotionThreshold(getCurrentActivity(),18);
+    }if (accuraConfigs.has("setMinGlarePercentage") &&
+      accuraConfigs.has("setMaxGlarePercentage")){
+      recogEngine.setGlarePercentage(getCurrentActivity(),accuraConfigs.getInt("setMinGlarePercentage"),
+        accuraConfigs.getInt("setMaxGlarePercentage") );
+    }else {
+      recogEngine.setGlarePercentage(getCurrentActivity(),6,98);
+    } if (accuraConfigs.has("setBlurPercentage")){
+      recogEngine.setBlurPercentage(getCurrentActivity(), accuraConfigs.getInt("setBlurPercentage"));
+    } else {
+      recogEngine.setBlurPercentage(getCurrentActivity(), 62);
+    }
+
+    // recogEngine.isCheckPhotoCopy(getCurrentActivity(),accuraConfigs.getBoolean("isCheckPhotoCopy"));
+    result.invoke(null, "Configs setup sucessfully");
+    return true;
+  }
+
+  @ReactMethod
+  public boolean startFaceMatch2(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    onResult = callbackContext;
+    ActivityFaceMatch.which = 3;
+
+    ActivityFaceMatch.No = 2;
+    JSONObject accuraConf = args.getJSONObject(0);
+    ActivityFaceMatch.faceMatchConfig = args.getJSONObject(1);
+    ActivityFaceMatch.sface = accuraConf.getString("face1");
+    ActivityFaceMatch.mface = accuraConf.getString("face2");
+    Intent intent = new Intent(getCurrentActivity(), ActivityFaceMatch.class);
+    getCurrentActivity().startActivity(intent);
+    return true;
+  }
+
+  @ReactMethod
+  public boolean openGallery1(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    onResult = callbackContext;
+    ActivityFaceMatch.which = 2;
+    ActivityFaceMatch.No = 1;
+    JSONObject accuraConf = args.getJSONObject(0);
+    ActivityFaceMatch.sface = accuraConf.getString("face1");
+    ActivityFaceMatch.mface = accuraConf.getString("face2");
+//    JSONObject config = args.getJSONObject(1);
+    Intent intent = new Intent(getCurrentActivity(), ActivityFaceMatch.class);
+//    intent = addDefaultConfigs(intent, accuraConf);
+//    intent = addDefaultConfigs(intent, config);
+    Objects.requireNonNull(getCurrentActivity()).startActivity(intent);
+    return true;
+  }
+
+  @ReactMethod
+  public boolean openGallery2(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+    onResult = callbackContext;
+    ActivityFaceMatch.No = 2;
+    ActivityFaceMatch.which = 4;
+    JSONObject accuraConf = args.getJSONObject(0);
+    ActivityFaceMatch.sface = accuraConf.getString("face1");
+    ActivityFaceMatch.mface = accuraConf.getString("face2");
+//    JSONObject config = args.getJSONObject(1);
+    Intent intent = new Intent(getCurrentActivity(), ActivityFaceMatch.class);
+//    intent = ActivityFaceMatch(intent, accuraConf);
+//    intent = addDefaultConfigs(intent, config);
+    getCurrentActivity().startActivity(intent);
+    return true;
+  }
+
+
+  @ReactMethod
+  public boolean startFaceMatch1(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    onResult = callbackContext;
+    ActivityFaceMatch.No = 1;
+    ActivityFaceMatch.which = 1;
+    JSONObject accuraConf = args.getJSONObject(0);
+    ActivityFaceMatch.faceMatchConfig = args.getJSONObject(1);
+    ActivityFaceMatch.sface = accuraConf.getString("face1");
+    ActivityFaceMatch.mface = accuraConf.getString("face2");
+//    JSONObject config = args.getJSONObject(1);
+    Intent intent = new Intent(getCurrentActivity(), ActivityFaceMatch.class);
+//    intent = addDefaultConfigs(intent, accuraConf);
+//    intent = addDefaultConfigs(intent, config);
+    getCurrentActivity().startActivity(intent);
+    return true;
+  }
+
+  @ReactMethod
+  public boolean startOcrWithCard(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    onResult = callbackContext;
+    OcrActivity.accuraErrorConfg = accuraErrorConfg;
+    OcrActivity.accuraTitleMsg = accuraTitleMsg;
+
+    int countryId = args.getInt(0);
+    int cardId = args.getInt(1);
+    String cardSelected = args.getString(2);
+    int cardType = args.getInt(3);
+
+    Intent intent = new Intent(getCurrentActivity(),OcrActivity.class);
+    intent.putExtra("country_id",countryId);
+    intent.putExtra("card_id",cardId);
+    intent.putExtra("card_name",cardSelected);
+
+    if (cardType == 1){
+      RecogType.PDF417.attachTo(intent);
+      OcrActivity.recogType = RecogType.PDF417;
+    }
+    else if (cardType == 2) {
+      RecogType.DL_PLATE.attachTo(intent);
+      OcrActivity.recogType = RecogType.DL_PLATE;
+    }
+    else {
+      RecogType.OCR.attachTo(intent);
+      OcrActivity.recogType = RecogType.OCR;
+    }
+
+    Objects.requireNonNull(getCurrentActivity()).startActivity(intent);
+    return true;
+  }
+
+  @ReactMethod
+  public boolean startMRZ( ReadableArray argsNew, Callback callbackContext ) throws JSONException {
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    String mrzType = args.getString(0);
+    Intent intent = new Intent(getCurrentActivity(),OcrActivity.class);
+    RecogType.MRZ.attachTo(intent);
+    OcrActivity.recogType = RecogType.MRZ;
+    if (mrzType.equals("passport_mrz")) {
+      MRZDocumentType.PASSPORT_MRZ.attachTo(intent);
+    }else if (mrzType.equals("id_mrz")){
+      MRZDocumentType.ID_CARD_MRZ.attachTo(intent);
+    }else if (mrzType.equals("visa_card")){
+      MRZDocumentType.VISA_MRZ.attachTo(intent);
+    }else{
+      MRZDocumentType.NONE.attachTo(intent);
+    }
+    OcrActivity.accuraErrorConfg = accuraErrorConfg;
+    OcrActivity.accuraTitleMsg = accuraTitleMsg;
+    intent.putExtra("card_name",mrzType);
+    intent.putExtra("app_orientation", Objects.requireNonNull(getCurrentActivity()).getRequestedOrientation());
+    onResult = callbackContext;
+
+    getCurrentActivity().startActivity(intent);
+    return true;
+  }
+
+  @ReactMethod
+  public boolean startBankCard(Callback callbackContext) throws JSONException {
+    onResult = callbackContext;
+    OcrActivity.accuraErrorConfg = accuraErrorConfg;
+    OcrActivity.accuraTitleMsg = accuraTitleMsg;
+
+    Intent intent = new Intent(getCurrentActivity(),OcrActivity.class);
+    intent.putExtra("card_name","Bank Card");
+    intent.putExtra("app_orientation", Objects.requireNonNull(getCurrentActivity()).getRequestedOrientation());
+
+    RecogType.BANKCARD.attachTo(intent);
+    OcrActivity.recogType = RecogType.BANKCARD;
+
+    getCurrentActivity().startActivity(intent);
+
+    return true;
+  }
+
+  @ReactMethod
+  public boolean startFaceMatch(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    onResult = callbackContext;
+
+    JSONArray arg = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    JSONObject uriL = arg.getJSONObject(0);
+    String uri = uriL.getString("face_uri");
+    OcrResultActivity.face1 = BitmapFactory.decodeFile(uri.replace("file://",""));
+    OcrResultActivity.which = 0;
+    OcrResultActivity.faceConfig = arg.getJSONObject(1);
+    Intent intent = new Intent(getCurrentActivity(),OcrResultActivity.class);
+    Objects.requireNonNull(getCurrentActivity()).startActivity(intent);
+
+    return true;
+  }
+
+  @ReactMethod
+  public boolean startLiveness(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    onResult = callbackContext;
+
+    JSONArray arg = ReactNativeJSON.convertArrayToJson(argsNew);
+    JSONObject uriL = arg.getJSONObject(0);
+    String uri = uriL.getString("face_uri");
+    OcrResultActivity.face1 = BitmapFactory.decodeFile(uri.replace("file://",""));
+    OcrResultActivity.which = 1;
+    OcrResultActivity.livenessConfig = arg.getJSONObject(1);
+    Intent intent = new Intent(getCurrentActivity(),OcrResultActivity.class);
+    getCurrentActivity().startActivity(intent);
+
+    return true;
+  };
+
+
+
+  @ReactMethod
+  public boolean startBarcode(ReadableArray argsNew, Callback callbackContext) throws JSONException {
+    onResult = callbackContext;
+    JSONArray args = ReactNativeJSON.convertArrayToJson(argsNew);
+
+    bType = args.getString(0);
+    OcrActivity.accuraErrorConfg = accuraErrorConfg;
+    OcrActivity.accuraTitleMsg = accuraTitleMsg;
+    OcrActivity.barcodeFormat = getBarcodeFormat(bType);
+    OcrActivity.recogType = RecogType.BARCODE;
+    Intent intent = new Intent(getCurrentActivity(),OcrActivity.class);
+    RecogType.BARCODE.attachTo(intent);
+    Objects.requireNonNull(getCurrentActivity()).startActivity(intent);
+    return true;
+  }
+
+  public static boolean isPermissionsGranted(Context context) {
+    String[] permissions = new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE};
+    for (String permission : permissions) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+        if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
+          return false;
+        }
+    }
+    return true;
+  }
+
+
+  public void requestCameraPermission() {
+    int currentapiVersion = Build.VERSION.SDK_INT;
+    if (currentapiVersion >= Build.VERSION_CODES.M) {
+      if (ActivityCompat.checkSelfPermission(getCurrentActivity(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
+        || ActivityCompat.checkSelfPermission(getCurrentActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+        if (ActivityCompat.shouldShowRequestPermissionRationale(getCurrentActivity(), Manifest.permission.CAMERA)
+          || ActivityCompat.shouldShowRequestPermissionRationale(getCurrentActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
+          getCurrentActivity().requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
+        } else {
+          getCurrentActivity().requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
+        }
+      }
+    }
+  }
+
+  public int getBarcodeFormat(String barcode){
+    int resultOf = 0;
+    switch (bType) {
+      case "0.0":     //"ALL FORMATS":
+        resultOf = 0;
+        break;
+      case "64.0": //"EAN-8":
+        resultOf = 64;
+        break;
+      case "32.0": //"EAN-13":
+        resultOf = 32;
+        break;
+      case "2048.0": //"PDF417":
+        resultOf = 2048;
+        break;
+      case "4096.0": //"AZTEC":
+        resultOf = 4096;
+        break;
+      case "1.0": //"CODE 128":
+        resultOf = 1;
+        break;
+      case "4.0": //"CODE 93":
+        resultOf = 4;
+        break;
+      case "2.0": //"CODE 39":
+        resultOf = 2;
+        break;
+      case "16.0": //"DATA MATRIX":
+        resultOf = 16;
+        break;
+      case "256.0": //"QR CODE":
+        resultOf = 256;
+        break;
+      case "8.0": //"CODABAR":
+        resultOf = 8;
+        break;
+      case "1024.0": //"UPC-E":
+        resultOf = 1024;
+        break;
+      case "512.0": //"UPC-A":
+        resultOf = 512;
+        break;
+    }
+    return resultOf;
+  }
+  
+}

package/android/src/main/java/com/accurascankyc/AccurascanKycPackage.java

@@ -0,0 +1,28 @@
+package com.accurascankyc;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class AccurascanKycPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new AccurascanKycModule(reactContext));
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}