@veriff/react-native-sdk 6.0.0 → 6.2.0

package/android/src/main/java/com/veriff/sdk/reactnative/VeriffSdkModule.kt

@@ -0,0 +1,449 @@
+package com.veriff.sdk.reactnative
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.BaseActivityEventListener
+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.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.veriff.Branding
+import com.veriff.Configuration
+import com.veriff.Font
+import com.veriff.GeneralConfig
+import com.veriff.Result
+import com.veriff.Sdk.createLaunchIntent
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import java.util.Locale
+
+class VeriffSdkModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private var lastResult: Result? = null
+  private var sessionToken: String? = null
+  private var status: String? = null
+
+  @ReactMethod
+  fun recoverLastResult(promise: Promise) {
+    if (lastResult != null && status != null && sessionToken != null) {
+      sendResult(lastResult, status, sessionToken, promise)
+      lastResult = null
+      sessionToken = null
+      status = null
+    }
+  }
+
+  override fun getName(): String {
+    return JS_NAME
+  }
+
+  override fun getConstants(): Map<String, Any> {
+    return EXPORTED_CONSTANTS
+  }
+
+  @ReactMethod
+  fun launchVeriff(configuration: ReadableMap, promise: Promise) {
+    try {
+      val sessionToken: String?
+      val startUrl: String?
+      if (configuration.hasKey(KEY_SESSION_URL) &&
+        !configuration.getString(KEY_SESSION_URL).isNullOrEmpty()
+      ) {
+        startUrl = configuration.getString(KEY_SESSION_URL)
+        sessionToken = if (startUrl != null) extractToken(startUrl) else null
+        if (startUrl.isNullOrEmpty() || sessionToken.isNullOrEmpty()) {
+          promise.reject(ERROR_INVALID_ARGS, "Invalid session url $startUrl")
+          return
+        }
+      } else {
+        sessionToken =
+          if (configuration.hasKey(KEY_TOKEN)) configuration.getString(KEY_TOKEN) else null
+        if (sessionToken.isNullOrEmpty()) {
+          promise.reject(
+            ERROR_INVALID_ARGS,
+            "No sessionToken in Veriff SDK configuration"
+          )
+          return
+        }
+        var baseUrl: String? = null
+        if (configuration.hasKey(KEY_BASE_URL)) {
+          baseUrl = configuration.getString(KEY_BASE_URL)
+        }
+        if (baseUrl.isNullOrEmpty()) {
+          baseUrl = DEFAULT_BASE_URL
+        }
+        if (baseUrl.endsWith("/")) {
+          baseUrl = baseUrl.substring(0, baseUrl.length - 1)
+        }
+        startUrl = "$baseUrl/v/$sessionToken"
+      }
+
+      this.sessionToken = sessionToken
+      lastResult = null
+      status = null
+
+      val activity = currentActivity
+      if (activity == null) {
+        promise.reject(ERROR_ACTIVITY_NOT_ATTACHED, "No activity attached while launching Veriff")
+        return
+      }
+
+      val listener = object : BaseActivityEventListener() {
+        override fun onActivityResult(
+          activity: Activity,
+          requestCode: Int,
+          resultCode: Int,
+          data: Intent?
+        ) {
+          if (requestCode == VERIFF_REQUEST_CODE) {
+            if (data == null) {
+              return
+            }
+            val token = data.getStringExtra(GeneralConfig.INTENT_EXTRA_SESSION_URL)
+            if (sessionToken != token && startUrl != token) {
+              return
+            }
+            reactContext.removeActivityEventListener(this)
+            val veriffResult = Result.fromResultIntent(data)
+            lastResult = veriffResult
+            status = statusToString(getVeriffStatus(resultCode, veriffResult))
+            sendResult(veriffResult, status, sessionToken, promise)
+          }
+        }
+      }
+      reactContext.addActivityEventListener(listener)
+      val configBuilder = Configuration.Builder()
+      if (configuration.hasKey(KEY_CUSTOM_INTRO_SCREEN)) {
+        configBuilder.customIntroScreen(configuration.getBoolean(KEY_CUSTOM_INTRO_SCREEN))
+      }
+      if (configuration.hasKey(KEY_BRANDING)) {
+        val brandConfig = configuration.getMap(KEY_BRANDING)
+        if (brandConfig != null) {
+          val branding = Branding.Builder()
+          if (brandConfig.hasKey(KEY_LOGO)) {
+            handleLogo(activity, KEY_LOGO, branding, brandConfig)
+          }
+          if (brandConfig.hasKey(KEY_BACKGROUND)) {
+            branding.background(parseColor(brandConfig.getString(KEY_BACKGROUND)))
+          }
+          if (brandConfig.hasKey(KEY_ON_BACKGROUND)) {
+            branding.onBackground(parseColor(brandConfig.getString(KEY_ON_BACKGROUND)))
+          }
+          if (brandConfig.hasKey(KEY_ON_BACKGROUND_SECONDARY)) {
+            branding.onBackgroundSecondary(
+              parseColor(brandConfig.getString(KEY_ON_BACKGROUND_SECONDARY))
+            )
+          }
+          if (brandConfig.hasKey(KEY_ON_BACKGROUND_TERTIARY)) {
+            branding.onBackgroundTertiary(
+              parseColor(brandConfig.getString(KEY_ON_BACKGROUND_TERTIARY))
+            )
+          }
+          if (brandConfig.hasKey(KEY_PRIMARY)) {
+            branding.primary(parseColor(brandConfig.getString(KEY_PRIMARY)))
+          }
+          if (brandConfig.hasKey(KEY_ON_PRIMARY)) {
+            branding.onPrimary(parseColor(brandConfig.getString(KEY_ON_PRIMARY)))
+          }
+          if (brandConfig.hasKey(KEY_SECONDARY)) {
+            branding.secondary(parseColor(brandConfig.getString(KEY_SECONDARY)))
+          }
+          if (brandConfig.hasKey(KEY_ON_SECONDARY)) {
+            branding.onSecondary(parseColor(brandConfig.getString(KEY_ON_SECONDARY)))
+          }
+          if (brandConfig.hasKey(KEY_CAMERA_OVERLAY)) {
+            branding.cameraOverlay(parseColor(brandConfig.getString(KEY_CAMERA_OVERLAY)))
+          }
+          if (brandConfig.hasKey(KEY_ON_CAMERA_OVERLAY)) {
+            branding.onCameraOverlay(
+              parseColor(brandConfig.getString(KEY_ON_CAMERA_OVERLAY))
+            )
+          }
+          if (brandConfig.hasKey(KEY_OUTLINE)) {
+            branding.outline(parseColor(brandConfig.getString(KEY_OUTLINE)))
+          }
+          if (brandConfig.hasKey(KEY_SUCCESS)) {
+            branding.success(parseColor(brandConfig.getString(KEY_SUCCESS)))
+          }
+          if (brandConfig.hasKey(KEY_ERROR)) {
+            branding.error(parseColor(brandConfig.getString(KEY_ERROR)))
+          }
+          if (brandConfig.hasKey(KEY_BUTTON_RADIUS)) {
+            branding.buttonRadius(brandConfig.getDouble(KEY_BUTTON_RADIUS).toFloat())
+          }
+          if (brandConfig.hasKey(KEY_FONT)) {
+            brandConfig.getMap(KEY_FONT)?.let { srcFont ->
+              val font = buildFont(activity, srcFont)
+              branding.font(font)
+            }
+          }
+          configBuilder.branding(branding.build())
+        }
+      }
+
+      if (configuration.hasKey(KEY_LOCALE)) {
+        configuration.getString(KEY_LOCALE)?.let { locale ->
+          configBuilder.locale(Locale.forLanguageTag(locale))
+        }
+      }
+
+      if (configuration.hasKey(KEY_RN_VENDOR_DATA)) {
+        configuration.getString(KEY_RN_VENDOR_DATA)?.let { vendorData ->
+          configBuilder.vendorData(vendorData)
+        }
+      }
+
+      val intent = createLaunchIntent(activity, startUrl, configBuilder.build())
+      activity.startActivityForResult(intent, VERIFF_REQUEST_CODE)
+    } catch (t: Throwable) {
+      Log.e(TAG, "starting verification failed", t)
+      promise.reject(t)
+    }
+  }
+
+  private fun sendResult(
+    veriffResult: Result?,
+    status: String?,
+    sessionToken: String?,
+    promise: Promise
+  ) {
+    val result = Arguments.createMap()
+    result.putString(KEY_TOKEN, sessionToken)
+    result.putString(KEY_STATUS, status)
+    if (veriffResult != null && veriffResult.error != null) {
+      result.putString(KEY_RESULT_ERROR, codeToError(veriffResult.error))
+    }
+    promise.resolve(result)
+  }
+
+  private fun buildFont(context: Context, src: ReadableMap): Font {
+    val regularFont = getFontId(context, src.getString(KEY_FONT_REGULAR))
+    val mediumFont = getFontId(context, src.getString(KEY_FONT_MEDIUM))
+    val boldFont = getFontId(context, src.getString(KEY_FONT_BOLD))
+    Log.v(
+      TAG, String.format(
+        "Regular font: [%s], value [%s]",
+        src.getString(KEY_FONT_REGULAR), regularFont
+      )
+    )
+    Log.v(
+      TAG, String.format(
+        "Medium font: [%s], value [%s]",
+        src.getString(KEY_FONT_MEDIUM), mediumFont
+      )
+    )
+    Log.v(
+      TAG, String.format(
+        "Bold font: [%s], value [%s]",
+        src.getString(KEY_FONT_BOLD), boldFont
+      )
+    )
+    return Font.Builder()
+      .setRegular(regularFont)
+      .setMedium(mediumFont)
+      .setBold(boldFont)
+      .build()
+  }
+
+  private fun handleLogo(
+    context: Context,
+    key: String,
+    branding: Branding.Builder,
+    brandConfig: ReadableMap
+  ) {
+    val type = brandConfig.getType(key)
+    Log.d(TAG, "Logo type$type")
+    if (ReadableType.String == type) {
+      branding.logo(getDrawableId(context, brandConfig.getString(key)))
+    } else if (ReadableType.Map == type) {
+      // check if it's a native RN image
+      val image = brandConfig.getMap(key)
+      if (image != null) {
+        if (image.hasKey(KEY_RN_IMAGE_URI)) {
+          val url = image.getString(KEY_RN_IMAGE_URI)
+          if (!url.isNullOrEmpty()) {
+            // check if url has an async scheme
+            if (isAsyncLogoUrl(url)) {
+              Log.d(TAG, "Async logo$url")
+              branding.logo(ReactNativeImageProvider(url))
+            } else {
+              Log.d(TAG, "Logo from resource$url")
+              branding.logo(getDrawableId(context, url))
+            }
+          } else {
+            Log.w(TAG, "Image url is empty: $url")
+          }
+        } else {
+          for (imageKey in image.toHashMap().keys) {
+            Log.w(TAG, imageKey)
+          }
+        }
+      } else {
+        Log.w(TAG, "Provided image is null")
+      }
+    } else {
+      Log.w(TAG, "Unexpected image type: $type")
+    }
+  }
+
+  private fun extractToken(startUrl: String): String? {
+    // this is suboptimal but it is what it is.. the SDK returns us a token in the
+    // INTENT_EXTRA_SESSION_URL for matching :(
+    val url = startUrl.toHttpUrlOrNull() ?: return null
+    return if (url.encodedPathSegments.size < 2) {
+      null
+    } else url.encodedPathSegments[1]
+  }
+
+  private fun isAsyncLogoUrl(url: String): Boolean {
+    return url.startsWith("https://") || url.startsWith("http://") || url.startsWith("file://")
+  }
+
+  private fun parseColor(hexcolor: String?): Int {
+    if (hexcolor == null) {
+      return 0
+    }
+    if (hexcolor.startsWith("#")) {
+      return parseColor(hexcolor.substring(1))
+    }
+    var color = hexcolor.toLong(16)
+    var a = 255
+    if (hexcolor.length > 6) {
+      a = color.toInt() and 0xff
+      color = color ushr 8
+    }
+    val r = (color ushr 16).toInt() and 0xff
+    val g = (color ushr 8).toInt() and 0xff
+    val b = (color ushr 0).toInt() and 0xff
+    return Color.argb(a, r, g, b)
+  }
+
+  companion object {
+    /**
+     * Indicates that the parameters passed to [.launchVeriff] were invalid.
+     */
+    private const val ERROR_INVALID_ARGS = "E_VERIFF_INVALID_ARGUMENTS"
+
+    /**
+     * Indicates that the activity is no longer attached when the
+     * [.launchVeriff] method was invoked.
+     */
+    private const val ERROR_ACTIVITY_NOT_ATTACHED = "E_VERIFF_ACTIVITY_NOT_ATTACHED"
+
+    /**
+     * The user canceled left the flow before completing it.
+     */
+    private const val STATUS_CANCELED = "STATUS_CANCELED"
+
+    /**
+     * The flow was completed, note that this doesn't mean there's a decision yet.
+     */
+    private const val STATUS_DONE = "STATUS_DONE"
+
+    /**
+     * The flow did not complete successfully.
+     */
+    private const val STATUS_ERROR = "STATUS_ERROR"
+    private const val DEFAULT_BASE_URL = "https://magic.veriff.me"
+    const val TAG = "@veriff/RN-SDK"
+    private const val JS_NAME = "VeriffSdk"
+    private const val VERIFF_REQUEST_CODE = 47239
+    private const val KEY_TOKEN = "sessionToken"
+    private const val KEY_BASE_URL = "baseUrl"
+    private const val KEY_SESSION_URL = "sessionUrl"
+    private const val KEY_BRANDING = "branding"
+    private const val KEY_LOCALE = "locale"
+    private const val KEY_STATUS = "status"
+    private const val KEY_RESULT_ERROR = "result_error"
+    private const val KEY_LOGO = "logo"
+    private const val KEY_BACKGROUND = "background"
+    private const val KEY_ON_BACKGROUND = "onBackground"
+    private const val KEY_ON_BACKGROUND_SECONDARY = "onBackgroundSecondary"
+    private const val KEY_ON_BACKGROUND_TERTIARY = "onBackgroundTertiary"
+    private const val KEY_PRIMARY = "primary"
+    private const val KEY_ON_PRIMARY = "onPrimary"
+    private const val KEY_SECONDARY = "secondary"
+    private const val KEY_ON_SECONDARY = "onSecondary"
+    private const val KEY_CAMERA_OVERLAY = "cameraOverlay"
+    private const val KEY_ON_CAMERA_OVERLAY = "onCameraOverlay"
+    private const val KEY_OUTLINE = "outline"
+    private const val KEY_SUCCESS = "success"
+    private const val KEY_ERROR = "error"
+    const val KEY_BUTTON_RADIUS = "buttonRadius"
+    private const val KEY_CUSTOM_INTRO_SCREEN = "customIntroScreen"
+    private const val KEY_RN_IMAGE_URI = "uri"
+    private const val KEY_RN_VENDOR_DATA = "vendorData"
+    private const val KEY_FONT = "androidFont"
+    private const val KEY_FONT_REGULAR = "regular"
+    private const val KEY_FONT_MEDIUM = "medium"
+    private const val KEY_FONT_BOLD = "bold"
+    private const val ERROR_UNABLE_TO_ACCESS_CAMERA = "UNABLE_TO_ACCESS_CAMERA"
+    private const val ERROR_UNABLE_TO_RECORD_AUDIO = "UNABLE_TO_RECORD_AUDIO"
+    private const val ERROR_UNABLE_TO_START_CAMERA = "UNABLE_TO_START_CAMERA"
+    private const val ERROR_NO_IDENTIFICATION_METHODS_AVAILABLE =
+      "NO_IDENTIFICATION_METHODS_AVAILABLE"
+    private const val ERROR_UNSUPPORTED_SDK_VERSION = "UNSUPPORTED_SDK_VERSION"
+    private const val ERROR_SESSION = "SESSION_ERROR"
+    private const val ERROR_SETUP = "SETUP_ERROR"
+    private const val ERROR_NETWORK = "NETWORK_ERROR"
+    private const val ERROR_UNKNOWN = "UNKNOWN_ERROR"
+    private const val ERROR_NFC_DISABLED = "NFC_DISABLED"
+    private const val ERROR_DEVICE_HAS_NO_NFC = "DEVICE_HAS_NO_NFC"
+    private val EXPORTED_CONSTANTS: MutableMap<String, Any> = HashMap()
+
+    init {
+      // promise reject errors
+      EXPORTED_CONSTANTS["errorInvalidArgs"] = ERROR_INVALID_ARGS
+      EXPORTED_CONSTANTS["errorActivityNotAttached"] =
+        ERROR_ACTIVITY_NOT_ATTACHED
+
+      // promise resolve statuses
+      EXPORTED_CONSTANTS["statusCanceled"] = STATUS_CANCELED
+      EXPORTED_CONSTANTS["statusDone"] = STATUS_DONE
+      EXPORTED_CONSTANTS["statusError"] = STATUS_ERROR
+    }
+
+    private fun getVeriffStatus(resultCode: Int, veriffResult: Result?): Result.Status {
+      return veriffResult?.status
+        ?: if (resultCode == Activity.RESULT_CANCELED) Result.Status.CANCELED else Result.Status.ERROR
+    }
+
+    private fun getDrawableId(context: Context, name: String?): Int {
+      return context.resources.getIdentifier(name, "drawable", context.packageName)
+    }
+
+    private fun getFontId(context: Context, name: String?): Int {
+      return context.resources.getIdentifier(name, "font", context.packageName)
+    }
+
+    private fun codeToError(error: Result.Error?): String {
+      return when (error) {
+        Result.Error.UNABLE_TO_ACCESS_CAMERA -> ERROR_UNABLE_TO_ACCESS_CAMERA
+        Result.Error.UNABLE_TO_RECORD_AUDIO -> ERROR_UNABLE_TO_RECORD_AUDIO
+        Result.Error.UNABLE_TO_START_CAMERA -> ERROR_UNABLE_TO_START_CAMERA
+        Result.Error.UNSUPPORTED_SDK_VERSION -> ERROR_UNSUPPORTED_SDK_VERSION
+        Result.Error.SESSION_ERROR -> ERROR_SESSION
+        Result.Error.NETWORK_ERROR -> ERROR_NETWORK
+        Result.Error.SETUP_ERROR -> ERROR_SETUP
+        Result.Error.NFC_DISABLED -> ERROR_NFC_DISABLED
+        Result.Error.DEVICE_HAS_NO_NFC -> ERROR_DEVICE_HAS_NO_NFC
+        Result.Error.UNKNOWN_ERROR -> ERROR_UNKNOWN
+        else -> ERROR_UNKNOWN
+      }
+    }
+
+    private fun statusToString(status: Result.Status): String {
+      return when (status) {
+        Result.Status.DONE -> STATUS_DONE
+        Result.Status.CANCELED -> STATUS_CANCELED
+        else -> STATUS_ERROR
+      }
+    }
+  }
+}

