@flybits/react-native-concierge 0.0.0 → 0.1.8

package/android/src/main/java/com/concierge/FlybitsModule.kt

@@ -0,0 +1,460 @@
+package com.concierge
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.flybits.android.push.provider.FcmV2DeliveryProvider
+import com.flybits.android.push.provider.PushProvider
+import com.flybits.commons.library.SharedElementsFactory.get
+import com.flybits.commons.library.api.results.callbacks.BasicResultCallback
+import com.flybits.commons.library.exceptions.FlybitsException
+import com.flybits.commons.library.logging.Logger
+import com.flybits.commons.library.logging.VerbosityLevel
+import com.flybits.commons.library.models.PushProviderType
+import com.flybits.concierge.Concierge
+import com.flybits.concierge.ConciergeConstants.HUAWEI_PACKAGE_CONSTANT
+import com.flybits.concierge.FlybitsConciergeConfiguration
+import com.flybits.concierge.enums.ConciergePush
+import com.flybits.concierge.enums.PushTokenStatus
+import com.flybits.concierge.models.toMap
+import com.flybits.context.ContextManager
+import com.flybits.context.ReservedContextPlugin
+import com.flybits.flybitscoreconcierge.actiontypes.ActionTypeSchemeParser
+import com.flybits.flybitscoreconcierge.idps.AnonymousConciergeIDP
+import com.flybits.flybitscoreconcierge.idps.JwtLoginConciergeIDP
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import handleError
+import handleSuccess
+import org.json.JSONObject
+import readableMapToHashMap
+import java.lang.reflect.Type
+import java.net.URLEncoder
+import java.nio.charset.StandardCharsets
+import java.util.Locale
+
+const val TAG_FLYBITS_MODULE = "FlybitsModule"
+
+class FlybitsModule internal constructor(private val context: ReactApplicationContext) : ReactContextBaseJavaModule
+                                                                                         (context) {
+  override fun getName(): String {
+    return "FlybitsModule"
+  }
+
+  private var pushNetwork: PushProviderType = PushProviderType.FCM
+
+  @ReactMethod
+  fun configureFlybits(config: ReadableMap, promise: Promise) {
+    val projectId = config.getString("projectId")
+    val gateway = config.getString("gateway")
+    val webService = config.getString("webService")
+
+    val logLevel = config.getString("logLevel") ?: ""
+    if (logLevel.lowercase() == "debug") {
+      Concierge.setLoggingVerbosity(VerbosityLevel.ALL)
+    } else {
+      Concierge.setLoggingVerbosity(VerbosityLevel.NONE)
+    }
+
+    if (config.hasKey("pushNetwork")) {
+      pushNetwork = when (config.getString("pushNetwork")?.lowercase()) {
+        "fcm" -> PushProviderType.FCM
+        "huawei" -> PushProviderType.HUAWEI
+        else -> PushProviderType.FCM
+      }
+    }
+
+    var webPoolSize = 0
+    if (config.hasKey("webPoolSize")) {
+      try {
+        webPoolSize = config.getInt("webPoolSize")
+      } catch (_: Exception) {
+      }
+    }
+
+    var uploadPushTokenOnConnect = false
+    if (config.hasKey("uploadPushTokenOnConnect")) {
+      try {
+        uploadPushTokenOnConnect = config.getBoolean("uploadPushTokenOnConnect")
+      } catch (_: Exception) {
+      }
+    }
+
+    var timeToRefreshInterval = 10
+    if (config.hasKey("timeToRefreshInterval")) {
+      try {
+        timeToRefreshInterval = config.getInt("timeToRefreshInterval")
+      } catch (_: Exception) {
+      }
+    }
+
+    var timeToRefreshNoDataInterval = 2
+    if (config.hasKey("timeToRefreshNoDataInterval")) {
+      try {
+        timeToRefreshNoDataInterval = config.getInt("timeToRefreshNoDataInterval")
+      } catch (_: Exception) {
+      }
+    }
+
+    var locationPlugin = false
+    if (config.hasKey("locationPlugin")) {
+      try {
+        locationPlugin = config.getBoolean("locationPlugin")
+      } catch (_: Exception) {
+      }
+    }
+
+    if (projectId != null && gateway != null && gateway.isNotEmpty() && projectId.isNotEmpty
+      ()) {
+      val conciergeConfiguration = FlybitsConciergeConfiguration.Builder(context)
+        .setProjectId(projectId)
+        .setGatewayUrl(gateway)
+        .setWebService(webService ?: "https://static-files-concierge.demo.flybits.com/latest")
+        .setWebViewPoolingSize(webPoolSize)
+        .setUploadPushtokenOnConnect(uploadPushTokenOnConnect)
+        .setTimeToRefreshInterval(timeToRefreshInterval)
+        .setTimeToRefreshNoDataInterval(timeToRefreshNoDataInterval)
+      when (pushNetwork) {
+
+        PushProviderType.HUAWEI -> {
+          try {
+            val huaweiPushProvider = Class.forName(HUAWEI_PACKAGE_CONSTANT).kotlin.objectInstance
+            if (huaweiPushProvider != null) {
+              get(context).storePushProviderType(PushProviderType.HUAWEI)
+              conciergeConfiguration.setPushProvider(huaweiPushProvider as PushProvider)
+            }
+          } catch (_: Exception) { }
+        }
+
+        else -> {
+          conciergeConfiguration.setPushProvider(FcmV2DeliveryProvider)
+        }
+      }
+
+      val pluginArrayList = arrayListOf<ContextManager.PluginType.ReservedPlugin>()
+      if (locationPlugin) {
+        pluginArrayList.add(ContextManager.PluginType.ReservedPlugin
+        (ReservedContextPlugin
+          .LOCATION))
+      }
+
+      val locales = config.getString("locales")
+      val localeList = ArrayList<Locale>()
+      if (locales != null) {
+        val cleanedString = locales.removePrefix("[").removeSuffix("]").replace("\"", "")
+        val languages = cleanedString.split(",")
+        languages.forEach {
+          if (it.isNotEmpty()) {
+            if (it.contains("_")) {
+              val localePart = it.split("_")
+              localeList.add(Locale(localePart[0], localePart[1]))
+            } else {
+              localeList.add(Locale(it))
+            }
+          }
+        }
+      }
+
+      Concierge.configure(conciergeConfiguration.build(), pluginArrayList, context, arrayListOf(),
+        customLanguages = localeList)
+
+      val result = handleSuccess()
+      promise.resolve(result)
+    } else {
+      val result = handleError(code = 1)
+      promise.reject(TAG_FLYBITS_MODULE, result)
+    }
+  }
+
+  @ReactMethod
+  fun anonymousConnect(promise: Promise) {
+    Concierge.connect(
+      context = context,
+      idp = AnonymousConciergeIDP(),
+      fetchConfiguration = true,
+      basicResultCallback = object : BasicResultCallback {
+        override fun onSuccess() {
+          val result = handleSuccess()
+          promise.resolve(result)
+        }
+
+        override fun onException(exception: FlybitsException) {
+          val result = handleError(exception)
+          promise.resolve(result)
+        }
+      }
+    )
+  }
+
+  @ReactMethod
+  fun authenticateJwtSignIn(jwt: String, promise: Promise) {
+    Concierge.connect(
+      context = context,
+      idp = JwtLoginConciergeIDP(clientJwt = jwt),
+      fetchConfiguration = true,
+      basicResultCallback = object : BasicResultCallback {
+        override fun onSuccess() {
+          val result = handleSuccess()
+          promise.resolve(result)
+        }
+
+        override fun onException(exception: FlybitsException) {
+          val result = handleError(exception)
+          promise.resolve(result)
+        }
+      }
+    )
+  }
+
+  @ReactMethod
+  fun disconnect(promise: Promise) {
+    Concierge.disconnect(
+      context = context,
+      callback = object : BasicResultCallback {
+        override fun onException(exception: FlybitsException) {
+          val result = handleError(exception)
+          promise.resolve(result)
+        }
+
+        override fun onSuccess() {
+          val result = handleSuccess()
+          promise.resolve(result)
+        }
+      }
+    )
+  }
+
+  @ReactMethod
+  fun isConnected(promise: Promise) {
+    try {
+      val isConnected = Concierge.isConnected(context = context)
+      if (isConnected) {
+        val result = handleSuccess(result = "true")
+        promise.resolve(result)
+      } else {
+        val result = handleSuccess(result = "false")
+        promise.resolve(result)
+      }
+    } catch (e: FlybitsException) {
+      val result = handleError(e)
+      promise.reject(TAG_FLYBITS_MODULE, result)
+    }
+  }
+
+  @ReactMethod
+  fun actionlink(notification: ReadableMap, promise: Promise) {
+    try {
+      var dataMap: HashMap<String, Any?> = HashMap()
+      var conciergePush: ConciergePush? = null
+
+      when (pushNetwork) {
+        PushProviderType.FCM -> {
+          dataMap = readableMapToHashMap(notification.getMap("data"))
+          conciergePush = Concierge.handlePush(dataMap as HashMap<String, String>)
+        }
+
+        PushProviderType.HUAWEI -> {
+          dataMap = parseHuaweiNotification(notification)
+          val title = dataMap["title"] as? String
+          if (title != null) {
+            val encodedTitle = URLEncoder.encode(title, StandardCharsets.UTF_8.toString())
+            dataMap["title"] = encodedTitle
+          }
+          val alert = dataMap["alert"] as? String
+          if (alert != null) {
+            val encodedAlert = URLEncoder.encode(alert, StandardCharsets.UTF_8.toString())
+            dataMap["alert"] = encodedAlert
+          }
+
+          val body = dataMap["body"] as? HashMap<String, Any>
+          if (body != null) {
+            val actionScheme = body["actionScheme"] as? String
+            if (actionScheme != null) {
+              val encodedActionScheme = URLEncoder.encode(actionScheme, StandardCharsets.UTF_8.toString())
+              body["actionScheme"] = encodedActionScheme
+            }
+          }
+          conciergePush = Concierge.handlePush(dataMap.toString())
+        }
+
+        null -> {
+          // No-op
+        }
+
+        else -> {
+          dataMap = HashMap()
+        }
+      }
+      conciergePush?.let {
+        val uri = Concierge.getActionableLink(it)
+        val result = handleSuccess(result = uri.toString())
+        promise.resolve(result)
+      } ?: run {
+        val result = handleError(code = 2)
+        promise.resolve(result)
+      }
+    } catch (e: Exception) {
+      val flybitsException = FlybitsException(e)
+      val result = handleError(exception = flybitsException)
+      promise.reject(TAG_FLYBITS_MODULE, result)
+    }
+  }
+
+  @ReactMethod
+  fun actionTypeSchemeParser(actionableLink: String, promise: Promise) {
+    try {
+      if (actionableLink.isNotEmpty()) {
+        val type: Type = object : TypeToken<Map<String, Any>>() {}.type
+        val map: Map<String, Any> = Gson().fromJson(actionableLink, type)
+        val resultValue = map["result"]
+        val unescapedResult = resultValue.toString()
+          .replace("\\u003d", "=")
+          .replace("\\u0026", "&")
+
+        val actionTypeParser = ActionTypeSchemeParser.parse(unescapedResult)
+        val jsonObject = Gson().toJson(actionTypeParser)
+        val result = handleSuccess(result = jsonObject)
+        promise.resolve(result)
+      } else {
+        val result = handleError(code = 3)
+        promise.resolve(result)
+      }
+    } catch (e: Exception) {
+      val flybitsException = FlybitsException(e)
+      val result = handleError(exception = flybitsException)
+      promise.reject(TAG_FLYBITS_MODULE, result)
+    }
+  }
+
+  @ReactMethod
+  fun isFlybitsPush(notification: ReadableMap, promise: Promise) {
+    try {
+      var map: HashMap<String, Any?> = HashMap()
+      when (pushNetwork) {
+        PushProviderType.FCM -> {
+          map = readableMapToHashMap(notification.getMap("data"))
+        }
+
+        PushProviderType.HUAWEI -> {
+          map = parseHuaweiNotification(notification)
+        }
+
+        null -> {
+        }
+
+        else -> {
+          map = HashMap()
+        }
+      }
+
+      if (map.containsKey("provider") && map["provider"].toString().lowercase() == "flybits") {
+        val result = handleSuccess(result = "true")
+        promise.resolve(result)
+      } else {
+        val result = handleSuccess(result = "false")
+        promise.resolve(result)
+      }
+    } catch (e: Exception) {
+      val flybitsException = FlybitsException(e)
+      val result = handleError(exception = flybitsException)
+      promise.reject(TAG_FLYBITS_MODULE, result)
+    }
+  }
+
+  private fun extractHuaweiPushMap(
+    outerMap: Map<String, *>,
+    key: String
+  ): Map<String, *>? {
+    val innerValue = outerMap[key]
+    return innerValue as? Map<String, *>
+  }
+
+  private fun parseHuaweiNotification(notification: ReadableMap): HashMap<String, Any?> {
+    val dateOfMapObject = notification.getString("dataOfMap")
+    dateOfMapObject?.let {
+      val pushBodyObject = extractHuaweiPushMap(JSONObject(it).toMap(), "pushbody")
+      pushBodyObject?.let {
+        return HashMap(it)
+      }
+    } ?: run {
+      val dateOfMapObjectNotification = notification.getMap("extras")
+      dateOfMapObjectNotification?.let {
+        val innerBody = it.getMap("notification")
+        innerBody?.getString("message")?.let {
+          val pushBodyObject = extractHuaweiPushMap(JSONObject(it).toMap(), "pushbody")
+          pushBodyObject?.let {
+            return HashMap(it)
+          }
+        }
+      }
+    }
+    return HashMap()
+  }
+
+  @ReactMethod
+  public fun notificationStatus(promise: Promise) {
+    val status = Concierge.pushTokenUploadStatus(context = context)
+    when (status) {
+      PushTokenStatus.SENT -> {
+        val result = handleSuccess(result = "sent")
+        promise.resolve(result)
+      }
+
+      PushTokenStatus.DELETED -> {
+        val result = handleSuccess(result = "deleted")
+        promise.resolve(result)
+      }
+
+      PushTokenStatus.UNKNOWN -> {
+        val result = handleSuccess(result = "unknown")
+        promise.resolve(result)
+      }
+
+      else -> {
+        val result = handleSuccess(result = "unknown")
+        promise.resolve(result)
+      }
+    }
+  }
+
+  @ReactMethod
+  public fun addToken(token: String, promise: Promise) {
+    Concierge.sendPush(
+      token = token,
+      context = context,
+      parameters = null,
+      callback = object : BasicResultCallback {
+        override fun onException(exception: FlybitsException) {
+          val result = handleError(exception)
+          promise.resolve(result)
+        }
+
+        override fun onSuccess() {
+          val result = handleSuccess()
+          promise.resolve(result)
+        }
+      }
+    )
+  }
+
+  @ReactMethod
+  public fun removeToken(promise: Promise) {
+    Concierge.deletePushToken(
+      context = context,
+      callback = object : BasicResultCallback {
+        override fun onException(exception: FlybitsException) {
+          val result = handleError(exception)
+          promise.resolve(result)
+        }
+
+        override fun onSuccess() {
+          val result = handleSuccess()
+          promise.resolve(result)
+        }
+      }
+    )
+  }
+}

