@patra-cid/akaim-sdk-rn 0.4.16-denymsg.3

package/android/src/main/java/com/akaimsdkrn/AkaimSdkRnModule.kt

@@ -0,0 +1,1327 @@
+package com.akaimsdkrn
+
+import aka_im_core.Aka_im_core
+import com.akaimsdkrn.listener.*
+import com.akaimsdkrn.utils.Emitter
+import com.alibaba.fastjson.JSON
+import com.alibaba.fastjson.JSONObject
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import java.util.Objects
+
+@ReactModule(name = AkaimSdkRnModule.NAME)
+class AkaimSdkRnModule(private val reactContext: ReactApplicationContext) :
+        NativeAkaimSdkRnSpec(reactContext) {
+
+  private var emitter = Emitter()
+
+  override fun getSelfUserInfo(operationID: String, promise: Promise) {
+    Aka_im_core.getSelfUserInfo(CallbackPromise(promise), operationID)
+  }
+
+  // override fun getUserStatus(userIDList: ReadableArray, operationID: String, promise: Promise) {
+  //   Aka_im_core.getUserStatus( CallbackPromise(promise), operationID, userIDList.toString());
+  // }
+
+  override fun subscribeUsersStatus(
+          userIDList: ReadableArray,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.subscribeUsersStatus(CallbackPromise(promise), operationID, userIDList.toString())
+  }
+
+  override fun unsubscribeUsersStatus(
+          userIDList: ReadableArray,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.unsubscribeUsersStatus(CallbackPromise(promise), operationID, userIDList.toString())
+  }
+
+  override fun getSubscribeUsersStatus(operationID: String, promise: Promise) {
+    Aka_im_core.getSubscribeUsersStatus(CallbackPromise(promise), operationID)
+  }
+
+  override fun getAllConversationList(operationID: String, promise: Promise) {
+    Aka_im_core.getAllConversationList(CallbackPromise(promise), operationID)
+  }
+
+  override fun getConversationListSplit(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getConversationListSplit(
+            CallbackPromise(promise),
+            operationID,
+            options.getDouble("offset").toLong(),
+            options.getDouble("count").toLong()
+    )
+  }
+
+  override fun getOneConversation(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.getOneConversation(
+            CallbackPromise(promise),
+            operationID,
+            options.getDouble("sessionType").toInt(),
+            options.getString("sourceID")
+    )
+  }
+
+  override fun getMultipleConversation(
+          conversationIDList: ReadableArray,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getMultipleConversation(
+            CallbackPromise(promise),
+            operationID,
+            conversationIDList.toString()
+    )
+  }
+
+  override fun setGlobalRecvMessageOpt(opt: Double, operationID: String, promise: Promise) {
+    val params = JSONObject()
+    params.put("globalRecvMsgOpt", opt.toInt())
+    Aka_im_core.setGroupInfo(CallbackPromise(promise), operationID, params.toString())
+  }
+
+  // override fun hideAllConversations(operationID: String, promise: Promise) {
+  //   Aka_im_core.hideAllConversations(CallbackPromise(promise), operationID)
+  // }
+
+  override fun hideConversation(conversationID: String, operationID: String, promise: Promise) {
+    Aka_im_core.hideConversation(CallbackPromise(promise), operationID, conversationID)
+  }
+
+  override fun setConversation(options: ReadableMap, operationID: String, promise: Promise) {
+    val conversationID = options.getString("conversationID")
+    val conversation = map2string(options)
+    Aka_im_core.setConversation(CallbackPromise(promise), operationID, conversationID, conversation)
+  }
+
+  override fun setConversationDraft(options: ReadableMap, operationID: String, promise: Promise) {
+    val conversationID = options.getString("conversationID")
+    val draftText = options.getString("draftText")
+    Aka_im_core.setConversationDraft(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            draftText
+    )
+  }
+
+  override fun resetConversationGroupAtType(
+          conversationID: String,
+          operationID: String,
+          promise: Promise
+  ) {
+    val params = JSONObject()
+    params.put("groupAtType", 0)
+    Aka_im_core.setConversation(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            params.toString()
+    )
+  }
+
+  override fun pinConversation(options: ReadableMap, operationID: String, promise: Promise) {
+    val conversationID = options.getString("conversationID")
+    val params = JSONObject()
+    params.put("isPinned", options.getBoolean("isPinned"))
+    Aka_im_core.setConversation(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            params.toString()
+    )
+  }
+
+  override fun setConversationPrivateChat(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val conversationID = options.getString("conversationID")
+    val params = JSONObject()
+    params.put("isPrivateChat", options.getBoolean("isPrivate"))
+    Aka_im_core.setConversation(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            params.toString()
+    )
+  }
+
+  override fun setConversationBurnDuration(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val conversationID = options.getString("conversationID")
+    val params = JSONObject()
+    params.put("burnDuration", options.getDouble("burnDuration").toInt())
+    Aka_im_core.setConversation(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            params.toString()
+    )
+  }
+
+  override fun setConversationRecvMessageOpt(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val conversationID = options.getString("conversationID")
+    val params = JSONObject()
+    params.put("recvMsgOpt", options.getDouble("opt").toInt())
+    Aka_im_core.setConversation(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            params.toString()
+    )
+  }
+
+  override fun getTotalUnreadMsgCount(operationID: String, promise: Promise) {
+    Aka_im_core.getTotalUnreadMsgCount(CallbackPromise(promise), operationID)
+  }
+
+  // override fun getAtAllTag(operationID: String): String {
+  //   return Aka_im_core.getAtAllTag(operationID)
+  // }
+
+  // override fun createAdvancedTextMessage(options: ReadableMap, operationID: String, promise:
+  // Promise) {
+  //   val messageEntityList = options.getArray("messageEntityList")?.toString() ?: throw
+  // NullPointerException("messageEntityList is null")
+  //   val text = options.getString("text")
+
+  //   val message = Aka_im_core.createAdvancedTextMessage(operationID, text, messageEntityList)
+  //   try {
+  //     val obj = JSON.parseObject(message)
+  //     promise.resolve(emitter.convertJsonToMap(obj))
+  //   } catch (e: Exception) {
+  //     promise.resolve(message)
+  //   }
+  // }
+
+  override fun createTextAtMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val text = options.getString("text")
+    val atUserIDList = Objects.requireNonNull(options.getArray("atUserIDList")).toString()
+
+    val atUsersInfoMap =
+            if (options.hasKey("atUsersInfo")) options.getArray("atUsersInfo") else null
+    val atUsersInfo = atUsersInfoMap?.toString()
+
+    val messageMap = if (options.hasKey("message")) options.getMap("message") else null
+    val quoteMessage = messageMap?.let { map2string(it) }
+
+    val message =
+            Aka_im_core.createTextAtMessage(
+                    operationID,
+                    text,
+                    atUserIDList,
+                    atUsersInfo,
+                    quoteMessage
+            )
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createTextMessage(textMsg: String, operationID: String, promise: Promise) {
+    val message = Aka_im_core.createTextMessage(operationID, textMsg)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createLocationMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val description = options.getString("description")
+    val longitude = options.getDouble("longitude")
+    val latitude = options.getDouble("latitude")
+
+    val message = Aka_im_core.createLocationMessage(operationID, description, longitude, latitude)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createCustomMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val data = options.getString("data")
+    val extension = options.getString("extension")
+    val description = options.getString("description")
+
+    val message = Aka_im_core.createCustomMessage(operationID, data, extension, description)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createQuoteMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val text = options.getString("text")
+    val quoteMessage =
+            map2string(options.getMap("message") ?: throw NullPointerException("message is null"))
+
+    val message = Aka_im_core.createQuoteMessage(operationID, text, quoteMessage)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  // override fun createAdvancedQuoteMessage(options: ReadableMap, operationID: String, promise:
+  // Promise) {
+  //   val text = options.getString("text")
+  //   val quoteMessage = map2string(options.getMap("message") ?: throw
+  // NullPointerException("message is null"))
+  //   val messageEntityList =
+  // Objects.requireNonNull(options.getArray("messageEntityList")).toString()
+
+  //   val message = Aka_im_core.createAdvancedQuoteMessage(operationID, text, quoteMessage,
+  // messageEntityList)
+  //   try {
+  //     val obj = JSON.parseObject(message)
+  //     promise.resolve(emitter.convertJsonToMap(obj))
+  //   } catch (e: Exception) {
+  //     promise.resolve(message)
+  //   }
+  // }
+
+  override fun createCardMessage(cardElem: ReadableMap, operationID: String, promise: Promise) {
+    val card = map2string(cardElem)
+
+    val message = Aka_im_core.createCardMessage(operationID, card)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  // override fun createImageMessage(imagePath: String, operationID: String, promise: Promise) {
+  //   val message = Aka_im_core.createImageMessage(operationID, imagePath)
+  //   try {
+  //     JSONObject obj = JSON.parseObject(message);
+  //     promise.resolve(emitter.convertJsonToMap(obj));
+  //   } catch (Exception e) {
+  //     promise.resolve(message);
+  //   }
+  // }
+
+  override fun createImageMessageFromFullPath(
+          imagePath: String,
+          operationID: String,
+          promise: Promise
+  ) {
+    val message = Aka_im_core.createImageMessageFromFullPath(operationID, imagePath)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createImageMessageByURL(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val sourcePicture = map2string(options.getMap("sourcePicture")!!)
+    val bigPicture = map2string(options.getMap("bigPicture")!!)
+    val snapshotPicture = map2string(options.getMap("snapshotPicture")!!)
+    val sourcePath = options.getString("sourcePath")
+
+    val message =
+            Aka_im_core.createImageMessageByURL(
+                    operationID,
+                    sourcePath,
+                    sourcePicture,
+                    bigPicture,
+                    snapshotPicture
+            )
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  // override fun createSoundMessage(options: ReadableMap, operationID: String, promise: Promise) {
+  //   val soundPath = options.getString("soundPath")
+  //   val duration = options.getInt("duration")
+
+  //   val message = Aka_im_core.createSoundMessage(operationID, soundPath, duration)
+  //   try {
+  //     val obj = JSON.parseObject(message)
+  //     promise.resolve(emitter.convertJsonToMap(obj))
+  //   } catch (e: Exception) {
+  //     promise.resolve(message)
+  //   }
+  // }
+
+  override fun createSoundMessageFromFullPath(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val soundPath = options.getString("soundPath")
+    val duration = options.getDouble("duration").toLong()
+
+    val message = Aka_im_core.createSoundMessageFromFullPath(operationID, soundPath, duration)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createSoundMessageByURL(
+          soundInfo: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val sound = map2string(soundInfo)
+
+    val message = Aka_im_core.createSoundMessageByURL(operationID, sound)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  // override fun createVideoMessage(options: ReadableMap, operationID: String, promise: Promise) {
+  //   val videoPath = options.getString("videoPath")
+  //   val videoType = options.getString("videoType")
+  //   val duration = options.getInt("duration")
+  //   val snapshotPath = options.getString("snapshotPath")
+
+  //   val message = Aka_im_core.createVideoMessage(operationID, videoPath, videoType, duration,
+  // snapshotPath)
+  //   try {
+  //     val obj = JSON.parseObject(message)
+  //     promise.resolve(emitter.convertJsonToMap(obj))
+  //   } catch (e: Exception) {
+  //     promise.resolve(message)
+  //   }
+  // }
+
+  override fun createVideoMessageFromFullPath(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val videoPath = options.getString("videoPath")
+    val videoType = options.getString("videoType")
+    val duration = options.getDouble("duration").toLong()
+    val snapshotPath = options.getString("snapshotPath")
+
+    val message =
+            Aka_im_core.createVideoMessageFromFullPath(
+                    operationID,
+                    videoPath,
+                    videoType,
+                    duration,
+                    snapshotPath
+            )
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createVideoMessageByURL(
+          videoInfo: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val video = map2string(videoInfo)
+
+    val message = Aka_im_core.createVideoMessageByURL(operationID, video)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createFileMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val filePath = options.getString("filePath")
+    val fileName = options.getString("fileName")
+
+    val message = Aka_im_core.createFileMessage(operationID, filePath, fileName)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createFileMessageFromFullPath(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val filePath = options.getString("filePath")
+    val fileName = options.getString("fileName")
+
+    val message = Aka_im_core.createFileMessage(operationID, filePath, fileName)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createFileMessageByURL(
+          fileInfo: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val file = map2string(fileInfo)
+
+    val message = Aka_im_core.createFileMessageByURL(operationID, file)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createMergerMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val messageList = options.getArray("messageList").toString()
+    val title = options.getString("title")
+    val summaryList = options.getArray("summaryList").toString()
+
+    val message = Aka_im_core.createMergerMessage(operationID, messageList, title, summaryList)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createFaceMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val index = options.getDouble("index").toLong()
+    val dataStr = options.getString("dataStr")
+
+    val message = Aka_im_core.createFaceMessage(operationID, index, dataStr)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun createForwardMessage(
+          messageList: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val forward = map2string(messageList)
+
+    val message = Aka_im_core.createForwardMessage(operationID, forward)
+    try {
+      val obj = JSON.parseObject(message)
+      promise.resolve(emitter.convertJsonToMap(obj))
+    } catch (e: Exception) {
+      promise.resolve(message)
+    }
+  }
+
+  override fun getConversationIDBySessionType(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val result =
+            Aka_im_core.getConversationIDBySessionType(
+                    operationID,
+                    options.getString("sourceID"),
+                    options.getDouble("sessionType").toLong()
+            )
+    promise.resolve(result)
+  }
+
+  override fun findMessageList(findOptions: ReadableArray, operationID: String, promise: Promise) {
+    Aka_im_core.findMessageList(CallbackPromise(promise), operationID, findOptions.toString())
+  }
+
+  override fun getAdvancedHistoryMessageList(
+          findOptions: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getAdvancedHistoryMessageList(
+            CallbackPromise(promise),
+            operationID,
+            map2string(findOptions)
+    )
+  }
+
+  override fun getAdvancedHistoryMessageListReverse(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getAdvancedHistoryMessageListReverse(
+            CallbackPromise(promise),
+            operationID,
+            map2string(options)
+    )
+  }
+
+  override fun revokeMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.revokeMessage(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("conversationID"),
+            options.getString("clientMsgID")
+    )
+  }
+
+  // override fun searchConversation(searchParams: String, operationID: String, promise: Promise) {
+  //   Aka_im_core.searchConversation(CallbackPromise(promise), operationID, searchParams)
+  // }
+
+  override fun typingStatusUpdate(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.typingStatusUpdate(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("recvID"),
+            options.getString("msgTip")
+    )
+  }
+
+  override fun changeInputStates(options: ReadableMap, operationID: String, promise: Promise) {
+    val conversationID = options.getString("conversationID")
+    val focus = options.getBoolean("focus")
+    Aka_im_core.changeInputStates(CallbackPromise(promise), operationID, conversationID, focus)
+  }
+
+  override fun getInputStates(options: ReadableMap, operationID: String, promise: Promise) {
+    val conversationID = options.getString("conversationID")
+    val userID = options.getString("userID")
+    Aka_im_core.getInputStates(CallbackPromise(promise), operationID, conversationID, userID)
+  }
+
+  override fun markConversationMessageAsRead(
+          conversationID: String,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.markConversationMessageAsRead(CallbackPromise(promise), operationID, conversationID)
+  }
+
+  override fun deleteMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val conversationID = options.getString("conversationID")
+    val clientMsgID = options.getString("clientMsgID")
+
+    Aka_im_core.deleteMessage(CallbackPromise(promise), operationID, conversationID, clientMsgID)
+  }
+
+  override fun deleteMessageFromLocalStorage(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val conversationID = options.getString("conversationID")
+    val clientMsgID = options.getString("clientMsgID")
+    Aka_im_core.deleteMessageFromLocalStorage(
+            CallbackPromise(promise),
+            operationID,
+            conversationID,
+            clientMsgID
+    )
+  }
+
+  override fun deleteAllMsgFromLocalAndSvr(operationID: String, promise: Promise) {
+    Aka_im_core.deleteAllMsgFromLocalAndSvr(CallbackPromise(promise), operationID)
+  }
+
+  override fun deleteAllMsgFromLocal(operationID: String, promise: Promise) {
+    Aka_im_core.deleteAllMsgFromLocal(CallbackPromise(promise), operationID)
+  }
+
+  override fun clearConversationAndDeleteAllMsg(
+          conversationID: String,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.clearConversationAndDeleteAllMsg(
+            CallbackPromise(promise),
+            operationID,
+            conversationID
+    )
+  }
+
+  override fun deleteConversationAndDeleteAllMsg(
+          conversationID: String,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.deleteConversationAndDeleteAllMsg(
+            CallbackPromise(promise),
+            operationID,
+            conversationID
+    )
+  }
+
+  override fun insertSingleMessageToLocalStorage(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.insertSingleMessageToLocalStorage(
+            CallbackPromise(promise),
+            operationID,
+            map2string(options.getMap("message")!!),
+            options.getString("recvID"),
+            options.getString("sendID")
+    )
+  }
+
+  override fun insertGroupMessageToLocalStorage(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.insertGroupMessageToLocalStorage(
+            CallbackPromise(promise),
+            operationID,
+            map2string(options.getMap("message")!!),
+            options.getString("groupID"),
+            options.getString("sendID")
+    )
+  }
+
+  override fun searchLocalMessages(
+          searchParam: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.searchLocalMessages(CallbackPromise(promise), operationID, map2string(searchParam))
+  }
+
+  override fun setMessageLocalEx(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.setMessageLocalEx(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("conversationID"),
+            options.getString("clientMsgID"),
+            options.getString("localEx")
+    )
+  }
+
+  override fun getSpecifiedFriendsInfo(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    val userIDList = options.getArray("userIDList")
+    var filterBlack = false
+    if (options.hasKey("filterBlack")) {
+      filterBlack = options.getBoolean("filterBlack")
+    }
+    Aka_im_core.getSpecifiedFriendsInfo(
+            CallbackPromise(promise),
+            operationID,
+            userIDList.toString(),
+            filterBlack
+    )
+  }
+
+  override fun getFriendList(filterBlack: Boolean, operationID: String, promise: Promise) {
+    Aka_im_core.getFriendList(CallbackPromise(promise), operationID, filterBlack)
+  }
+
+  override fun getFriendListPage(options: ReadableMap, operationID: String, promise: Promise) {
+    val offset = options.getDouble("offset").toInt()
+    val count = options.getDouble("count").toInt()
+    var filterBlack = false
+    if (options.hasKey("filterBlack")) {
+      filterBlack = options.getBoolean("filterBlack")
+    }
+    Aka_im_core.getFriendListPage(CallbackPromise(promise), operationID, offset, count, filterBlack)
+  }
+
+  override fun searchFriends(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.searchFriends(CallbackPromise(promise), operationID, map2string(options))
+  }
+
+  override fun checkFriend(userIDList: ReadableArray, operationID: String, promise: Promise) {
+    Aka_im_core.checkFriend(CallbackPromise(promise), operationID, userIDList.toString())
+  }
+
+  override fun addFriend(params: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.addFriend(CallbackPromise(promise), operationID, map2string(params))
+  }
+
+  // public fun updateFriends(params: ReadableMap, operationID: String, promise: Promise) {
+  //   Aka_im_core.updateFriends(CallbackPromise(promise), operationID, map2string(params))
+  // }
+
+  override fun setFriendRemark(options: ReadableMap, operationID: String, promise: Promise) {
+    val toUserIDList = ArrayList<String>()
+    options.getString("friendUserIDs")?.let { toUserIDList.add(it) }
+
+    val params = JSONObject()
+    params.put("friendUserIDs", toUserIDList)
+    params.put("remark", options.getString("remark"))
+
+    Aka_im_core.updateFriends(CallbackPromise(promise), operationID, params.toString())
+  }
+
+  override fun deleteFriend(friendUserID: String, operationID: String, promise: Promise) {
+    Aka_im_core.deleteFriend(CallbackPromise(promise), operationID, friendUserID)
+  }
+
+  override fun getFriendApplicationListAsRecipient(operationID: String, promise: Promise) {
+    Aka_im_core.getFriendApplicationListAsRecipient(CallbackPromise(promise), operationID)
+  }
+
+  override fun getFriendApplicationListAsApplicant(operationID: String, promise: Promise) {
+    Aka_im_core.getFriendApplicationListAsApplicant(CallbackPromise(promise), operationID)
+  }
+
+  override fun acceptFriendApplication(
+          userIDHandleMsg: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.acceptFriendApplication(
+            CallbackPromise(promise),
+            operationID,
+            map2string(userIDHandleMsg)
+    )
+  }
+
+  override fun refuseFriendApplication(
+          userIDHandleMsg: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.refuseFriendApplication(
+            CallbackPromise(promise),
+            operationID,
+            map2string(userIDHandleMsg)
+    )
+  }
+
+  override fun addBlack(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.addBlack(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("toUserID"),
+            options.getString("ex")
+    )
+  }
+
+  override fun getBlackList(operationID: String, promise: Promise) {
+    Aka_im_core.getBlackList(CallbackPromise(promise), operationID)
+  }
+
+  override fun removeBlack(removeUserID: String, operationID: String, promise: Promise) {
+    Aka_im_core.removeBlack(CallbackPromise(promise), operationID, removeUserID)
+  }
+
+  override fun createGroup(gInfo: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.createGroup(CallbackPromise(promise), operationID, map2string(gInfo))
+  }
+
+  override fun joinGroup(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.joinGroup(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getString("reqMsg"),
+            options.getDouble("joinSource").toInt(),
+            options.getString("ex")
+    )
+  }
+
+  override fun quitGroup(groupID: String, operationID: String, promise: Promise) {
+    Aka_im_core.quitGroup(CallbackPromise(promise), operationID, groupID)
+  }
+
+  override fun dismissGroup(groupID: String, operationID: String, promise: Promise) {
+    Aka_im_core.dismissGroup(CallbackPromise(promise), operationID, groupID)
+  }
+
+  override fun changeGroupMute(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.changeGroupMute(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getBoolean("isMute")
+    )
+  }
+
+  override fun changeGroupMemberMute(options: ReadableMap, operationID: String, promise: Promise)
+  {
+    Aka_im_core.changeGroupMemberMute(CallbackPromise(promise), operationID,
+  options.getString("groupID"),
+      options.getString("userID"), options.getInt("mutedSeconds").toLong())
+  }
+
+  // override fun setGroupMemberRoleLevel(options: ReadableMap, operationID: String, promise:
+  // Promise) {
+  //   Aka_im_core.setGroupMemberInfo(CallbackPromise(promise), operationID, map2string(options))
+  // }
+
+  override fun setGroupMemberInfo(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.setGroupMemberInfo(CallbackPromise(promise), operationID, map2string(options))
+  }
+
+  override fun getJoinedGroupList(operationID: String, promise: Promise) {
+    Aka_im_core.getJoinedGroupList(CallbackPromise(promise), operationID)
+  }
+
+  override fun getJoinedGroupListPage(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.getJoinedGroupListPage(
+            CallbackPromise(promise),
+            operationID,
+            options.getDouble("offset").toInt(),
+            options.getDouble("count").toInt()
+    )
+  }
+
+  override fun getSpecifiedGroupsInfo(
+          groupIDList: ReadableArray,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getSpecifiedGroupsInfo(
+            CallbackPromise(promise),
+            operationID,
+            groupIDList.toString()
+    )
+  }
+
+  override fun searchGroups(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.searchGroups(CallbackPromise(promise), operationID, map2string(options))
+  }
+
+  override fun setGroupInfo(jsonGroupInfo: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.setGroupInfo(CallbackPromise(promise), operationID, map2string(jsonGroupInfo))
+  }
+
+  // override fun setGroupVerification(options: ReadableMap, operationID: String, promise: Promise)
+  // {
+  //   val params = JSONObject()
+  //   params.put("groupID", options.getString("groupID"))
+  //   params.put("needVerification", options.getString("verification"))
+  //   Aka_im_core.setGroupInfo(CallbackPromise(promise), operationID, params.toString())
+  // }
+
+  // override fun setGroupLookMemberInfo(options: ReadableMap, operationID: String, promise:
+  // Promise) {
+  //   val params = JSONObject()
+  //   params.put("groupID", options.getString("groupID"))
+  //   params.put("lookMemberInfo", options.getString("rule"))
+  //   Aka_im_core.setGroupInfo(CallbackPromise(promise), operationID, params.toString())
+  // }
+
+  // override fun setGroupApplyMemberFriend(options: ReadableMap, operationID: String, promise:
+  // Promise) {
+  //   val params = JSONObject()
+  //   params.put("groupID", options.getString("groupID"))
+  //   params.put("applyMemberFriend", options.getString("rule"))
+  //   Aka_im_core.setGroupInfo(CallbackPromise(promise), operationID, params.toString())
+  // }
+
+  override fun getGroupMemberList(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.getGroupMemberList(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getDouble("filter").toInt(),
+            options.getDouble("offset").toInt(),
+            options.getDouble("count").toInt()
+    )
+  }
+
+  override fun getGroupMemberOwnerAndAdmin(groupID: String, operationID: String, promise: Promise) {
+    Aka_im_core.getGroupMemberOwnerAndAdmin(CallbackPromise(promise), operationID, groupID)
+  }
+
+  override fun getGroupMemberListByJoinTimeFilter(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getGroupMemberListByJoinTimeFilter(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getDouble("offset").toInt(),
+            options.getDouble("count").toInt(),
+            options.getDouble("joinTimeBegin").toLong(),
+            options.getDouble("joinTimeEnd").toLong(),
+            Objects.requireNonNull(options.getArray("filterUserIDList")).toString()
+    )
+  }
+
+  override fun getSpecifiedGroupMembersInfo(
+          options: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.getSpecifiedGroupMembersInfo(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            Objects.requireNonNull(options.getArray("userIDList")).toString()
+    )
+  }
+
+  override fun getUsersInGroup(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.getUsersInGroup(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            Objects.requireNonNull(options.getArray("userIDList")).toString()
+    )
+  }
+
+  override fun kickGroupMember(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.kickGroupMember(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getString("reason"),
+            Objects.requireNonNull(options.getArray("userIDList")).toString()
+    )
+  }
+
+  override fun transferGroupOwner(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.transferGroupOwner(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getString("newOwnerUserID")
+    )
+  }
+
+  override fun inviteUserToGroup(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.inviteUserToGroup(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getString("reason"),
+            Objects.requireNonNull(options.getArray("userIDList")).toString()
+    )
+  }
+
+  override fun getGroupApplicationListAsRecipient(operationID: String, promise: Promise) {
+    Aka_im_core.getGroupApplicationListAsRecipient(CallbackPromise(promise), operationID)
+  }
+
+  override fun getGroupApplicationListAsApplicant(operationID: String, promise: Promise) {
+    Aka_im_core.getGroupApplicationListAsApplicant(CallbackPromise(promise), operationID)
+  }
+
+  override fun acceptGroupApplication(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.acceptGroupApplication(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getString("fromUserID"),
+            options.getString("handleMsg")
+    )
+  }
+
+  override fun refuseGroupApplication(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.refuseGroupApplication(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("groupID"),
+            options.getString("fromUserID"),
+            options.getString("handleMsg")
+    )
+  }
+
+  // override fun setGroupMemberNickname(options: ReadableMap, operationID: String, promise:
+  // Promise) {
+  //   val params = JSONObject()
+  //   params.put("groupID", options.getString("groupID"))
+  //   params.put("userID", options.getString("userID"))
+  //   params.put("nickname", options.getString("groupMemberNickname"))
+  //   Aka_im_core.setGroupMemberInfo(CallbackPromise(promise), operationID, params.toString())
+  // }
+
+  override fun searchGroupMembers(
+          searchOptions: ReadableMap,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.searchGroupMembers(CallbackPromise(promise), operationID, map2string(searchOptions))
+  }
+
+  override fun isJoinGroup(groupID: String, operationID: String, promise: Promise) {
+    Aka_im_core.isJoinGroup(CallbackPromise(promise), operationID, groupID)
+  }
+
+  // override fun updateFcmToken(options: ReadableMap, operationID: String, promise: Promise) {
+  //   Aka_im_core.updateFcmToken(CallbackPromise(promise), operationID,
+  // options.getString("fcmToken"), options.getInt("expireTime"))
+  // }
+
+  override fun sendMessage(options: ReadableMap, operationID: String, promise: Promise) {
+    val message = options.getMap("message")
+    val receiver = options.getString("recvID")
+    val groupID = options.getString("groupID")
+    var offlinePushInfo = options.getMap("offlinePushInfo")
+
+    var isOnlineOnly = false
+    if (options.hasKey("isOnlineOnly")) {
+      isOnlineOnly = options.getBoolean("isOnlineOnly")
+    }
+
+    if (offlinePushInfo == null) {
+      val defaultOfflinePushInfo = Arguments.createMap()
+      defaultOfflinePushInfo.putString("title", "you have a new message")
+      defaultOfflinePushInfo.putString("desc", "new message")
+      defaultOfflinePushInfo.putString("ex", "")
+      defaultOfflinePushInfo.putString("iOSPushSound", "+1")
+      defaultOfflinePushInfo.putBoolean("iOSBadgeCount", true)
+      offlinePushInfo = defaultOfflinePushInfo
+    }
+
+    requireNotNull(message)
+    Aka_im_core.sendMessage(
+            SendMsgCallBack(reactContext, promise, message),
+            operationID,
+            map2string(message),
+            receiver,
+            groupID,
+            map2string(offlinePushInfo),
+            isOnlineOnly
+    )
+  }
+
+  override fun sendMessageNotOss(options: ReadableMap, operationID: String, promise: Promise) {
+    val message = options.getMap("message")
+    val receiver = options.getString("recvID")
+    val groupID = options.getString("groupID")
+    var offlinePushInfo = options.getMap("offlinePushInfo")
+
+    var isOnlineOnly = false
+    if (options.hasKey("isOnlineOnly")) {
+      isOnlineOnly = options.getBoolean("isOnlineOnly")
+    }
+
+    if (offlinePushInfo == null) {
+      val defaultOfflinePushInfo = Arguments.createMap()
+      defaultOfflinePushInfo.putString("title", "you have a new message")
+      defaultOfflinePushInfo.putString("desc", "new message")
+      defaultOfflinePushInfo.putString("ex", "")
+      defaultOfflinePushInfo.putString("iOSPushSound", "+1")
+      defaultOfflinePushInfo.putBoolean("iOSBadgeCount", true)
+      offlinePushInfo = defaultOfflinePushInfo
+    }
+
+    assert(message != null)
+    Aka_im_core.sendMessageNotOss(
+            SendMsgCallBack(reactContext, promise, message!!),
+            operationID,
+            map2string(message),
+            receiver,
+            groupID,
+            map2string(offlinePushInfo),
+            isOnlineOnly
+    )
+  }
+
+  // override fun setAppBadge(appUnreadCount: Int, operationID: String, promise: Promise) {
+  //   Aka_im_core.setAppBadge(CallbackPromise(promise), operationID, appUnreadCount)
+  // }
+
+  override fun uploadLogs(options: ReadableMap, opid: String?, promise: Promise) {
+    Aka_im_core.uploadLogs(
+            CallbackPromise(promise),
+            opid,
+            options.getDouble("line").toLong(),
+            options.getString("ex") ?: "",
+            UploadLogProgressListener(reactContext, opid ?: "")
+    )
+  }
+
+  override fun logs(options: ReadableMap, opid: String?, promise: Promise) {
+    val logLevel = options.getDouble("logLevel")
+    val file = options.getString("file")
+    val line = options.getDouble("line")
+    val msg = options.getString("msgs")
+    val err = options.getString("err")
+    val keyAndValue = options.getString("keyAndValue")
+    Aka_im_core.logs(
+            CallbackPromise(promise),
+            opid,
+            logLevel.toLong(),
+            file,
+            line.toLong(),
+            msg,
+            err,
+            keyAndValue
+    )
+  }
+
+  fun getSdkVersion(): String {
+    return Aka_im_core.getSdkVersion()
+  }
+
+  override fun uploadFile(reqData: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.uploadFile(
+            CallbackPromise(promise),
+            operationID,
+            map2string(reqData),
+            UploadFileCallbackListener(reactContext, operationID)
+    )
+  }
+
+  override fun unInitSDK(operationID: String?, promise: Promise) {
+    Aka_im_core.unInitSDK(operationID)
+  }
+  // ============
+  override fun setSelfInfo(userInfo: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.setSelfInfo(CallbackPromise(promise), operationID, map2string(userInfo))
+  }
+  override fun getUsersInfo(userIDList: ReadableArray, operationID: String, promise: Promise) {
+    Aka_im_core.getUsersInfo(CallbackPromise(promise), operationID, userIDList.toString())
+  }
+  override fun getLoginUserID(promise: Promise) {
+    val userID = Aka_im_core.getLoginUserID()
+    promise.resolve(userID)
+  }
+  override fun getLoginStatus(operationID: String, promise: Promise) {
+    val status = Aka_im_core.getLoginStatus(operationID)
+    promise.resolve(status.toString())
+  }
+  override fun networkStatusChange(operationID: String, promise: Promise) {
+    Aka_im_core.networkStatusChanged(CallbackPromise(promise), operationID)
+  }
+  override fun setAppBackgroundStatus(
+          isBackground: Boolean,
+          operationID: String,
+          promise: Promise
+  ) {
+    Aka_im_core.setAppBackgroundStatus(CallbackPromise(promise), operationID, isBackground)
+  }
+  override fun logout(operationID: String, promise: Promise) {
+    Aka_im_core.logout(CallbackPromise(promise), operationID)
+  }
+  override fun login(options: ReadableMap, operationID: String, promise: Promise) {
+    Aka_im_core.login(
+            CallbackPromise(promise),
+            operationID,
+            options.getString("userID"),
+            options.getString("token")
+    )
+  }
+
+  override fun initSDK(options: ReadableMap, operationID: String, promise: Promise) {
+    val config: WritableMap = Arguments.createMap()
+    config.merge(options)
+
+    config.putInt("platformID", 2)
+
+    val initialized =
+            Aka_im_core.initSDK(InitSDKListener(reactContext), operationID, map2string(config))
+    setUserListener()
+    setConversationListener()
+    setFriendListener()
+    setGroupListener()
+    setAdvancedMsgListener()
+    setBatchMsgListener()
+
+    if (initialized) {
+      promise.resolve("init success")
+    } else {
+      promise.reject("-1", "please check params and dir")
+    }
+  }
+  private fun setBatchMsgListener() {
+    Aka_im_core.setBatchMsgListener(BatchMsgListener(reactContext))
+  }
+  private fun setAdvancedMsgListener() {
+    Aka_im_core.setAdvancedMsgListener(AdvancedMsgListener(reactContext))
+  }
+  private fun setGroupListener() {
+    Aka_im_core.setGroupListener(OnGroupListener(reactContext))
+  }
+  private fun setFriendListener() {
+    Aka_im_core.setFriendListener(OnFriendshipListener(reactContext))
+  }
+  private fun setConversationListener() {
+    Aka_im_core.setConversationListener(OnConversationListener(reactContext))
+  }
+  private fun setUserListener() {
+    Aka_im_core.setUserListener(UserListener(reactContext))
+  }
+
+  private var listenerCount = 0
+  override fun addListener(eventName: String?) {
+    listenerCount += 1
+  }
+  override fun removeListeners(count: Double) {
+    listenerCount -= count.toInt()
+  }
+
+  private fun map2string(map: ReadableMap): String {
+    return map.toString()
+  }
+  private fun array2string(array: ReadableArray): String {
+    return array.toString()
+  }
+  override fun getName(): String {
+    return NAME
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  override fun multiply(a: Double, b: Double): Double {
+    return a * b
+  }
+
+  companion object {
+    const val NAME = "AkaimSdkRn"
+  }
+}