[Release 19-04-2023] Android stability improvements & developer compatibility enhancements

android/src/main/java/io/mosip/tuvali/ble/central/ICentralListener.kt

@@ -21,5 +21,5 @@ interface ICentralListener {
   fun onSubscriptionFailure(charUUID: UUID, err: Int)
   fun onNotificationReceived(charUUID: UUID, value: ByteArray?)
   fun onClosed()
-  fun onException(exception: Throwable)
+  fun onException(exception: Exception)
 }

android/src/main/java/io/mosip/tuvali/ble/central/impl/Controller.kt

@@ -16,10 +16,10 @@ const val MTU_HEADER_SIZE = 3
 const val REQUEST_MTU_TIME_OUT = -1
 
 class Controller(val context: Context) {
-  private lateinit var scanner: Scanner
   private val logTag = getLogTag(javaClass.simpleName)
 
   private var gattClient: GattClient? = null
+  private var scanner: Scanner? = null
   private lateinit var messageSender: IMessageSender
   private var requestedMTUValue = -1
   private lateinit var mtuValues : Array<Int>
@@ -34,7 +34,7 @@ class Controller(val context: Context) {
 
   fun scan(scanStartMessage: ScanStartMessage) {
     scanner = Scanner(context)
-    scanner.start(
+    scanner?.start(
       scanStartMessage.serviceUUID,
       scanStartMessage.advPayload,
       this::onDeviceFound,
@@ -43,7 +43,7 @@ class Controller(val context: Context) {
   }
 
   fun stopScan() {
-    scanner.stopScan()
+    scanner?.stopScan()
   }
 
   @SuppressLint("MissingPermission")

android/src/main/java/io/mosip/tuvali/ble/central/state/StateHandler.kt

@@ -255,7 +255,7 @@ class StateHandler(
   override fun dispatchMessage(msg: Message) {
     try {
       super.dispatchMessage(msg)
-    } catch (e: Throwable) {
+    } catch (e: Exception) {
       listener.onException(StateHandlerException("Exception in Central State Handler", e))
       Log.d(logTag, "dispatchMessage " + e.message)
     }

android/src/main/java/io/mosip/tuvali/ble/peripheral/IPeripheralListener.kt

@@ -11,5 +11,5 @@ interface IPeripheralListener {
   fun onSendDataNotified(uuid: UUID, isSent: Boolean)
   fun onClosed()
   fun onMTUChanged(mtu: Int)
-  fun onException(exception: Throwable)
+  fun onException(exception: Exception)
 }

android/src/main/java/io/mosip/tuvali/ble/peripheral/state/StateHandler.kt

@@ -156,7 +156,7 @@ class StateHandler(
   override fun dispatchMessage(msg: Message) {
     try {
       super.dispatchMessage(msg)
-    } catch (e: Throwable) {
+    } catch (e: Exception) {
       peripheralListener.onException(StateHandlerException("Exception in Peripheral State Handler", e))
       Log.d(logTag, "dispatchMessage " + e.message)
     }

android/src/main/java/io/mosip/tuvali/common/safeExecute/TryExecuteSync.kt

@@ -0,0 +1,21 @@
+package io.mosip.tuvali.common.safeExecute
+
+import io.mosip.tuvali.openid4vpble.exception.OpenIdBLEExceptionHandler
+
+class TryExecuteSync(private val bleExceptionHandler: OpenIdBLEExceptionHandler) {
+  private val mutex = Object()
+
+  fun <T> run(fn: () -> T): T? {
+    var returnValue: T? = null;
+
+    synchronized(mutex) {
+      try {
+        returnValue = fn()
+      } catch (e: Exception) {
+        bleExceptionHandler.handleException(Exception("Unknown Exception", e))
+      }
+    }
+
+    return returnValue;
+  }
+}

android/src/main/java/io/mosip/tuvali/openid4vpble/Openid4vpBleModule.kt

@@ -3,25 +3,20 @@ package io.mosip.tuvali.openid4vpble
 import android.util.Log
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import io.mosip.tuvali.verifier.Verifier
-import io.mosip.tuvali.wallet.Wallet
+import io.mosip.tuvali.common.safeExecute.TryExecuteSync
 import io.mosip.tuvali.openid4vpble.exception.OpenIdBLEExceptionHandler
 import org.json.JSONObject
 import io.mosip.tuvali.transfer.Util.Companion.getLogTag
+import io.mosip.tuvali.verifier.Verifier
+import io.mosip.tuvali.wallet.Wallet
 
 class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
   private val logTag = getLogTag(javaClass.simpleName)
   private var verifier: Verifier? = null
   private var wallet: Wallet? = null
-  private val mutex = Object()
-  private var walletExceptionHandler = OpenIdBLEExceptionHandler(this::emitNearbyErrorEvent, this::stopBLE)
-
-  init {
-    Thread.setDefaultUncaughtExceptionHandler { _, exception ->
-      walletExceptionHandler.handleException(exception)
-    }
-  }
+  private var bleExceptionHandler = OpenIdBLEExceptionHandler(this::emitNearbyErrorEvent, this::stopBLE)
+  private val tryExecuteSync = TryExecuteSync(bleExceptionHandler);
 
   //Inji contract requires double quotes around the states.
   enum class VCResponseStates(val value: String) {
@@ -49,27 +44,30 @@ class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun getConnectionParameters(): String {
     Log.d(logTag, "getConnectionParameters new verifier object at ${System.nanoTime()}")
-    synchronized(mutex) {
+
+    return tryExecuteSync.run {
       if (verifier == null) {
         Log.d(logTag, "synchronized getConnectionParameters new verifier object at ${System.nanoTime()}")
         verifier = Verifier(reactContext, this::emitNearbyMessage, this::emitNearbyEvent, this::onException)
         verifier?.generateKeyPair()
       }
+
       val payload = verifier?.getAdvIdentifier("OVPMOSIP")
       Log.d(
         logTag,
         "synchronized getConnectionParameters called with adv identifier $payload at ${System.nanoTime()} and verifier hashcode: ${verifier.hashCode()}"
       )
-      return "{\"cid\":\"ilB8l\",\"pk\":\"${payload}\"}"
-    }
+
+      return@run "{\"cid\":\"ilB8l\",\"pk\":\"${payload}\"}"
+    }.orEmpty()
   }
 
-  private fun onException(exception: Throwable){
+  private fun onException(exception: Exception){
     if(exception.cause != null){
       Log.e(logTag, "Exception: ${exception.message}");
-      walletExceptionHandler.handleException(exception.cause!!)
+      bleExceptionHandler.handleException(exception.cause!!)
     } else {
-      walletExceptionHandler.handleException(exception)
+      bleExceptionHandler.handleException(exception)
     }
   }
 
@@ -81,7 +79,8 @@ class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun setConnectionParameters(params: String) {
     Log.d(logTag, "setConnectionParameters at ${System.nanoTime()}")
-    synchronized(mutex) {
+
+    tryExecuteSync.run {
       if (wallet == null) {
         Log.d(logTag, "synchronized setConnectionParameters new wallet object at ${System.nanoTime()}")
         wallet = Wallet(reactContext, this::emitNearbyMessage, this::emitNearbyEvent, this::onException)
@@ -99,8 +98,9 @@ class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
   @ReactMethod
   fun createConnection(mode: String, callback: Callback) {
     Log.d(logTag, "createConnection: received request with mode $mode at ${System.nanoTime()}")
-    synchronized(mutex) {
-      Log.d(logTag, "synchronized createConnection: received request with mode $mode at ${System.nanoTime()}")
+
+    tryExecuteSync.run {
+    Log.d(logTag, "synchronized createConnection: received request with mode $mode at ${System.nanoTime()}")
       when (mode) {
         "advertiser" -> {
           verifier?.startAdvertisement("OVPMOSIP", callback)
@@ -119,15 +119,15 @@ class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
   fun destroyConnection(callback: Callback) {
     //TODO: Make sure callback can be called only once[Can be done once wallet and verifier split into different modules]
     Log.d(logTag, "destroyConnection called at ${System.nanoTime()}")
-
-    stopBLE(callback)
+    tryExecuteSync.run {
+      stopBLE(callback)
+    }
   }
 
   private fun stopBLE(callback: Callback) {
-    synchronized(mutex) {
-      if (wallet == null && verifier == null) {
+    if (wallet == null && verifier == null) {
         callback()
-      } else {
+    } else {
         if (wallet != null) {
           Log.d(logTag, "synchronized destroyConnection called for wallet at ${System.nanoTime()}")
           stopWallet { callback() }
@@ -137,7 +137,6 @@ class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
           stopVerifier { callback() }
         }
       }
-    }
   }
 
   private fun stopVerifier(onDestroy: Callback) {
@@ -165,21 +164,27 @@ class Openid4vpBleModule(private val reactContext: ReactApplicationContext) :
   @ReactMethod
   fun send(message: String, callback: Callback) {
     Log.d(logTag, "send: message $message at ${System.nanoTime()}")
-    val messageSplits = message.split("\n", limit = 2)
-    when (messageSplits[0]) {
-      NearbyEvents.EXCHANGE_RECEIVER_INFO.value -> {
-        callback()
-      }
-      NearbyEvents.EXCHANGE_SENDER_INFO.value -> {
-        callback()
-        wallet?.writeToIdentifyRequest()
-      }
-      NearbyEvents.SEND_VC.value -> {
-        callback()
-        wallet?.sendData(messageSplits[1])
-      }
-      NearbyEvents.SEND_VC_RESPONSE.value -> {
-        verifier?.notifyVerificationStatus(messageSplits[1] == VCResponseStates.ACCEPTED.value)
+
+    tryExecuteSync.run {
+      val messageSplits = message.split("\n", limit = 2)
+      when (messageSplits[0]) {
+        NearbyEvents.EXCHANGE_RECEIVER_INFO.value -> {
+          callback()
+        }
+        NearbyEvents.EXCHANGE_SENDER_INFO.value -> {
+          callback()
+          wallet?.writeToIdentifyRequest()
+        }
+        NearbyEvents.SEND_VC.value -> {
+          callback()
+          wallet?.sendData(messageSplits[1])
+        }
+        NearbyEvents.SEND_VC_RESPONSE.value -> {
+          verifier?.notifyVerificationStatus(messageSplits[1] == VCResponseStates.ACCEPTED.value)
+        }
+        else -> {
+          Log.d(logTag, "send: received send with unrecognized event")
+        }
       }
     }
   }

android/src/main/java/io/mosip/tuvali/openid4vpble/exception/OpenIdBLEExceptionHandler.kt

@@ -35,7 +35,11 @@ class OpenIdBLEExceptionHandler(private val sendError: (String) -> Unit, private
       }
     }
 
-    stopBle {}
+    try{
+      stopBle {}
+    } catch (e: Exception) {
+      Log.d(logTag,"Failed to stop BLE connection while handling exception: $e")
+    }
   }
 
   private fun handleUnknownException(e: Throwable) {

android/src/main/java/io/mosip/tuvali/openid4vpble/exception/exception/StateHandlerException.kt

@@ -1,4 +1,4 @@
 package io.mosip.tuvali.openid4vpble.exception.exception
 
-class StateHandlerException(message: String, cause: Throwable): Throwable(message, cause) {
+class StateHandlerException(message: String, cause: Throwable): Exception(message, cause) {
 }

android/src/main/java/io/mosip/tuvali/openid4vpble/exception/exception/TransferHandlerException.kt

@@ -1,4 +1,4 @@
 package io.mosip.tuvali.openid4vpble.exception.exception
 
-class TransferHandlerException(message: String, cause: Throwable): Throwable(message, cause) {
+class TransferHandlerException(message: String, cause: Throwable): Exception(message, cause) {
 }

android/src/main/java/io/mosip/tuvali/verifier/Verifier.kt

@@ -31,7 +31,7 @@ class Verifier(
   context: Context,
   private val messageResponseListener: (String, String) -> Unit,
   private val eventResponseListener: (String) -> Unit,
-  private val onBLEException: (Throwable) -> Unit
+  private val onBLEException: (Exception) -> Unit
 ) :
   IPeripheralListener, ITransferListener {
   private var secretsTranslator: SecretsTranslator? = null;
@@ -200,7 +200,7 @@ class Verifier(
     }
   }
 
-  override fun onException(e: Throwable) {
+  override fun onException(e: Exception) {
     onBLEException(e)
   }
 

android/src/main/java/io/mosip/tuvali/verifier/exception/ReadFromRemoteException.kt

@@ -1,4 +1,4 @@
 package io.mosip.tuvali.verifier.exception
 
-class ReadFromRemoteException: Throwable() {
+class ReadFromRemoteException: Exception() {
 }

android/src/main/java/io/mosip/tuvali/verifier/exception/VerifierException.kt

@@ -1,3 +1,3 @@
 package io.mosip.tuvali.verifier.exception
 
-open class VerifierException(message: String): Throwable(message)
+open class VerifierException(message: String): Exception(message)

android/src/main/java/io/mosip/tuvali/verifier/transfer/ITransferListener.kt

@@ -6,5 +6,5 @@ interface ITransferListener {
   fun sendDataOverNotification(charUUID: UUID, data: ByteArray)
   fun onResponseReceived(data: ByteArray)
   fun onResponseReceivedFailed(errorMsg: String)
-  fun onException(exception: Throwable )
+  fun onException(exception: Exception )
 }

android/src/main/java/io/mosip/tuvali/verifier/transfer/TransferHandler.kt

@@ -130,7 +130,7 @@ class TransferHandler(looper: Looper, private val peripheral: Peripheral, privat
   override fun dispatchMessage(msg: Message) {
     try {
       super.dispatchMessage(msg)
-    } catch (e: Throwable) {
+    } catch (e: Exception) {
       transferListener.onException(TransferHandlerException("Exception in Verifier Transfer Handler", e))
       Log.d(logTag, "dispatchMessage " + e.message)
     }

android/src/main/java/io/mosip/tuvali/wallet/Wallet.kt

@@ -29,14 +29,15 @@ import java.security.SecureRandom
 import java.util.*
 import io.mosip.tuvali.transfer.Util.Companion.getLogTag
 import io.mosip.tuvali.wallet.exception.TransferFailedException
+import java.lang.Thread.setDefaultUncaughtExceptionHandler
 
 private const val MTU_REQUEST_RETRY_DELAY_TIME_IN_MILLIS = 500L
 
 class Wallet(
   context: Context,
   private val messageResponseListener: (String, String) -> Unit,
   private val eventResponseListener: (String) -> Unit,
-  private val onBLEException: (Throwable) -> Unit
+  private val onBLEException: (Exception) -> Unit
 ) : ICentralListener, ITransferListener {
   private val logTag = getLogTag(javaClass.simpleName)
 
@@ -303,7 +304,7 @@ class Wallet(
     }
   }
 
-  override fun onException(exception: Throwable) {
+  override fun onException(exception: Exception) {
     onBLEException(exception)
   }
 

android/src/main/java/io/mosip/tuvali/wallet/exception/WalletException.kt

@@ -1,3 +1,3 @@
 package io.mosip.tuvali.wallet.exception
 
-open class WalletException(message: String): Throwable(message)
+open class WalletException(message: String): Exception(message)

android/src/main/java/io/mosip/tuvali/wallet/transfer/ITransferListener.kt

@@ -3,5 +3,5 @@ package io.mosip.tuvali.wallet.transfer
 interface ITransferListener {
   fun onResponseSent()
   fun onResponseSendFailure(errorMsg: String)
-  fun onException(exception: Throwable)
+  fun onException(exception: Exception)
 }

android/src/main/java/io/mosip/tuvali/wallet/transfer/TransferHandler.kt

@@ -173,7 +173,7 @@ class TransferHandler(looper: Looper, private val central: Central, val serviceU
   override fun dispatchMessage(msg: Message) {
     try {
       super.dispatchMessage(msg)
-    } catch (e: Throwable) {
+    } catch (e: Exception) {
       transferListener.onException(TransferHandlerException("Exception in Central transfer Handler", e))
       Log.d(logTag, "dispatchMessage " + e.message)
     }