package/android/src/main/java/com/concierge/UtilityHelper.kt

@@ -0,0 +1,57 @@
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+import com.flybits.commons.library.exceptions.FlybitsException
+import com.flybits.flybitscoreconcierge.actiontypes.ActionTypeSchemeParser
+import com.google.gson.Gson
+import okhttp3.Response
+
+fun readableMapToHashMap(readableMap: ReadableMap?): HashMap<String, Any?> {
+  val hashMap = HashMap<String, Any?>()
+  if (readableMap == null) {
+    return hashMap
+  }
+
+  val iterator = readableMap.entryIterator
+  while (iterator.hasNext()) {
+    val entry = iterator.next()
+    val key = entry.key
+    val type = readableMap.getType(key)
+    when (type) {
+      ReadableType.Null -> hashMap[key] = null
+      ReadableType.Boolean -> hashMap[key] = readableMap.getBoolean(key)
+      ReadableType.Number -> hashMap[key] = readableMap.getDouble(key)
+      ReadableType.String -> hashMap[key] = readableMap.getString(key)
+      ReadableType.Map -> hashMap[key] = readableMapToHashMap(readableMap.getMap(key))
+      else -> throw IllegalArgumentException("Could not convert object with key: $key.")
+    }
+  }
+  return hashMap
+}
+
+fun handleSuccess(result: String = "ok") : String {
+  val responseMap: Map<String, Any?> =  mapOf(
+    "success" to true,
+    "result" to (result ?: "")
+  )
+  return constructJsonResponse(responseMap)
+}
+
+fun handleError(exception: FlybitsException?=null, code:Int? = -1) :String {
+  val responseMap: Map<String, Any?> =  mapOf(
+    "success" to false,
+    "code" to (exception?.errorCode ?: code),
+    "message" to (exception?.message ?: "")
+  )
+  return constructJsonResponse(responseMap)
+}
+
+fun constructJsonResponse(responseMap: Map<String, Any?>): String {
+  try {
+    val gson = Gson()
+    return gson.toJson(responseMap)
+  } catch (e: Exception) {
+    return ""
+  }
+}

