@au10tixorg/secureme-sdk 4.7.0

package/android/src/main/java/com/securemesdk/SecuremeSdkModule.kt

@@ -0,0 +1,59 @@
+package com.securemesdk
+
+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.securemesdk.models.SDKError
+import com.securemesdk.secureme.SecureMeBottomSheet
+
+class SecuremeSdkModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        private const val TAG = "SecureMe"
+    }
+
+    override fun getName(): String {
+        return "SecuremeSdk"
+    }
+
+    @ReactMethod
+    fun start(
+        workFlowResponse: String, flowMap: ReadableMap, configMap: ReadableMap, promise: Promise
+    ) {
+        try {
+            val activity = this.reactApplicationContext.currentActivity
+
+            if (activity is androidx.fragment.app.FragmentActivity) {
+
+                activity.runOnUiThread {
+                    val bottomSheet = SecureMeBottomSheet()
+                    bottomSheet.setup(
+                        workFlowResponse = workFlowResponse,
+                        flowMap = flowMap,
+                        configMap = configMap
+                    )
+
+                    bottomSheet.onSuccessAction = { success ->
+                        promise.resolve(success)
+                    }
+
+                    bottomSheet.onErrorAction = { error ->
+                        promise.reject(error.code, error.message)
+                    }
+
+                    bottomSheet.show(activity.supportFragmentManager, TAG)
+                }
+            } else {
+                val error =
+                    SDKError.SecureMeFailure("Current activity is null or not a FragmentActivity")
+                promise.reject(error.code, error.message)
+            }
+        } catch (e: Exception) {
+            val error = SDKError.SecureMeFailure(e.message ?: "")
+            promise.reject(error.code, error.message)
+        }
+    }
+}

package/android/src/main/java/com/securemesdk/SecuremeSdkPackage.kt

