@regulaforensics/document-reader 8.2.186-beta

package/README.md

@@ -0,0 +1,18 @@
+# Regula Document Reader plugin
+Document Reader allows you to read various kinds of identification documents, passports, driving licenses, ID cards, etc. All processing is performed completely offline on your device. This plugin makes possible to use it with react-native, cordova and ionic applications.
+
+## Demo applications
+In the [examples](examples/) folder you can find 4 demo applications:
+* [React-native](examples/react-native)
+* [Cordova](examples/cordova)
+* [Ionic(ionic app with cordova, angular)](examples/ionic)
+* [Capacitor(ionic app with capacitor, react)](examples/capacitor)
+
+Each demo app has its own readme file with instructions on building and installation.
+
+## Documentation
+* [Documentation](https://docs.regulaforensics.com/develop/doc-reader-sdk/mobile)
+* [API Reference](https://dev.regulaforensics.com/npm-document-reader)
+
+## Support
+If you have any technical questions, feel free to [contact](mailto:support@regulaforensics.com) us or create issues [here](https://github.com/regulaforensics/npm-document-reader/issues).

package/RNDocumentReader.podspec

@@ -0,0 +1,21 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+source = File.join(__dir__, 'ios')
+
+Pod::Spec.new do |s|
+  s.name         = 'RNDocumentReader'
+  s.version      = '8.2.186-beta'
+  s.summary      = package['description']
+  s.license      = package['license']
+
+  s.authors      = { 'RegulaForensics' => 'support@regulaforensics.com' }
+  s.homepage     = 'https://regulaforensics.com'
+
+  s.source       = { http: "file:#{source}" }
+  s.ios.deployment_target = '13.0'
+  s.source_files = 'ios/**/*.{h,m}'
+  s.exclude_files = [ 'ios/CVDDocumentReader.h', 'ios/CVDDocumentReader.m' ]
+  s.dependency 'DocumentReader', '8.1.4772'
+  s.dependency 'React'
+end

package/android/CVDDocumentReader.kt

@@ -0,0 +1,74 @@
+package com.regula.plugin.documentreader
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.Lifecycle
+import org.apache.cordova.CallbackContext
+import org.apache.cordova.CordovaPlugin
+import org.apache.cordova.PluginResult
+import org.json.JSONArray
+
+val eventCallbackIds = mutableMapOf<String, String>()
+
+lateinit var args: JSONArray
+lateinit var binding: CordovaPlugin
+val context: Context
+    get() = binding.cordova.context
+ val activity: Activity
+     get() = binding.cordova.activity
+val lifecycle: Lifecycle
+    get() = (activity as AppCompatActivity).lifecycle
+
+fun sendEvent(callbackId: String, data: Any? = "") {
+    val pluginResult = when (data) {
+        is Int -> PluginResult(PluginResult.Status.OK, data)
+        is Boolean -> PluginResult(PluginResult.Status.OK, data)
+        else -> PluginResult(PluginResult.Status.OK, data.toSendable() as String?)
+    }
+    pluginResult.keepCallback = true
+    binding.webView.sendPluginResult(pluginResult, eventCallbackIds[callbackId] ?: callbackId)
+}
+
+@Suppress("UNCHECKED_CAST")
+fun <T> argsNullable(index: Int): T? = if (args.get(index).toString() != "null") {
+    args.get(index) as T
+} else null
+
+fun requestPermissions(@Suppress("UNUSED_PARAMETER") activity: Activity, permissions: Array<String>, requestCode: Int) = binding.cordova.requestPermissions(binding, requestCode, permissions)
+fun startActivityForResult(@Suppress("UNUSED_PARAMETER") activity: Activity, intent: Intent, requestCode: Int) = binding.cordova.startActivityForResult(binding, intent, requestCode)
+fun myOnRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) = onRequestPermissionsResult(requestCode, permissions, grantResults)
+fun myOnActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) = onActivityResult(requestCode, resultCode, intent)
+
+class CVDDocumentReader : CordovaPlugin() {
+    init {
+        binding = this
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        newIntent(intent)
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
+        myOnActivityResult(requestCode, resultCode, intent)
+    }
+
+    @Suppress("OVERRIDE_DEPRECATION")
+    override fun onRequestPermissionResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
+        myOnRequestPermissionsResult(requestCode, permissions, grantResults)
+    }
+
+    override fun execute(action: String, arguments: JSONArray, callbackContext: CallbackContext): Boolean {
+        args = arguments
+        val method = args.remove(0) as String
+        if (method == "setEvent") eventCallbackIds[args(0)] = callbackContext.callbackId
+        try {
+            methodCall(method) { data: Any? -> sendEvent(callbackContext.callbackId, data) }
+        } catch (error: Exception) {
+            Log.e("REGULA", "Caught exception in \"$method\" function:", error)
+        }
+        return true
+    }
+}