package/ios/Concierge-Bridging-Header.h

@@ -0,0 +1 @@
+#import <React/RCTViewManager.h>

package/ios/ConciergeViewManager.m

@@ -0,0 +1,40 @@
+#import <React/RCTEventEmitter.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTBridgeModule.h>
+
+
+@interface RCT_EXTERN_MODULE(ConciergeViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(onConciergeChange, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(zoneReferenceIDs, NSArray<NSString>)
+RCT_EXPORT_VIEW_PROPERTY(onActionEvent, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAnalyticsEvent, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onContentArrived, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(actionlink, NSDictionary)
+
+@end
+
+
+@interface RCT_EXTERN_MODULE(FlybitsModule, NSObject)
+
+RCT_EXTERN_METHOD(configureFlybits: (NSDictionary) configuration resolved: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(anonymousConnect: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(isConnected: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(disconnect: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(notificationStatus: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(addToken: (NSString)token  resolved: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(removeToken: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(actionlink: (NSDictionary)userInfo resolved: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(authenticateJwtSignIn: (NSString)jwt resolved: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(isFlybitsPush: (NSDictionary)notification resolved: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+RCT_EXTERN_METHOD(actionTypeSchemeParser: (NSString)actionableLink resolved: (RCTPromiseResolveBlock)resolved rejected:(RCTPromiseRejectBlock))
+
+
+@end
+
+@interface RCT_EXTERN_MODULE(Auth, RCTEventEmitter)
+@end
+
+@interface RCT_EXTERN_MODULE(ConciergeView, RCTEventEmitter)
+@end
+