package/android/src/main/java/com/veriff/sdk/reactnative/VeriffSdkPackage.kt

@@ -0,0 +1,18 @@
+package com.veriff.sdk.reactnative
+
+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.Arrays
+
+@Suppress("unused")
+class VeriffSdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf<NativeModule>(VeriffSdkModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/catalog-info.yaml

@@ -4,7 +4,7 @@ metadata:
   name: react-native-sdk
   description: React Native wrapper around our native Android & iOS SDKs
   annotations:
-    veriff.com/criticality: high
+    veriff.com/criticality: disaster
     github.com/project-slug: Veriff/react-native-sdk
     circleci.com/project-slug: github/Veriff/react-native-sdk
     sonarqube.org/project-key: Veriff_react-native-sdk

package/ios/Podfile

@@ -9,7 +9,7 @@ require Pod::Executable.execute_command('node', ['-p',
 
 target 'VeriffSdk' do
   # Pods for VeriffSdk
-  pod 'VeriffSDK', '6.23.0'
+  pod 'VeriffSDK', '6.32.0'
 
   config = use_native_modules!
 

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@veriff/react-native-sdk",
   "title": "React Native Veriff SDK",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "description": "React Native SDK for Veriff identity verification",
   "main": "index.js",
   "scripts": {
-    "lint": "eslint .",
-    "check-dependencies": "rnx-align-deps",
-    "fix-dependencies": "rnx-align-deps --write"
+    "lint": "eslint ."
   },
   "homepage": "https://developers.veriff.com/#react-native-sdk-integration",
   "keywords": [
@@ -31,56 +29,19 @@
     "react-native": "^0.73.0"
   },
   "devDependencies": {
+    "@babel/core": "^7.20.0",
+    "@babel/preset-env": "^7.20.0",
+    "@babel/runtime": "^7.20.0",
+    "@react-native/babel-preset": "^0.73.18",
     "@react-native/eslint-config": "^0.73.1",
     "@react-native/metro-config": "^0.73.2",
-    "@rnx-kit/align-deps": "^2.2.0",
+    "@react-native/typescript-config": "^0.73.1",
+    "@types/react": "^18.2.6",
     "eslint": "^8.19.0",
     "prettier": "2.8.8",
-    "react": "18.2.0",
-    "react-native": "0.73.0"
-  },
-  "resolutions": {
-    "ansi-regex": "^5.0.1",
-    "minimist": "^0.2.1",
-    "lodash": "^4.17.21",
-    "ua-parser-js": "^0.7.24",
-    "path-parse": "^1.0.7",
-    "tmpl": "^1.0.5",
-    "node-fetch": "^2.6.7",
-    "plist": "^3.0.4",
-    "ajv": "^6.12.3"
-  },
-  "resolutionComments": {
-    "ansi-regex": "Resolving to 5.0.1 to fix vulnerability (https://github.com/advisories/GHSA-93q8-gq69-wqmw)",
-    "minimist": "Resolving to 0.2.1 to fix vulnerability (https://www.npmjs.com/advisories/1066649)",
-    "lodash": "Resolving to 4.17.21 to fix vulnerability (https://www.npmjs.com/advisories/1065397)",
-    "ua-parser-js": "Resolving to 0.7.24 to fix vulnerability (https://www.npmjs.com/advisories/1065393)",
-    "path-parse": "Resolving to 1.0.7 to fix vulnerability (https://www.npmjs.com/advisories/1064972)",
-    "tmpl": "Resolving to 1.0.5 to fix vulnerability (https://www.npmjs.com/advisories/1064907)",
-    "node-fetch": "Resolving to 2.6.7 to fix vulnerability (https://www.npmjs.com/advisories/1064646)",
-    "plist": "Resolving to 3.0.4 to fix vulnerability (https://www.npmjs.com/advisories/1064605)",
-    "ajv": "Resolving to 6.12.3 to fix vulnerability (https://www.npmjs.com/advisories/1065159)"
-  },
-  "rnx-kit": {
-    "kitType": "library",
-    "alignDeps": {
-      "requirements": {
-        "development": [
-          "react-native@0.73"
-        ],
-        "production": [
-          "react-native@0.73"
-        ]
-      },
-      "capabilities": [
-        "core",
-        "core-android",
-        "core-ios",
-        "react"
-      ]
-    }
+    "typescript": "5.0.4"
   },
-  "dependencies": {
-    "eslint-plugin-ft-flow": "^2.0.3"
+  "engines": {
+    "node": ">=18"
   }
 }

package/react-native-sdk.podspec

@@ -20,5 +20,5 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React"
-  s.dependency "VeriffSDK", "6.23.0"
+  s.dependency "VeriffSDK", "6.32.0"
 end