package/android/build.gradle

@@ -0,0 +1,36 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    // Conditional for compatibility with AGP <4.2.
+    if (project.android.hasProperty("namespace")) {
+        namespace 'com.regula.plugin.documentreader'
+    }
+
+    compileSdk 35
+
+    defaultConfig {
+        minSdkVersion 24
+        targetSdk 35
+        versionCode 1
+        versionName "1.0"
+    }
+}
+
+rootProject.allprojects {
+    repositories {
+        maven {
+            url "https://maven.regulaforensics.com/RegulaDocumentReader"
+        }
+    }
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation 'com.facebook.react:react-native:+'
+    //noinspection GradleDependency
+    implementation('com.regula.documentreader:api:8.1.11551'){
+        transitive = true
+    }
+}
+  

package/android/cordova.gradle

@@ -0,0 +1,12 @@
+repositories {
+    maven {
+        url "https://maven.regulaforensics.com/RegulaDocumentReader"
+    }
+}
+
+dependencies {
+    //noinspection GradleDependency
+    implementation('com.regula.documentreader:api:8.1.11551'){
+        transitive = true
+    }
+}

package/android/src/main/java/com/regula/plugin/documentreader/BluetoothUtil.kt

@@ -0,0 +1,160 @@
+package com.regula.plugin.documentreader
+
+import android.Manifest.permission.ACCESS_FINE_LOCATION
+import android.Manifest.permission.BLUETOOTH_CONNECT
+import android.Manifest.permission.BLUETOOTH_SCAN
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.bluetooth.BluetoothAdapter
+import android.content.ComponentName
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.PackageManager.PERMISSION_GRANTED
+import android.os.Build
+import android.os.IBinder
+import android.provider.Settings
+import android.util.Log
+import androidx.core.content.ContextCompat.checkSelfPermission
+import com.regula.common.ble.BLEWrapper
+import com.regula.common.ble.BleWrapperCallback
+import com.regula.common.ble.RegulaBleService
+import com.regula.documentreader.api.internal.permission.BluetoothPermissionHelper.BLE_ACCESS_PERMISSION
+import com.regula.documentreader.api.internal.permission.BluetoothSettingsHelper.isBluetoothEnabled
+import com.regula.documentreader.api.internal.permission.BluetoothSettingsHelper.isLocationServiceEnabled
+import java.util.Timer
+import java.util.TimerTask
+
+const val SEARCHING_TIMEOUT: Long = 7000
+
+const val INTENT_REQUEST_ENABLE_LOCATION = 196
+const val INTENT_REQUEST_ENABLE_BLUETOOTH = 197
+
+@SuppressLint("StaticFieldLeak")
+var bluetooth: BLEWrapper? = null
+lateinit var savedCallbackForPermissionResult: Callback
+
+fun connectBluetoothDevice(callback: Callback) {
+    if (bluetooth?.isConnected == true) {
+        Log.e("REGULA", "Bluetooth device already connected, returning false")
+        callback(false)
+        return
+    }
+
+    if (!isBluetoothSettingsReady(activity)) {
+        savedCallbackForPermissionResult = callback
+        return
+    }
+
+    val timeout = object : TimerTask() {
+        override fun run() {
+            callback(false)
+            bluetooth?.stopDeviceScan()
+            bluetooth?.disconnect()
+        }
+    }
+    Timer().schedule(timeout, SEARCHING_TIMEOUT)
+
+    val bleIntent = Intent(context, RegulaBleService::class.java)
+    context.startService(bleIntent)
+    context.bindService(bleIntent, object : ServiceConnection {
+        override fun onServiceConnected(name: ComponentName, service: IBinder) {
+            bluetooth = (service as RegulaBleService.LocalBinder).service.bleManager
+            if (bluetooth!!.isConnected) callback(true)
+            else bluetooth!!.addCallback(object : BleWrapperCallback() {
+                override fun onDeviceReady() {
+                    timeout.cancel()
+                    bluetooth!!.removeCallback(this)
+                    callback(true)
+                }
+            })
+        }
+
+        override fun onServiceDisconnected(name: ComponentName) {}
+    }, 0)
+}
+
+fun onRequestPermissionsResult(
+    requestCode: Int,
+    permissions: Array<String>,
+    grantResults: IntArray
+): Boolean {
+    if (requestCode != BLE_ACCESS_PERMISSION || permissions.isEmpty()) return false
+    if (grantResults.isEmpty() || grantResults[0] != PERMISSION_GRANTED) {
+        savedCallbackForPermissionResult(false)
+        return true
+    }
+    connectBluetoothDevice(savedCallbackForPermissionResult)
+    return true
+}
+
+fun onActivityResult(requestCode: Int, rc: Int, @Suppress("UNUSED_PARAMETER") data: Intent?): Boolean {
+    var resultCode = rc
+    if (requestCode == INTENT_REQUEST_ENABLE_LOCATION)
+        resultCode = if (isLocationServiceEnabled(activity)) Activity.RESULT_OK
+        else requestCode
+
+    if (requestCode == INTENT_REQUEST_ENABLE_BLUETOOTH || requestCode == INTENT_REQUEST_ENABLE_LOCATION) {
+        if (resultCode == Activity.RESULT_OK)
+            connectBluetoothDevice(savedCallbackForPermissionResult)
+        else
+            savedCallbackForPermissionResult(false)
+        return true
+    }
+    return false
+}
+
+fun isBluetoothSettingsReady(activity: Activity): Boolean {
+    deniedBluetoothPermissions()?.let {
+        requestPermissions(activity, it, BLE_ACCESS_PERMISSION)
+        return false
+    }
+    if (!isBluetoothEnabled(activity)) {
+        requestEnableBluetooth(activity)
+        return false
+    }
+    if (!isLocationServiceEnabled(activity)) {
+        requestEnableLocationService(activity)
+        return false
+    }
+    return true
+}
+
+fun deniedBluetoothPermissions(): Array<String>? {
+    val result = mutableListOf<String>()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        result.addAll(deniedBluetoothPermission(BLUETOOTH_SCAN))
+        result.addAll(deniedBluetoothPermission(BLUETOOTH_CONNECT))
+    } else
+        result.addAll(deniedBluetoothPermission(ACCESS_FINE_LOCATION))
+    return result.let { if (it.size > 0) it.toTypedArray() else null }
+}
+
+fun deniedBluetoothPermission(permission: String): Array<String> {
+    if (checkSelfPermission(context, permission) != PERMISSION_GRANTED)
+        return arrayOf(permission)
+    return arrayOf()
+}
+
+fun requestEnableBluetooth(activity: Activity) {
+    val enableIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
+    startActivityForResult(activity, enableIntent, INTENT_REQUEST_ENABLE_BLUETOOTH)
+}
+
+fun requestEnableLocationService(activity: Activity) {
+    val myIntent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
+    startActivityForResult(activity, myIntent, INTENT_REQUEST_ENABLE_LOCATION)
+}
+
+// btDevice functionality(temporary, will be reworked)
+
+fun btDeviceRequestFlashing() {
+    bluetooth?.requestFlashing()
+}
+
+fun btDeviceRequestFlashingFullIR() {
+    bluetooth?.requestFlashingFullIR()
+}
+
+fun btDeviceRequestTurnOffAll() {
+    bluetooth?.requestTurnOffAll()
+}