@moxtradeveloper/react-native-moxo-module 10.11.2 → 10.13.1

package/android/src/main/java/com/moxomodule/MoxoModuleModule.kt

@@ -3,80 +3,54 @@ package com.moxomodule
 import android.app.Application
 import android.content.Intent
 import android.util.Log
-import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
 import com.moxtra.mepsdk.MEPClient
 import com.moxtra.mepsdk.MEPClientDelegate
 import com.moxtra.mepsdk.data.MEPStartMeetOptions
 import com.moxtra.sdk.LinkConfig
 import com.moxtra.sdk.common.ActionListener
 import com.moxtra.sdk.common.ApiCallback
-import org.json.JSONArray
-import org.json.JSONException
-import org.json.JSONObject
 
-class MoxoModuleModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+@ReactModule(name = MoxoModuleModule.NAME)
+class MoxoModuleModule(private val reactContext: ReactApplicationContext) :
+  NativeMoxoModuleSpec(reactContext) {
 
-  private val TAG: String = "MoxoModuleModule"
+  @Volatile private var tapWindowCloseEnabled = false
 
-  private var mReactContext = reactContext
+  override fun getName(): String = NAME
 
-  private val UNREAD_MSG_EVENT = "onUnreadMessageCountUpdated"
-  private val TAP_WINDOW_CLOSE_EVENT = "tapWindowCloseEvent"
-  
-  override fun getName(): String {
-    return NAME
-  }
-
-  @ReactMethod
-  fun setup(domain: String?, options: String?) {
+  override fun setup(domain: String, options: ReadableMap?) {
     Log.d(TAG, "setup called with domain: $domain, options: $options")
-    var linkConfig: LinkConfig? = null
-    try {
-      if (!domain.isNullOrEmpty() && !options.isNullOrEmpty()) {
-          linkConfig = LinkConfig()
-          val jsonObject = JSONObject(options)
-          val certOrgName: String? = jsonObject.getString("certOrgName")
-          val certPublicKey: String? = jsonObject.getString("certPublicKey")
-          val ignoreBadCert: Boolean = jsonObject.getBoolean("ignoreBadCert")
-        linkConfig.certOrganization = certOrgName
-        linkConfig.certPublicKey = certPublicKey
-        linkConfig.isIgnoreBadCert = ignoreBadCert
-      }
-    } catch (e: JSONException) {
+    val linkConfig = if (domain.isNotEmpty() && options != null) toLinkConfig(options) else null
 
-    }
-
-    mReactContext.runOnUiQueueThread {
-      MEPClient.initialize(mReactContext?.applicationContext as Application)
+    runOnSdkThread {
+      MEPClient.initialize(reactContext.applicationContext as Application)
       MEPClient.setupDomain(domain, linkConfig)
+      registerClientListeners()
     }
   }
 
-  @ReactMethod
-  fun link(token: String?, promise: Promise?) {
-    Log.d(TAG, "link called with token: $token")
-    if (token.isNullOrEmpty()) {
-      promise?.reject("-1", "token is empty or null")
+  override fun link(token: String, promise: Promise) {
+    Log.d(TAG, "link called")
+    if (token.isEmpty()) {
+      promise.reject("-1", "token is empty or null")
       return
     }
-    mReactContext.runOnUiQueueThread {
+    runOnSdkThread(promise) {
       MEPClient.linkWithAccessToken(token, object : ApiCallback<Void?> {
-        override fun onCompleted(rlt: Void?) {
-          Log.d(
-            TAG,
-            "initWithAccessToken successful..."
-          )
-          promise?.resolve(true)
+        override fun onCompleted(result: Void?) {
+          Log.d(TAG, "linkWithAccessToken successful...")
+          promise.resolve(true)
         }
 
         override fun onError(errorCode: Int, errorMsg: String) {
-          Log.d(
-            TAG,
-            "initWithAccessToken failed, errCode:$errorCode, errMsg:$errorMsg"
-          )
-          promise?.reject(
+          Log.d(TAG, "linkWithAccessToken failed, errCode:$errorCode, errMsg:$errorMsg")
+          promise.reject(
             errorCode.toString(),
             "initWithAccessToken failed, errCode:$errorCode, errMsg:$errorMsg"
           )
@@ -85,11 +59,10 @@ class MoxoModuleModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  @ReactMethod
-  fun unlink(keepNotification: Boolean) {
+  override fun unlink(keepNotification: Boolean) {
     Log.d(TAG, "unlink called with keep notification $keepNotification")
-    val callback: ApiCallback<Void?> = object : ApiCallback<Void?> {
-      override fun onCompleted(rult: Void?) {
+    val callback = object : ApiCallback<Void?> {
+      override fun onCompleted(result: Void?) {
         Log.d(TAG, "unlink successful...")
       }
 
@@ -97,369 +70,284 @@ class MoxoModuleModule(reactContext: ReactApplicationContext) :
         Log.w(TAG, "unlink failed with error code $errorCode and error message $errorMsg ...")
       }
     }
-    if (keepNotification) {
-      MEPClient.localUnlink(callback)
-    } else {
-      MEPClient.unlink(callback)
+    runOnSdkThread {
+      if (keepNotification) {
+        MEPClient.localUnlink(callback)
+      } else {
+        MEPClient.unlink(callback)
+      }
     }
   }
 
-  @ReactMethod
-  fun getUnreadMessageCount(options: ReadableMap?, promise: Promise?) {
-    var unreadCount = MEPClient.getUnreadMessageCount()
-    promise?.resolve(unreadCount)
+  override fun getUnreadMessageCount(options: ReadableMap?, promise: Promise) {
+    runOnSdkThread(promise) {
+      promise.resolve(MEPClient.getUnreadMessageCount())
+    }
   }
 
-  @ReactMethod
-  fun showMEPWindow() {
+  override fun showMEPWindow() {
     Log.d(TAG, "showMEPWindow called...")
-    if (MEPClient.isLinked()) {
-      Log.d(TAG, "MEP is linked and showMEPWindow...")
-      MEPClient.showMEPWindow(mReactContext?.baseContext)
+    runOnSdkThread {
+      if (MEPClient.isLinked()) {
+        MEPClient.showMEPWindow(reactContext.baseContext)
+      }
     }
   }
 
-  @ReactMethod
-  fun hideMEPWindow() {
+  override fun hideMEPWindow() {
     Log.d(TAG, "hideMEPWindow called...")
-    if (MEPClient.isLinked()) {
-      Log.d(TAG, "MEP is linked and hideMEPWindow...")
-      MEPClient.destroyMEPWindow()
+    runOnSdkThread {
+      if (MEPClient.isLinked()) {
+        MEPClient.destroyMEPWindow()
+      }
     }
   }
 
-  @ReactMethod
-  fun openChat(chatId: String?, feedSequence: Double?, promise: Promise?) {
+  override fun openChat(chatId: String, feedSequence: Double?, promise: Promise) {
     Log.d(TAG, "openChat called...")
-    if (!MEPClient.isLinked()) {
-      promise?.reject("-1", "Not linked")
-      return
-    }
-    if (!chatId.isNullOrEmpty()) {
+    runOnSdkThread(promise) {
+      if (!MEPClient.isLinked()) {
+        promise.reject("-1", "Not linked")
+        return@runOnSdkThread
+      }
+      if (chatId.isEmpty()) {
+        promise.reject("-1", "Invalid parameter")
+        return@runOnSdkThread
+      }
       MEPClient.openChat(chatId, feedSequence?.toLong() ?: 0, object : ApiCallback<Void?> {
-        override fun onCompleted(rult: Void?) {
+        override fun onCompleted(result: Void?) {
           Log.d(TAG, "openChat successful...")
-          promise?.resolve(true)
+          promise.resolve(true)
         }
 
         override fun onError(errorCode: Int, errorMsg: String) {
-          promise?.reject(
-            errorCode.toString(),
-            "openChat failed, errCode:$errorCode, errMsg:$errorMsg"
-          )
+          promise.reject(errorCode.toString(), "openChat failed, errCode:$errorCode, errMsg:$errorMsg")
         }
       })
-    } else {
-      promise?.reject("-1", "Invalid parameter")
     }
   }
 
-  @ReactMethod
-  fun openRelation(options: ReadableMap?, promise: Promise?) {
+  override fun openRelation(options: ReadableMap, promise: Promise) {
     Log.d(TAG, "openRelation called...")
-    if (!MEPClient.isLinked()) {
-      promise?.reject("-1", "Not linked")
-      return
-    }
-    val uniqueId: String? = options?.getString("uniqueId")
-    val email: String? = options?.getString("email")
-    val callback: ApiCallback<Void?> = object : ApiCallback<Void?> {
-      override fun onCompleted(rult: Void?) {
+    val uniqueId = options.stringOrNull("uniqueId")
+    val email = options.stringOrNull("email")
+    val callback = object : ApiCallback<Void?> {
+      override fun onCompleted(result: Void?) {
         Log.d(TAG, "openRelationChat successful...")
-        promise?.resolve(true)
+        promise.resolve(true)
       }
 
       override fun onError(errorCode: Int, errorMsg: String) {
-        promise?.reject(
+        promise.reject(
           errorCode.toString(),
           "openRelationChat failed, errCode:$errorCode, errMsg:$errorMsg"
         )
       }
     }
-    if (!uniqueId.isNullOrEmpty()) {
-      MEPClient.openRelationChat(uniqueId, callback)
-    } else if (!email.isNullOrEmpty()) {
-      MEPClient.openRelationChatWithEmail(email, callback)
-    } else {
-      promise?.reject("-1", "Invalid parameter")
-    }
-  }
-
-  private fun onUnreadMessageCountUpdated() {
-    Log.d(TAG, "onUnreadMessageCountUpdated called...")
-    val listener: MEPClientDelegate.OnUnreadMessageListener =
-      MEPClientDelegate.OnUnreadMessageListener { unreadCount ->
-        Log.d(TAG, "onUnreadMessageCountUpdated, count is $unreadCount")
-        sendEvent(mReactContext, UNREAD_MSG_EVENT, unreadCount)
+    runOnSdkThread(promise) {
+      if (!MEPClient.isLinked()) {
+        promise.reject("-1", "Not linked")
+        return@runOnSdkThread
       }
-
-    MEPClient.getClientDelegate().setOnUnreadMessageListener(listener)
-  }
-  
-  private fun onTapWindowClose() {
-    Log.d(TAG, "onTapWindowClose called...")
-    val listener: ActionListener<Void> = ActionListener { _, _ ->
-      run {
-        Log.d(TAG, "onTapWindowClose button clicked...")
-        sendEvent(mReactContext, TAP_WINDOW_CLOSE_EVENT, null)
+      when {
+        !uniqueId.isNullOrEmpty() -> MEPClient.openRelationChat(uniqueId, callback)
+        !email.isNullOrEmpty() -> MEPClient.openRelationChatWithEmail(email, callback)
+        else -> promise.reject("-1", "Invalid parameter")
       }
     }
-    MEPClient.getClientDelegate().setOnCloseButtonListener(listener)
-  }
-
-  private fun sendEvent(reactContext: ReactContext, eventName: String, params: Any?) {
-    reactContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit(eventName, params)
   }
 
-  @ReactMethod
-  fun addListener(eventName: String) {
-    Log.d(TAG, "addListener called...")
-    when (eventName) {
-        TAP_WINDOW_CLOSE_EVENT ->
-           onTapWindowClose()
+  override fun registerNotification(deviceToken: String, promise: Promise) {
+    Log.d(TAG, "registerNotification called and token is " + if (deviceToken.isEmpty()) "empty" else "not empty")
+    if (deviceToken.isEmpty()) {
+      promise.reject("-1", "device token is empty")
+      return
     }
-  }
-
-  @ReactMethod
-  fun removeListeners(count: Integer) {
-    Log.d(TAG, "removeListeners called...")
-  }
-
-  @ReactMethod
-  fun registerNotification(deviceToken: String?) {
-    Log.d(
-      TAG,
-      "registerNotification called and token is " + (if (deviceToken == null) "null" else "not null")
-    )
-    if (!deviceToken.isNullOrEmpty()) {
-            MEPClient.registerNotification(
-                deviceToken,
-        null, null, null,
-        object : ApiCallback<Void> {
-        override fun onCompleted(rlt: Void?) {
+    runOnSdkThread(promise) {
+      MEPClient.registerNotification(deviceToken, null, null, null, object : ApiCallback<Void> {
+        override fun onCompleted(result: Void?) {
           Log.d(TAG, "registerNotification called and completed...")
+          promise.resolve(true)
         }
 
         override fun onError(errorCode: Int, errorMsg: String?) {
           Log.w(TAG, "registerNotification called but failed with $errorCode and $errorMsg ...")
+          promise.reject(errorCode.toString(), "registerNotification failed, errCode:$errorCode, errMsg:$errorMsg")
         }
       })
     }
   }
 
-  @ReactMethod
-  fun parseNotification(payload: ReadableMap?, promise: Promise?) {
-    Log.d(
-      TAG,
-      "parseNotification called and payload is " + (payload ?: "null")
-    )
-    if (payload == null) {
-      promise?.reject("-1", "payload data is null or empty")
-      return
-    }
-    try {
-      var intent = map2Intent(payload)
-      if (MEPClient.isMEPNotification(intent)) {
-        MEPClient.parseRemoteNotification(
-          intent,
-          object : ApiCallback<Map<String, String>> {
-            override fun onCompleted(rlt: Map<String, String>) {
-              var jsonObject = JSONObject()
-              var keys = rlt.keys
-              for (key in keys) {
-                when (key) {
-                  "chat_id", "feed_sequence", "session_id" -> jsonObject.put(key, rlt.getValue(key))
-                  "meet_id" -> {
-                    var meetId = rlt.getValue(key)
-                    jsonObject.put("session_id", meetId)
-                  }
-
-                  else -> continue
-                }
-              }
-              promise?.resolve(json2WritableNativeMap(jsonObject))
+  override fun parseNotification(payload: ReadableMap, promise: Promise) {
+    Log.d(TAG, "parseNotification called and payload is $payload")
+    val intent = toIntent(payload)
+    runOnSdkThread(promise) {
+      if (!MEPClient.isMEPNotification(intent)) {
+        promise.reject("-1", "It is not moxo payload!")
+        return@runOnSdkThread
+      }
+      MEPClient.parseRemoteNotification(intent, object : ApiCallback<Map<String, String>> {
+        override fun onCompleted(result: Map<String, String>) {
+          val map = Arguments.createMap()
+          for ((key, value) in result) {
+            when (key) {
+              "chat_id", "feed_sequence", "session_id" -> map.putString(key, value)
+              "meet_id" -> map.putString("session_id", value)
             }
+          }
+          promise.resolve(map)
+        }
 
-            override fun onError(errorCode: Int, errorMsg: String?) {
-              promise?.reject(
-                errorCode.toString(),
-                "parseRemoteNotification failed, errCode:$errorCode, errMsg:$errorMsg"
-              )
-            }
-          })
-      } else {
-        promise?.reject("-1", "It is not moxo payload!")
-      }
-    } catch (e: JSONException) {
-      e.printStackTrace()
-      promise?.reject("-1", "Invalid parameter: Not fcm payload")
+        override fun onError(errorCode: Int, errorMsg: String?) {
+          promise.reject(
+            errorCode.toString(),
+            "parseRemoteNotification failed, errCode:$errorCode, errMsg:$errorMsg"
+          )
+        }
+      })
     }
   }
 
-  @ReactMethod
-  fun showMeetRinger(sessionId: String, promise: Promise?) {
+  override fun showMeetRinger(sessionId: String, promise: Promise) {
     Log.d(TAG, "show meet ringer called with session id $sessionId")
-    if (!MEPClient.isLinked()) {
-      promise?.reject("-1", "Not linked")
-      return
-    }
-    if (sessionId.isEmpty()) {
-      promise?.reject("-1", "session id is empty!")
-      return
-    }
-    MEPClient.showMeetRinger(sessionId, object : ApiCallback<Void> {
-      override fun onCompleted(rlt: Void?) {
-        Log.d(TAG, "show meet ringer success ...")
-        promise?.resolve("Show meet ringer success")
+    runOnSdkThread(promise) {
+      if (!MEPClient.isLinked()) {
+        promise.reject("-1", "Not linked")
+        return@runOnSdkThread
       }
-
-      override fun onError(errorCode: Int, errorMsg: String?) {
-        Log.w(TAG, "show meet ringer failed with $errorCode and $errorMsg ...")
-        promise?.reject("-1", "Show meet ringer failed with $errorCode and $errorMsg")
+      if (sessionId.isEmpty()) {
+        promise.reject("-1", "session id is empty!")
+        return@runOnSdkThread
       }
-    })
+      MEPClient.showMeetRinger(sessionId, object : ApiCallback<Void> {
+        override fun onCompleted(result: Void?) {
+          Log.d(TAG, "show meet ringer success ...")
+          promise.resolve("Show meet ringer success")
+        }
+
+        override fun onError(errorCode: Int, errorMsg: String?) {
+          Log.w(TAG, "show meet ringer failed with $errorCode and $errorMsg ...")
+          promise.reject("-1", "Show meet ringer failed with $errorCode and $errorMsg")
+        }
+      })
+    }
   }
 
-  @ReactMethod
-  fun changeLanguage(lang: String) {
-    Log.d(TAG, "changeLanguage called with $lang ...")
-    if (lang.isNotEmpty()) {
-      MEPClient.changeLanguage(lang)
+  override fun changeLanguage(language: String) {
+    Log.d(TAG, "changeLanguage called with $language ...")
+    if (language.isEmpty()) {
+      return
+    }
+    runOnSdkThread {
+      MEPClient.changeLanguage(language)
     }
   }
 
-    @ReactMethod
-  fun startMeet(topic: String, options: ReadableMap?, promise: Promise?) {
-    Log.d(TAG, "startMeet called with topic: $topic, options:" + options?.toString())
-    if (topic.isNullOrEmpty()) {
-      promise?.reject("-1", "Topic is empty!")
+  override fun startMeet(topic: String, options: ReadableMap?, promise: Promise) {
+    Log.d(TAG, "startMeet called with topic: $topic, options: $options")
+    if (topic.isEmpty()) {
+      promise.reject("-1", "Topic is empty!")
       return
     }
 
-    var callback: ApiCallback<String> = object : ApiCallback<String> {
-      override fun onCompleted(sessionId: String) {
-        Log.d(TAG, "startMeet success ...")
-        val jsonObject = JSONObject()
-        with(jsonObject) {
-          put("session_id", sessionId)
+    val meetOptions = MEPStartMeetOptions().apply { this.topic = topic }
+    if (options != null) {
+      options.stringOrNull("chat_id")?.let { meetOptions.chatID = it }
+      options.booleanOrNull("auto_join_audio")?.let { meetOptions.setAutoJoinAudio(it) }
+      options.booleanOrNull("auto_start_video")?.let { meetOptions.setAutoStartVideo(it) }
+      options.booleanOrNull("auto_recording")?.let { meetOptions.isAutoRecordingEnabled = it }
+      options.booleanOrNull("instant_call")?.let { meetOptions.setInstantCall(it) }
+      if (options.hasKey("unique_ids") && options.getType("unique_ids") == ReadableType.Array) {
+        val ids = options.getArray("unique_ids")
+        if (ids != null) {
+          meetOptions.uniqueIDs = ArrayList((0 until ids.size()).mapNotNull { ids.getString(it) })
         }
-        promise?.resolve(json2WritableNativeMap(jsonObject))
-      }
-
-      override fun onError(errorCode: Int, errorMsg: String?) {
-        Log.w(TAG, "startMeet failed with $errorCode and $errorMsg ...")
-        promise?.reject(errorCode.toString(), "startMeet failed with $errorCode and $errorMsg")
       }
     }
 
-    //map to MEPStartMeetOptions
-    var mepStartMeetOptions = MEPStartMeetOptions()
-    mepStartMeetOptions.topic = topic
-
-    var mapValues = options?.entryIterator;
-    while (mapValues?.hasNext() == true) {
-      var mapEntry = mapValues.next()
-      when (mapEntry.key) {
-        "chat_id" -> mepStartMeetOptions.chatID = mapEntry.value.toString()
-        "auto_join_audio" -> mepStartMeetOptions.setAutoJoinAudio(mapEntry.value as Boolean)
-        "auto_start_video" -> mepStartMeetOptions.setAutoStartVideo(mapEntry.value as Boolean)
-        "auto_recording" -> mepStartMeetOptions.isAutoRecordingEnabled = mapEntry.value as Boolean
-        "instant_call" -> mepStartMeetOptions.setInstantCall(mapEntry.value as Boolean)
-        "unique_ids" -> {
-          val ids = mapEntry.value
-          if (ids is ReadableNativeArray) {
-            ids.toArrayList().also { mepStartMeetOptions.uniqueIDs = it as ArrayList<String> }
-          }
+    runOnSdkThread(promise) {
+      MEPClient.startMeet(meetOptions, object : ApiCallback<String> {
+        override fun onCompleted(sessionId: String) {
+          Log.d(TAG, "startMeet success ...")
+          promise.resolve(Arguments.createMap().apply { putString("session_id", sessionId) })
         }
-      }
-    }
 
-    MEPClient.startMeet(mepStartMeetOptions, callback)
+        override fun onError(errorCode: Int, errorMsg: String?) {
+          Log.w(TAG, "startMeet failed with $errorCode and $errorMsg ...")
+          promise.reject(errorCode.toString(), "startMeet failed with $errorCode and $errorMsg")
+        }
+      })
+    }
   }
 
-  private fun json2Intent(jsonObject: JSONObject?): Intent {
-    var intent = Intent()
-    var keys = jsonObject?.keys();
-    while (keys?.hasNext() == true) {
-      var key = keys.next()
-      intent.putExtra(key, jsonObject?.getString(key))
+  override fun enableTapWindowCloseEvent() {
+    Log.d(TAG, "enableTapWindowCloseEvent called...")
+    tapWindowCloseEnabled = true
+    runOnSdkThread {
+      registerCloseButtonListener()
     }
-    return intent
   }
 
-  private fun map2Intent(readableMap: ReadableMap?): Intent {
-    var intent = Intent()
-    var mapValues = readableMap?.entryIterator;
-    while (mapValues?.hasNext() == true) {
-      var mapEntry = mapValues.next()
-      when (mapEntry.value) {
-        is Double -> intent.putExtra(mapEntry.key, mapEntry.value as Double)
-        is String -> intent.putExtra(mapEntry.key, mapEntry.value as String)
-        is Map<*, *> -> intent.putExtra(mapEntry.key, mapEntry.value as String)
-        is ArrayList<*> -> intent.putExtra(mapEntry.key, mapEntry.value as ArrayList<*>)
+  // SDK calls share the queue that setup() initializes MEPClient on, so they
+  // always run after it. SDK exceptions are reported instead of crashing the app.
+  private fun runOnSdkThread(promise: Promise? = null, block: () -> Unit) {
+    reactContext.runOnUiQueueThread {
+      try {
+        block()
+      } catch (e: RuntimeException) {
+        Log.w(TAG, "MEPClient call failed", e)
+        promise?.reject("-1", e.message, e)
       }
     }
-    return intent
   }
 
- private fun json2WritableNativeMap(jsonObject: JSONObject?): WritableNativeMap {
-    val writableMap = WritableNativeMap()
-    jsonObject?.let {
-      for (key in jsonObject.keys()) {
-        when (val value = jsonObject.get(key)) {
-          is JSONObject -> {
-            writableMap.putMap(key, json2WritableNativeMap(value))
-          }
-
-          is JSONArray -> {
-            writableMap.putArray(key, json2WritableNativeArray(value))
-          }
-
-          is String -> {
-            writableMap.putString(key, value)
-          }
-
-          is Boolean -> {
-            writableMap.putBoolean(key, value)
-          }
-
-          is Double -> {
-            writableMap.putDouble(key, value)
-          }
-
-          is Int -> {
-            writableMap.putInt(key, value)
-          }
-
-          is Long -> {
-            writableMap.putDouble(key, value.toDouble());
-          }
-
-          else -> {
-            writableMap.putString(key, value.toString())
-          }
-        }
+  private fun registerClientListeners() {
+    MEPClient.getClientDelegate().setOnUnreadMessageListener(
+      MEPClientDelegate.OnUnreadMessageListener { unreadCount ->
+        Log.d(TAG, "onUnreadMessageCountUpdated, count is $unreadCount")
+        emitOnUnreadMessageCountUpdated(unreadCount.toDouble())
       }
+    )
+    if (tapWindowCloseEnabled) {
+      registerCloseButtonListener()
     }
-    return writableMap
   }
 
-  private fun json2WritableNativeArray(jsonArray: JSONArray?): WritableNativeArray {
-    val writableArray = WritableNativeArray()
-    jsonArray?.let {
-      for (i in 0 until jsonArray.length()) {
-        val jsonObject = jsonArray.get(i)
-        if (jsonObject is JSONObject) {
-          writableArray.pushMap(json2WritableNativeMap(jsonObject))
-        }
+  // Setting this listener replaces the SDK's default close behavior, so it is
+  // only installed once JS subscribes to onTapWindowClose.
+  private fun registerCloseButtonListener() {
+    MEPClient.getClientDelegate().setOnCloseButtonListener(ActionListener<Void> { _, _ ->
+      Log.d(TAG, "onTapWindowClose button clicked...")
+      emitOnTapWindowClose()
+    })
+  }
+
+  private fun toLinkConfig(options: ReadableMap): LinkConfig = LinkConfig().apply {
+    options.stringOrNull("certOrgName")?.let { certOrganization = it }
+    options.stringOrNull("certPublicKey")?.let { certPublicKey = it }
+    options.booleanOrNull("ignoreBadCert")?.let { isIgnoreBadCert = it }
+  }
+
+  // Only top-level strings and numbers are passed on to the SDK.
+  private fun toIntent(payload: ReadableMap): Intent {
+    val intent = Intent()
+    for ((key, value) in payload.toHashMap()) {
+      when (value) {
+        is String -> intent.putExtra(key, value)
+        is Double -> intent.putExtra(key, value)
       }
     }
-    return writableArray
+    return intent
   }
 
+  private fun ReadableMap.stringOrNull(key: String): String? =
+    if (hasKey(key) && getType(key) == ReadableType.String) getString(key) else null
+
+  private fun ReadableMap.booleanOrNull(key: String): Boolean? =
+    if (hasKey(key) && getType(key) == ReadableType.Boolean) getBoolean(key) else null
+
   companion object {
-    const val NAME = "MoxoModule"
+    const val NAME = NativeMoxoModuleSpec.NAME
+    private const val TAG = "MoxoModuleModule"
   }
 }