@moxtradeveloper/react-native-moxo-module 8.9.5

package/LICENSE

@@ -0,0 +1,6 @@
+MIT License
+
+Copyright (c) 2022 john.hu
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,179 @@
+# react-native-moxo-module
+reactnative-moxo-module is based on native Moxo MEPSDK, for now it only provides ability to call native SDK functions.
+
+## Installation
+
+```sh
+npm install react-native-moxo-module
+```
+#### Supported platforms
+iOS: iOS 13, Xcode 14
+
+Android: 
+
+### iOS Specific Steps
+* Add moxo cocoapod repo as source into Podfile under your iOS project.
+* Change pod deployment platform to iOS 13
+
+Sample:
+
+```ruby
+require_relative '../node_modules/react-native/scripts/react_native_pods'
+require_relative '../node_modules/@react-native-community/cli-platform-ios/native_modules'
+#Add moxo source here
+source 'https://maven.moxtra.com/repo/moxtra-specs.git'
+
+#Change platform version if is not iOS 13
+platform :ios, '13.0'
+install! 'cocoapods', :deterministic_uuids => false
+
+# Rest of the file.....
+```
+
+## Quick start 
+```js
+import * as moxo from 'react-native-moxo-module';
+
+// Setup domain
+moxo.setup('myenv.moxo.com')
+
+// Get access token
+const response = await fetch('https://myenv.moxo.com/v1/core/oauth/token', {
+    method: 'POST',
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+        client_id: 'my_clientid',
+        org_id: 'my_orgid',
+        unique_id: 'my_uniqueid',
+        client_secret: 'my_clientsecret'
+    })
+})
+const json = await response.json();
+token = json.access_token
+
+//Login and show moxo engagement platform window
+moxo.link(token).then((success)=>{
+if (result)
+    moxo.showMEPWindow();
+}).catch((err=>{
+    console.log(`Link failed!:${err}`);
+}))
+```
+### Notification
+To enable notification feature, you'll need to integrate a notification module first, here we take [react-native-notifications](https://www.npmjs.com/package/react-native-notifications) for example, which can help to get device token and notification payload.
+
+#### Register notification
+Through react-native-notifications registerRemoteNotifications(), post user agreement, notification will be enabled for your app. 
+Call registerRemoteNotificationsRegistered() to get a device token.
+Then pass token to moxo function ```registerNotification()``` will register notification to Moxo server.
+
+```js
+    Notifications.registerRemoteNotifications();
+    Notifications.events().registerRemoteNotificationsRegistered((event: Registered) => {
+      console.log("Device Token Received", event.deviceToken);
+      moxo.registerNotification(event.deviceToken).catch((err=>{
+        alertErr("Register notification failed", err);
+      }));
+    });
+    Notifications.events().registerRemoteNotificationsRegistrationFailed((event: RegistrationError) => {
+        console.error(event);
+    });
+```
+
+#### Handle notification
+For example, once notification received, and user tapped notification, react-native-notifications function registerNotificationOpened will be triggered with notification payload data. Then pass payload to moxo function ```parseNotification()``` like below:
+
+```js
+    Notifications.events().registerNotificationOpened((notification: Notification, completion: () => void, action?: NotificationActionResponse) => {
+      console.log("Notification opened by device user", notification.payload);
+      if (action != undefined) {
+        console.log(`Notification opened with an action identifier: ${action.identifier} and response text: ${action.text}`);
+      }
+      moxo.parseNotification(notification.payload).then((result=>{
+        console.log(`Moxo notificaiton parse success: ${result}`);
+        completion();
+      })).catch(err => {
+        alertErr('Notification parse failed',err)
+      })
+    });
+```
+
+If is a Moxo notification, then callback of the ```parseNotification()``` would be triggered with info parameter. Usually info contains 'chat_id' or 'meet_id', depends one which kind of notification you received.
+To do more, you can invoke function openChat(chat_id) to open target chat directly.
+
+#### Sample notification payload 
+
+##### iOS
+
+```json
+{
+    "aps": {
+        "alert": {
+            "body": "cheng4: hi",
+            "action_loc_key": "BCA"
+        },
+        "sound": "default"
+    },
+    "request": {
+        "object": {
+            "board": {
+                "id": "CBPErkesrtOeFfURA6gusJAD",
+                "feeds": [{
+                    "sequence": 191
+                }]
+            }
+        }
+    },
+    "id": "359",
+    "moxtra": "",
+    "category": "message",
+    "board_id": "CBPErkesrtOeFfURA6gusJAD",
+    "moxtra": ""
+}
+```
+
+##### Android 
+
+```json
+[
+  {
+    "count": "7",
+    "sound": "default",
+    "title": "rm1 Zhang",
+    "message": "rm1 Zhang: 1",
+    "additionalData": {
+       "feed_sequence": "3234",
+       "action_loc_key": "BCA",
+       "board_feed_unread_count": "3",
+       "moxtra": "",
+       "user_id": "CUxceIGfpXcHBna163lfFMD0",
+       "arg1": "rm1 Zhang",
+       "arg2": "1",
+       "arg3": "",
+       "loc_key": "BCM",
+       "request": {
+         "object": {
+        "board": {
+           "id": "CBPErkesrtOeFfURA6gusJAD",
+           "feeds": [{
+              "sequence": 3234
+                    }]
+                 }
+               }
+        },
+       "board_id": "CBPErkesrtOeFfURA6gusJAD",
+       "coldstart": false,
+       "board_name": "rm1 Zhang",
+       "foreground": true
+    }
+}]
+```
+
+## License
+
+ISC
+
+---