@@ -0,0 +1,17 @@
+package com.securemesdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class SecuremeSdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(SecuremeSdkModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/java/com/securemesdk/helpers/ReadableMapExt.kt

@@ -0,0 +1,51 @@
+package com.securemesdk.helpers
+
+import com.facebook.react.bridge.ReadableMap
+
+fun ReadableMap.getSafeBool(key: String, default: Boolean = false): Boolean {
+    if (this.hasKey(key) && !this.isNull(key)) {
+        return try {
+            this.getBoolean(key)
+        } catch (e: Exception) {
+            default
+        }
+    }
+    return default
+}
+
+fun ReadableMap.getSafeFloat(key: String, default: Float? = null): Float? {
+    if (this.hasKey(key) && !this.isNull(key)) {
+        return try {
+            this.getDouble(key).toFloat()
+        } catch (e: Exception) {
+            default
+        }
+    }
+    return default
+}
+
+fun ReadableMap.getSafeInt(key: String, default: Int = 0): Int {
+    if (this.hasKey(key) && !this.isNull(key)) {
+        return try {
+            this.getInt(key)
+        } catch (e: Exception) {
+            try {
+                this.getDouble(key).toInt()
+            } catch (e2: Exception) {
+                default
+            }
+        }
+    }
+    return default
+}
+
+fun ReadableMap.getSafeString(key: String, default: String? = null): String? {
+    if (this.hasKey(key) && !this.isNull(key)) {
+        return try {
+            this.getString(key) ?: default
+        } catch (e: Exception) {
+            default
+        }
+    }
+    return default
+}

package/android/src/main/java/com/securemesdk/helpers/SessionParser.kt

@@ -0,0 +1,21 @@
+package com.securemesdk.helpers
+
+import com.securemesdk.models.SDKError
+import org.json.JSONArray
+import org.json.JSONObject
+
+fun parseSessionData(jsonString: String): Triple<String, String, JSONArray> {
+    try {
+        val rootObject = JSONObject(jsonString)
+
+        val responseObject = rootObject.getJSONObject("response")
+
+        val session = responseObject.getString("session")
+        val accessToken = responseObject.getString("accessToken")
+        val assets = responseObject.getJSONArray("assets")
+
+        return Triple(session, accessToken, assets)
+    } catch (e: Exception) {
+        throw SDKError.JsonParse(e.message ?: "")
+    }
+}

package/android/src/main/java/com/securemesdk/models/SDKError.kt

@@ -0,0 +1,24 @@
+package com.securemesdk.models
+
+sealed class SDKError : Exception() {
+
+    abstract val reason: String
+
+    data class JsonParse(override val reason: String) : SDKError()
+    data class SecureMeFailure(override val reason: String) : SDKError()
+
+    val code: String
+        get() = when (this) {
+            is JsonParse -> "ERROR_JSON_PARSE"
+            is SecureMeFailure -> "ERROR_SECURE_ME_FAILURE"
+        }
+
+    override val message: String
+        get() = reason
+
+    val nsErrorCode: Int
+        get() = when (this) {
+            is JsonParse -> 1001
+            is SecureMeFailure -> 1002
+        }
+}

package/android/src/main/java/com/securemesdk/secureme/SecureMeBottomSheet.kt

@@ -0,0 +1,308 @@
+package com.securemesdk.secureme
+
+import android.app.Dialog
+import android.graphics.Color
+import android.os.Bundle
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.activity.OnBackPressedCallback
+import androidx.fragment.app.Fragment
+import com.au10tix.sdk.commons.Au10Error
+import com.au10tix.sdk.core.Au10xCore
+import com.au10tix.sdk.security.config.SuspiciousConfig
+import com.au10tix.sdk.protocol.FeatureSessionError
+import com.au10tix.sdk.protocol.FeatureSessionResult
+import com.au10tix.secureMe.SecureMe
+import com.au10tix.secureMe.SecureMeResult
+import com.au10tix.secureMe.callback.SecureMeCallback
+import com.au10tix.secureMe.callback.SecureMePrepareCallback
+import com.au10tix.secureMe.configurations.SMConfig
+import com.au10tix.secureMe.configurations.SMFlow
+import com.facebook.react.bridge.ReadableMap
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.google.android.material.bottomsheet.BottomSheetDialog
+import com.google.android.material.bottomsheet.BottomSheetDialogFragment
+import com.securemesdk.helpers.getSafeBool
+import com.securemesdk.helpers.getSafeFloat
+import com.securemesdk.helpers.getSafeInt
+import com.securemesdk.helpers.getSafeString
+import com.securemesdk.helpers.parseSessionData
+import com.securemesdk.models.SDKError
+
+class SecureMeBottomSheet : BottomSheetDialogFragment() {
+
+    private var containerId = View.generateViewId()
+    private var secureMe: SecureMe? = null
+    private var fragment: Fragment? = null
+    private var workFlowResponse: String = ""
+    private var flow: SMFlow? = null
+    private var config: SMConfig? = null
+
+    var onSuccessAction: ((Boolean) -> Unit)? = null
+    var onErrorAction: ((SDKError) -> Unit)? = null
+
+    companion object {
+        private const val TAG = "SecureMe"
+    }
+
+    fun setup(workFlowResponse: String, flowMap: ReadableMap?, configMap: ReadableMap?) {
+        this.workFlowResponse = workFlowResponse
+
+        if (flowMap != null && flowMap.toHashMap().isNotEmpty()) {
+            flow = createFlow(flowMap)
+        }
+        if (configMap != null && configMap.toHashMap().isNotEmpty()) {
+            config = createConfig(configMap)
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val dialog = super.onCreateDialog(savedInstanceState) as BottomSheetDialog
+        dialog.setOnShowListener { dialogInterface ->
+            val bottomSheetDialog = dialogInterface as BottomSheetDialog
+            val bottomSheet =
+                bottomSheetDialog.findViewById<FrameLayout>(com.google.android.material.R.id.design_bottom_sheet)
+
+            dialog.window?.setDimAmount(0f)
+
+            bottomSheet?.let { sheet ->
+                sheet.setBackgroundColor(Color.TRANSPARENT)
+
+                val behavior = BottomSheetBehavior.from(sheet)
+                val layoutParams = sheet.layoutParams
+                layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT
+                sheet.layoutParams = layoutParams
+
+                behavior.state = BottomSheetBehavior.STATE_EXPANDED
+                behavior.isDraggable = false
+            }
+        }
+
+        val backCallback = object : OnBackPressedCallback(true) {
+            override fun handleOnBackPressed() {
+                dismissAllowingStateLoss()
+            }
+        }
+
+        dialog.onBackPressedDispatcher.addCallback(this, backCallback)
+        return dialog
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        isCancelable = false
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
+    ): View {
+        val programmaticContainer = FrameLayout(requireContext()).apply {
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT
+            )
+            id = containerId
+        }
+
+        return programmaticContainer
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        try {
+            Au10xCore.getInstance(requireContext()).setHost("reactNative")
+            val (sessionToken, accessToken, assets) = parseSessionData(workFlowResponse)
+            secureMe = SecureMe(
+                requireActivity(),
+                accessToken,
+                sessionToken,
+                assets,
+                object : SecureMePrepareCallback {
+                    override fun onPrepared(secureMe: SecureMe) {
+                        fragment = secureMe.createUI(
+                            flow, config, object : SecureMeCallback {
+                                override fun onUpdate(
+                                    event: String?, result: FeatureSessionResult?
+                                ) {
+                                    Log.d(TAG, "SecureMe update: $event")
+                                }
+
+                                override fun onComplete(result: SecureMeResult?) {
+                                    Log.d(TAG, "SecureMe сomplete")
+                                    onSuccessAction?.invoke(true)
+                                    close()
+                                }
+
+                                override fun onError(error: FeatureSessionError) {
+                                    Log.e(TAG, "SecureMe error: ${error?.errorMessage}")
+
+                                    if (error.severity != FeatureSessionError.SEVERITY_WARNING) {
+                                        onErrorAction?.invoke(SDKError.SecureMeFailure("${error?.errorMessage}"))
+                                        close()
+                                    }
+                                }
+                            })
+                        activity?.runOnUiThread {
+                            if (isAdded && !isDetached) {
+                                try {
+                                    if (fragment != null) {
+                                        childFragmentManager.beginTransaction()
+                                            .replace(containerId, fragment!!).commit()
+                                    } else {
+                                        val message = "fragment is null"
+                                        Log.e(TAG, message)
+
+                                        onErrorAction?.invoke(SDKError.SecureMeFailure(message))
+                                        close()
+                                    }
+                                } catch (e: Exception) {
+                                    onErrorAction?.invoke(SDKError.SecureMeFailure("Failed to commit fragment transaction: ${e.message}"))
+                                }
+                            }
+                        }
+                    }
+
+                    override fun onError(error: Au10Error?) {
+                        Log.e(TAG, "error: ${error?.message}")
+
+                        onErrorAction?.invoke(SDKError.SecureMeFailure("${error?.message}"))
+                        close()
+                    }
+                })
+        } catch (e: Exception) {
+            Log.e(TAG, "error: ${e.message}")
+            onErrorAction?.invoke(SDKError.SecureMeFailure(e.message ?: ""))
+            close()
+        }
+    }
+
+    override fun onDestroy() {
+        secureMe?.destroy()
+        secureMe = null
+        fragment = null
+        super.onDestroy()
+    }
+
+    private fun createFlow(map: ReadableMap) = SMFlow().apply {
+        map.getMap("afl")?.let { innerMap ->
+            this.withAFL(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("showIntro"),
+                innerMap.getSafeBool("enableFileUpload"),
+                innerMap.getSafeBool("sendFeatureResult")
+            )
+        }
+
+        map.getMap("sdcBack")?.let { innerMap ->
+            this.withBackSDC(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("enableFileUpload"),
+                innerMap.getSafeBool("sendFeatureResult")
+            )
+        }
+
+        map.getMap("sdcFront")?.let { innerMap ->
+            this.withFrontSDC(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("showIntro"),
+                innerMap.getSafeBool("enableFileUpload")
+            )
+        }
+
+        map.getMap("nfc")?.let { innerMap ->
+            this.withNFC(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("enableFileUpload"),
+                innerMap.getSafeBool("sendFeatureResult")
+            )
+        }
+
+        map.getMap("pfl")?.let { innerMap ->
+            this.withPFL(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("showIntro"),
+                innerMap.getSafeBool("sendFeatureResult")
+            )
+        }
+
+        map.getMap("poa")?.let { innerMap ->
+            this.withPOA(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("showIntro"),
+                innerMap.getSafeBool("enableFileUpload"),
+                innerMap.getSafeBool("sendFeatureResult")
+            )
+        }
+
+        map.getMap("videoSession")?.let { innerMap ->
+            this.withVideoSession(
+                innerMap.getSafeBool("enabled"),
+                innerMap.getSafeBool("showIntro"),
+                innerMap.getSafeBool("sendFeatureResult")
+            )
+        }
+
+        map.getMap("voiceConsent")?.let { voiceMap ->
+            this.withVoiceConsent(
+                voiceMap.getSafeBool("enabled"),
+                voiceMap.getSafeBool("showIntro"),
+                voiceMap.getSafeBool("sendFeatureResult")
+            )
+        }
+    }
+
+    private fun createConfig(map: ReadableMap) = map.run {
+
+        val suspiciousConfig = map.getMap("suspiciousConfig")?.let {
+            createSuspiciousConfig(it)
+        }
+
+        SMConfig(
+            p0 = map.getSafeBool("withPflDetectionDelay"),
+            p1 = map.getSafeInt("pflDelaySecs"),
+            p2 = map.getSafeBool("sendResults"),
+            p3 = map.getSafeString("voiceConsentText"),
+            p4 = map.getSafeInt("voiceConsentSessionTime"),
+            p5 = map.getSafeInt("videoSessionConsentTime"),
+            p6 = map.getSafeInt("videoSessionIDTime"),
+            p7 = map.getSafeBool("videoSessionAskUserConsent"),
+            p8 = suspiciousConfig
+        )
+    }
+
+    private fun createSuspiciousConfig(map: ReadableMap): SuspiciousConfig {
+        return SuspiciousConfig().apply {
+
+            map.getSafeInt("checkInterval").let {
+                this.checkInterval = it
+            }
+
+            map.getSafeFloat("fastFilterThreshold")?.let {
+                this.fastFilterThreshold = it
+            }
+
+            map.getSafeFloat("pixelPerfectThreshold")?.let {
+                this.pixelPerfectThreshold = it
+            }
+
+            map.getSafeFloat("preFilterThreshold")?.let {
+                this.preFilterThreshold = it
+            }
+
+            map.getSafeFloat("stillDeviceThreshold")?.let {
+                this.stillDeviceThreshold = it
+            }
+        }
+    }
+
+    private fun close() {
+        activity?.runOnUiThread {
+            if (isAdded) {
+                dismissAllowingStateLoss()
+            }
+        }
+    }
+}

package/ios/Extensions/DictionaryExtensions.swift

@@ -0,0 +1,90 @@
+//
+//  DictionaryExtensions.swift
+//  SecuremeSdk
+//
+//  Created by Ihor Konfedrat on 28.12.2025.
+//  Copyright © 2025 Facebook. All rights reserved.
+//
+
+extension NSDictionary {
+
+  func getSafeBool(_ key: String, defaultVal: Bool = false) -> Bool {
+    if let val = self[key] as? Bool {
+      return val
+    }
+    if let val = self[key] as? NSNumber {
+      return val.boolValue
+    }
+    return defaultVal
+  }
+
+  func getSafeInt(_ key: String, defaultVal: Int = 0) -> Int {
+    if let val = self[key] as? Int {
+      return val
+    }
+
+    if let valStr = self[key] as? String, let valInt = Int(valStr) {
+      return valInt
+    }
+    return defaultVal
+  }
+
+  func getSafeString(_ key: String) -> String? {
+    if let stringValue = self[key] as? String {
+      return stringValue
+    }
+
+    if let numberValue = self[key] as? NSNumber {
+      return numberValue.stringValue
+    }
+
+    return nil
+  }
+
+  func getSafeFloat(_ key: String, defaultVal: Float = 0.0) -> Float {
+    if let val = self[key] as? Float {
+      return val
+    }
+    if let val = self[key] as? NSNumber {
+      return val.floatValue
+    }
+    return defaultVal
+  }
+
+  func getSafeDouble(_ key: String, defaultVal: Double = 0.0) -> Double {
+    if let val = self[key] as? Double {
+      return val
+    }
+    if let val = self[key] as? NSNumber {
+      return val.doubleValue
+    }
+    return defaultVal
+  }
+
+  func getSafeTimeInterval(_ key: String) -> TimeInterval? {
+    if let val = self[key] as? TimeInterval {
+      return val
+    }
+    if let number = self[key] as? NSNumber {
+      return number.doubleValue
+    }
+    if let str = self[key] as? String, let doubleVal = Double(str) {
+      return TimeInterval(doubleVal)
+    }
+    return nil
+  }
+
+  func getSafeTimeInterval(_ key: String, defaultVal: TimeInterval = 0.0) -> TimeInterval {
+    return getSafeTimeInterval(key) ?? defaultVal
+  }
+
+  func getSafeCGFloat(_ key: String, defaultVal: CGFloat = 0.0) -> CGFloat {
+    if let val = self[key] as? CGFloat {
+      return val
+    }
+    if let val = self[key] as? NSNumber {
+      return CGFloat(val.doubleValue)
+    }
+    return defaultVal
+  }
+}

package/ios/Extensions/SecureMeExtensions.swift

@@ -0,0 +1,82 @@
+//
+//  SecureMeExtensions.swift
+//  SecuremeSdk
+//
+//  Created by Ihor Konfedrat on 12.12.2025.
+//  Copyright © 2025 Facebook. All rights reserved.
+//
+
+import Foundation
+
+import Au10tixCore
+import Au10tixSecureMeKit
+
+
+extension SecureMeFlowConfig {
+  init(dict: NSDictionary) {
+    var susConfig: SuspiciousBehaviorConfig? = nil
+    if let susDict = dict["suspiciousBehaviorConfig"] as? NSDictionary {
+      susConfig = SuspiciousBehaviorConfig(dict: susDict)
+    }
+
+    self.init(
+      showIntro: dict.getSafeBool("showIntro", defaultVal: true),
+      enableFileUpload: dict.getSafeBool("enableFileUpload", defaultVal: true),
+      sendFeatureResult: dict
+        .getSafeBool("sendFeatureResult", defaultVal: true),
+      localClassification: dict.getSafeBool("localClassification"),
+      suspiciousBehaviorConfig: susConfig
+    )
+  }
+}
+
+extension SuspiciousBehaviorConfig {
+  init(dict: NSDictionary) {
+    self.init(
+      similarityThreshold: dict.getSafeFloat("similarityThreshold", defaultVal: 0.009),
+      stillDeviceThreshold: dict.getSafeDouble("stillDeviceThreshold", defaultVal: 0.01),
+      rectangleDriftDelta: dict.getSafeCGFloat("rectangleDriftDelta", defaultVal: 0.01),
+      minimumConfidence: dict.getSafeFloat("minimumConfidence", defaultVal: 0.1),
+      minimumAspectRatio: dict.getSafeFloat("minimumAspectRatio", defaultVal: 0.3),
+      checkInterval: dict.getSafeInt("checkInterval", defaultVal: 5),
+      riskThreshold: dict.getSafeFloat("riskThreshold", defaultVal: 45.0),
+      visualSimilarityWeight: dict.getSafeFloat("visualSimilarityWeight", defaultVal: 35.0),
+      motionAnomaliesWeight: dict.getSafeFloat("motionAnomaliesWeight", defaultVal: 30.0),
+      spatialConsistencyWeight: dict.getSafeFloat("spatialConsistencyWeight", defaultVal: 20.0),
+      temporalPatternsWeight: dict.getSafeFloat("temporalPatternsWeight", defaultVal: 15.0),
+      treatMissingSensorsAsSuspicious: dict.getSafeBool("treatMissingSensorsAsSuspicious", defaultVal: true),
+      missingSensorRiskScore: dict.getSafeFloat("missingSensorRiskScore", defaultVal: 25.0),
+      enableSpatialAnalysis: dict.getSafeBool("enableSpatialAnalysis", defaultVal: true),
+      spatialSuspicionThreshold: dict.getSafeFloat("spatialSuspicionThreshold", defaultVal: 0.5),
+      spatialGridSize: dict.getSafeInt("spatialGridSize", defaultVal: 4),
+      temporalWindowSize: dict.getSafeInt("temporalWindowSize", defaultVal: 30),
+      timingVarianceThreshold: dict.getSafeDouble("timingVarianceThreshold", defaultVal: 0.001),
+      enableDebugLogging: dict.getSafeBool("enableDebugLogging", defaultVal: false)
+    )
+  }
+}
+
+extension SecureMeFeaturesConfig {
+  init(dict: NSDictionary) {
+
+    let pflEnabled = dict.getSafeBool("pflDetectionDelayEnabled", defaultVal: false)
+    let pflDelay = dict.getSafeTimeInterval("pflDelay", defaultVal: 0)
+    let sendResults = dict.getSafeBool("sendResults", defaultVal: true)
+    let voiceText = dict.getSafeString("voiceConsentText")
+    let voiceTime = dict.getSafeInt("voiceConsentSessionTime", defaultVal: 20)
+    let videoText = dict.getSafeString("videoSessionText")
+    let videoIdDuration = dict.getSafeInt("videoSessionIdSessionDuration", defaultVal: 5)
+    let videoVoiceDuration = dict.getSafeInt("videoSessionVoiceSessionDuration", defaultVal: 0)
+
+    self.init(
+      pflDetectionDelayEnabled: pflEnabled,
+      pflDelay: pflDelay,
+      sendResults: sendResults,
+      voiceConsentText: voiceText,
+      voiceConsentSessionTime: voiceTime,
+      videoSessionText: videoText,
+      videoSessionIdSessionDuration: videoIdDuration,
+      videoSessionVoiceSessionDuration: videoVoiceDuration
+    )
+  }
+}

package/ios/Models/SDKError.swift

@@ -0,0 +1,36 @@
+//
+//  SDKError.swift
+//  SecuremeSdk
+//
+//  Created by Ihor Konfedrat on 12.12.2025.
+//  Copyright © 2025 Facebook. All rights reserved.
+//
+
+import Foundation
+
+enum SDKError: LocalizedError {
+
+  case jsonParse(String)
+  case secureMeFailure(String)
+
+  var code: String {
+    switch self {
+      case .jsonParse:        return "ERROR_JSON_PARSE"
+      case .secureMeFailure:  return "SECURE_ME_FAILURE"
+    }
+  }
+
+  var errorDescription: String? {
+    switch self {
+      case .secureMeFailure(let msg): return msg
+      case .jsonParse(let msg): return msg
+    }
+  }
+
+  var nsErrorCode: Int {
+    switch self {
+      case .jsonParse:        return 1001
+      case .secureMeFailure:  return 1002
+    }
+  }
+}