package/android/build.gradle

@@ -0,0 +1,161 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['MoxoModule_kotlinVersion']
+
+  repositories {
+    google()
+    mavenCentral()
+    maven() {
+      url "https://maven.moxtra.com/nexus/content/groups/mep_public/"
+    }
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:3.5.3'
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+rootProject.allprojects {
+  repositories {
+    google()
+    mavenCentral()
+    jcenter()
+    maven() {
+      url "https://maven.moxtra.com/nexus/content/groups/mep_public/"
+    }
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['MoxoModule_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['MoxoModule_' + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+
+  def found = false
+  def defaultDir = null
+  def androidSourcesName = 'React Native sources'
+
+  if (rootProject.ext.has('reactNativeAndroidRoot')) {
+    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
+  } else {
+    defaultDir = new File(
+      projectDir,
+      '/../../../node_modules/react-native/android'
+    )
+  }
+
+  if (defaultDir.exists()) {
+    maven {
+      url defaultDir.toString()
+      name androidSourcesName
+    }
+
+    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
+    found = true
+  } else {
+    def parentDir = rootProject.projectDir
+
+    1.upto(5, {
+      if (found) return true
+      parentDir = parentDir.parentFile
+
+      def androidSourcesDir = new File(
+        parentDir,
+        'node_modules/react-native'
+      )
+
+      def androidPrebuiltBinaryDir = new File(
+        parentDir,
+        'node_modules/react-native/android'
+      )
+
+      if (androidPrebuiltBinaryDir.exists()) {
+        maven {
+          url androidPrebuiltBinaryDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
+        found = true
+      } else if (androidSourcesDir.exists()) {
+        maven {
+          url androidSourcesDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
+        found = true
+      }
+    })
+  }
+
+  if (!found) {
+    throw new GradleException(
+      "${project.name}: unable to locate React Native android sources. " +
+        "Ensure you have you installed React Native as a dependency in your project and try again."
+    )
+  }
+}
+
+def kotlin_version = getExtOrDefault('kotlinVersion')
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.moxtra:mep-sdk:8.9.5"
+// From node_modules
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "MoxoModule"
+    codegenJavaPackageName = "com.moxomodule"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+MoxoModule_kotlinVersion=1.7.0
+MoxoModule_minSdkVersion=21
+MoxoModule_targetSdkVersion=31
+MoxoModule_compileSdkVersion=31
+MoxoModule_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.moxomodule">
+
+</manifest>

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

@@ -0,0 +1,287 @@
+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.moxtra.mepsdk.MEPClient
+import com.moxtra.mepsdk.MEPClientDelegate
+import com.moxtra.sdk.LinkConfig
+import com.moxtra.sdk.common.ApiCallback
+import org.json.JSONException
+import org.json.JSONObject
+
+class MoxoModuleModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val TAG: String = "MoxoModuleModule"
+
+  private var mReactContext = reactContext
+
+  private val UNREAD_MSG_EVENT = "onUnreadMessageCountUpdated"
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  fun setup(domain: String?, options: String?) {
+    Log.d(TAG, "setup called with domain: $domain, options: $options")
+    var linkConfig: LinkConfig? = null
+    try {
+      if (domain != null) {
+        if (options != null && options is String) {
+          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.setCertOrganization(certOrgName)
+          linkConfig.setCertPublicKey(certPublicKey)
+          linkConfig.setIgnoreBadCert(ignoreBadCert)
+        }
+      }
+    } catch (e: JSONException) {
+
+    }
+
+    mReactContext.runOnUiQueueThread {
+      MEPClient.initialize(mReactContext?.applicationContext as Application)
+      MEPClient.setupDomain(domain, linkConfig)
+
+      //setup callbacks
+      onUnreadMessageCountUpdated()
+    }
+  }
+
+  @ReactMethod
+  fun link(token: String?, promise: Promise?) {
+    Log.d(TAG, "link called with token: $token")
+    if (token == null || token.isEmpty()) {
+      promise?.reject("-1", "token is empty or null")
+      return
+    }
+    mReactContext.runOnUiQueueThread {
+      MEPClient.linkWithAccessToken(token, object : ApiCallback<Void?> {
+        override fun onCompleted(rlt: Void?) {
+          Log.d(
+            TAG,
+            "initWithAccessToken successful..."
+          )
+          promise?.resolve(true)
+        }
+
+        override fun onError(errorCode: Int, errorMsg: String) {
+          Log.d(
+            TAG,
+            "initWithAccessToken failed, errCode:$errorCode, errMsg:$errorMsg"
+          )
+          promise?.reject(
+            errorCode.toString(),
+            "initWithAccessToken failed, errCode:$errorCode, errMsg:$errorMsg"
+          )
+        }
+      })
+    }
+
+  }
+
+  @ReactMethod
+  fun showMEPWindow() {
+    Log.d(TAG, "showMEPWindow called...")
+    if (MEPClient.isLinked()) {
+      Log.d(TAG, "MEP is linked and showMEPWindow...")
+      MEPClient.showMEPWindow(mReactContext?.baseContext)
+    }
+  }
+
+  @ReactMethod
+  fun hideMEPWindow() {
+    Log.d(TAG, "hideMEPWindow called...")
+    if (MEPClient.isLinked()) {
+      Log.d(TAG, "MEP is linked and hideMEPWindow...")
+      MEPClient.destroyMEPWindow()
+    }
+  }
+
+  @ReactMethod
+  fun openChat(chatId: String?, feedSequence: Double?, promise: Promise?) {
+    Log.d(TAG, "openChat called...")
+    if (!MEPClient.isLinked()) {
+      promise?.reject("-1", "Not linked")
+      return
+    }
+    if (chatId?.isEmpty() == false) {
+      MEPClient.openChat(chatId, feedSequence?.toLong() ?: 0, object : ApiCallback<Void?> {
+        override fun onCompleted(rult: Void?) {
+          Log.d(TAG, "openChat successful...")
+          promise?.resolve(true)
+        }
+
+        override fun onError(errorCode: Int, errorMsg: String) {
+          promise?.reject(
+            errorCode.toString(),
+            "openChat failed, errCode:$errorCode, errMsg:$errorMsg"
+          )
+        }
+      })
+    } else {
+      promise?.reject("-1", "Invalid parameter")
+    }
+  }
+
+  @ReactMethod
+  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?) {
+        Log.d(TAG, "openRelationChat successful...")
+        promise?.resolve(true)
+      }
+
+      override fun onError(errorCode: Int, errorMsg: String) {
+        promise?.reject(
+          errorCode.toString(),
+          "openRelationChat failed, errCode:$errorCode, errMsg:$errorMsg"
+        )
+      }
+    }
+    if (uniqueId?.isEmpty() == false) {
+      MEPClient.openRelationChat(uniqueId, callback)
+    } else if (email?.isEmpty() == false) {
+      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)
+      }
+
+    MEPClient.getClientDelegate().setOnUnreadMessageListener(listener)
+  }
+
+  private fun sendEvent(reactContext: ReactContext, eventName: String, params: Int?) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    Log.d(TAG, "addListener called...")
+  }
+
+  @ReactMethod
+  fun removeListener(eventName: String) {
+    Log.d(TAG, "removeListener called...")
+  }
+
+  @ReactMethod
+  fun registerNotification(deviceToken: String?) {
+    Log.d(
+      TAG,
+      "registerNotification called and token is " + (if (deviceToken == null) "null" else "not null")
+    )
+    if (deviceToken != null) {
+      MEPClient.registerNotification(deviceToken, object : ApiCallback<Void> {
+        override fun onCompleted(rlt: Void?) {
+          Log.d(TAG, "registerNotification called and completed...")
+        }
+
+        override fun onError(errorCode: Int, errorMsg: String?) {
+          Log.w(TAG, "registerNotification called but failed with $errorCode and $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(jsonObject.toString())
+            }
+
+            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")
+    }
+  }
+
+  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))
+    }
+    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<*>)
+      }
+    }
+    return intent
+  }
+
+  companion object {
+    const val NAME = "MoxoModule"
+  }
+}

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

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

package/ios/MoxoModule-Bridging-Header.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>
+#import "MoxoModuleBridge.h"