@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/android/src/main/java/com/hydralib/hydrasdk/HydraExtenstions.kt

@@ -0,0 +1,331 @@
+package com.hydralib.hydrasdk
+
+import com.capillary.hydra.inapp.database.entity.CampaignPayload
+import com.capillary.hydra.inbox.core.internal.Constants.NOTIFICATION_EXPANDED_DETAILS
+import com.capillary.hydra.inbox.core.model.Action
+import com.capillary.hydra.inbox.core.model.CTATYPE
+import com.capillary.hydra.inbox.core.model.GATEWAY
+import com.capillary.hydra.inbox.core.model.InboxMessage
+import com.capillary.hydra.inbox.core.model.MediaContent
+import com.capillary.hydra.inbox.core.model.TextContent
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.google.gson.Gson
+import org.json.JSONArray
+import org.json.JSONObject
+
+fun com.capillary.hydra.pushbase.notification.model.NotificationPayload.toMap(): Map<String, Any> {
+  val payloadMap = mutableMapOf<String, Any>()
+
+  payloadMap["accountId"] = accountId
+  campaignId?.let { payloadMap["campaignId"] = it }
+  payloadMap["channelId"] = channelId
+  payloadMap["cuid"] = cuid
+  customData?.let { payloadMap["customData"] = it }
+  payloadMap["gateway"] = gateway.name
+  payloadMap["messageId"] = messageId
+  payloadMap["body"] = notificationBody.toMap()
+  notificationExpandedDetails?.toMap()?.let { payloadMap["expandableDetails"] = it }
+  payloadMap["scope"] = scope
+  senderId?.let { payloadMap["senderId"] = it }
+  payloadMap["senderSource"] = senderSource
+  variationId?.let { payloadMap["variationId"] = it }
+  payloadMap["createdAt"] = createdAt
+  return payloadMap
+}
+
+fun com.capillary.hydra.pushbase.notification.model.CTA.toMap(): Map<String, Any> {
+  val ctaMap = mutableMapOf<String, Any>()
+
+  action?.let { ctaMap["action"] = it }
+  actionText?.let { ctaMap["actionText"] = it }
+  ctaMap["type"] = type.name
+
+  return ctaMap
+}
+
+fun com.capillary.hydra.inapp.repository.model.CTA.toMap(): Map<String, Any> {
+  val ctaMap = mutableMapOf<String, Any>()
+
+  action?.let { ctaMap["action"] = it }
+  actionText?.let { ctaMap["actionText"] = it }
+  ctaMap["type"] = type.name
+
+  return ctaMap
+}
+
+fun com.capillary.hydra.pushbase.notification.model.NotificationBody.toMap(): Map<String, Any> {
+  val bodyMap = mutableMapOf<String, Any>()
+
+  cta?.toMap()?.let { bodyMap["cta"] = it }
+  image?.let { bodyMap["image"] = it }
+  bodyMap["message"] = message
+  title?.let { bodyMap["title"] = it }
+
+  return bodyMap
+}
+
+fun com.capillary.hydra.pushbase.notification.model.NotificationExpandedDetails.toMap(): Map<String, Any> {
+  val detailsMap = mutableMapOf<String, Any>()
+
+  detailsMap["ctas"] = ctas.map { it.toMap() }
+  image?.let { detailsMap["image"] = it }
+  detailsMap["message"] = message
+  detailsMap["style"] = style.name
+
+  return detailsMap
+}
+
+fun com.google.firebase.messaging.RemoteMessage.toMap(): Map<String, Any> {
+  val remoteMessageMap = mutableMapOf<String, Any>()
+  val notificationMap = mutableMapOf<String, Any>()
+
+  notification?.title?.let { notificationMap["title"] = it }
+  notification?.body?.let { notificationMap["body"] = it }
+  notification?.icon?.let { notificationMap["icon"] = it }
+  notification?.imageUrl?.let { notificationMap["imageUrl"] = it }
+
+  remoteMessageMap["data"] = data
+  remoteMessageMap["notification"] = notificationMap
+
+  return remoteMessageMap
+}
+
+fun ReadableMap.toMap(): Map<String, Any> {
+  val immutableMap = mutableMapOf<String, Any>()
+  val iterator = keySetIterator()
+  while (iterator.hasNextKey()) {
+    val key = iterator.nextKey()
+    when (getType(key)) {
+      ReadableType.Boolean -> immutableMap[key] = getBoolean(key)
+      ReadableType.Number -> immutableMap[key] = getDouble(key)
+      ReadableType.String -> immutableMap[key] = getString(key) as String
+      ReadableType.Map -> immutableMap[key] =
+        getMap(key)!!.toMap()
+
+      ReadableType.Array -> {
+        getArray(key)?.toList()
+      }
+
+      else -> { /* Handle other types if needed */
+      }
+    }
+  }
+  return immutableMap
+}
+
+fun ReadableArray.toList(): List<Any> {
+  val immutableList = mutableListOf<Any>()
+  for (i in 0 until size()) {
+    when (getType(i)) {
+      ReadableType.Boolean -> immutableList.add(getBoolean(i))
+      ReadableType.Number -> immutableList.add(getDouble(i))
+      ReadableType.String -> getString(i)?.let { immutableList.add(it) }
+      ReadableType.Map -> getMap(i)?.let { immutableList.add(it.toMap()) }
+      ReadableType.Array -> getArray(i)?.let { immutableList.add(it.toList()) }
+      else -> { /* Handle other types if needed */
+      }
+    }
+  }
+  return immutableList
+
+}
+
+fun Map<*, *>.toInboxMessage(): InboxMessage? {
+  val scope = this["scope"] as String?
+  val accountId = this["accountId"] as String?
+  val senderId = this["senderId"] as String?
+  val messageId = this["messageId"] as String?
+  val gatewayString = this["gateway"] as String?
+  val createdAt = this["createdAt"] as String?
+  val isRead = this["isRead"] == "true"
+  val payload = (this["payload"] as String?)?.let { JSONObject(it) } ?: JSONObject()
+  val validity = (this["validity"] as String?) ?: ""
+  val isExpanded = (this["isExpanded"] as Boolean?) == true
+
+  if (scope == null || accountId == null || senderId == null || messageId == null || gatewayString == null || createdAt == null) {
+    return null
+  }
+
+  val gateway = GATEWAY.valueOf(gatewayString)
+
+  var textContent: TextContent? = null
+  var action: Action? = null
+  var mediaContent: MediaContent? = null
+  val bodyMap = this["body"] as Map<*, *>?
+
+  if (bodyMap != null) {
+    val title = bodyMap["title"] as String?
+    val message = bodyMap["message"] as String?
+    textContent = TextContent(title ?: "", message ?: "")
+
+    val image = bodyMap["image"] as String?
+    if (image != null) {
+      mediaContent = MediaContent(image)
+    }
+
+    val ctaMap = bodyMap["cta"] as Map<*, *>?
+    if (ctaMap != null) {
+      val ctaAction = ctaMap["action"] as String?
+      val ctaActionType = (ctaMap["type"] as String?)?.let { CTATYPE.valueOf(it) }
+      val ctaActionText = ctaMap["actionText"] as String?
+      action = Action(ctaActionText, ctaActionType!!, ctaAction)
+    }
+  }
+
+  return InboxMessage(
+    scope,
+    accountId,
+    senderId,
+    messageId,
+    gateway,
+    textContent!!,
+    action,
+    mediaContent,
+    isRead,
+    createdAt,
+    payload,
+    validity,
+    isExpanded,
+  )
+}
+
+fun InboxMessage.toMap(): Map<String, Any> {
+  val inboxMessageMap = mutableMapOf<String, Any>()
+  inboxMessageMap["scope"] = scope
+  inboxMessageMap["accountId"] = accountId
+  inboxMessageMap["senderId"] = senderId
+  inboxMessageMap["messageId"] = messageId
+  inboxMessageMap["gateway"] = gateway.name
+
+  val bodyMap = mutableMapOf<String, Any>()
+  bodyMap["title"] = textContent.title
+  bodyMap["message"] = textContent.message
+
+  primaryAction?.toMap()?.let {
+    bodyMap["cta"] = it
+  }
+
+  mediaContent?.image?.let {
+    bodyMap["image"] = it
+  }
+
+  inboxMessageMap["body"] = bodyMap
+  inboxMessageMap["isRead"] = isRead.toString()
+  inboxMessageMap["createdAt"] = createdAt
+  inboxMessageMap["payload"] = payload.toString()
+  if (payload.has(NOTIFICATION_EXPANDED_DETAILS)) {
+    val expandedDetailsStr = payload.get(NOTIFICATION_EXPANDED_DETAILS) as String?
+    expandedDetailsStr?.let {
+      inboxMessageMap["expandableDetails"] = JSONObject(expandedDetailsStr).toMap()
+    }
+  }
+
+  inboxMessageMap["validity"] = validity
+  inboxMessageMap["isExpanded"] = isExpanded
+
+  return inboxMessageMap
+}
+
+fun CampaignPayload.toMap(): Map<String, Any> {
+  val inAppMap = mutableMapOf<String, Any>()
+  inAppMap["scope"] = scope
+  campaignId?.let { inAppMap["campaignId"] = it }
+  cuid?.let { inAppMap["cuid"] = it }
+  senderId?.let { inAppMap["senderId"] = it }
+
+  title?.let {
+    val titleMap = mutableMapOf<String, Any?>()
+    it["text"]?.let { text -> titleMap["text"] = text }
+    titleMap["style"] = getInAppStyleMap(it)
+    inAppMap["title"] = titleMap
+  }
+
+  message.let {
+    val messageMap = mutableMapOf<String, Any?>()
+    it["text"]?.let { text -> messageMap["text"] = text }
+    messageMap["style"] = getInAppStyleMap(it)
+    inAppMap["message"] = messageMap
+  }
+
+  image?.let { inAppMap["imageUrl"] = it.value }
+  inAppMap["campaignType"] = campaignType
+  eventAttribiutes?.let { inAppMap["eventAttributes"] = it }
+  inAppMap["templateType"] = templateType
+  actionButton?.let {
+    inAppMap["actionButton"] = getInAppActionButtonMap(it)
+  }
+
+  negativeActionButton.let{
+    inAppMap["negativeActionButton"] = getInAppActionButtonMap(it)
+  }
+  inAppMap["phoneBackgroundColor"] = phoneBackgroundColor
+  inAppMap["layoutBackgroundColor"] = layoutBackgroundColor
+  feedbackType?.let { inAppMap["feedbackType"] = it }
+  feedbackOptions?.let {
+    feedbackOptions?.let { optionsMap ->
+        val prefix = optionsMap.keys.firstOrNull()?.takeWhile { !it.isDigit() }
+        if (prefix != null) {
+            inAppMap["feedbackOptions"] = optionsMap.entries
+                .sortedBy { it.key.removePrefix(prefix).toIntOrNull() }
+                .map { it.value }
+        }
+    }
+  }
+  selectedColor?.let { inAppMap["ratingSelectedColor"] = it }
+  unselectedColor?.let { inAppMap["ratingUnselectedColor"] = it }
+  inAppMap["createdAt"] = createdAt
+  inAppMap["nativeJsonPayload"] = Gson().toJson(this)
+  return inAppMap
+}
+
+
+
+fun getInAppStyleMap(originalMap : Map<String, Any?>): Map<String, Any?> {
+  val styleMap = mutableMapOf<String, Any?>()
+  originalMap.forEach {
+    when (it.key) {
+      "textColor" -> styleMap["textColor"] = it.value
+      "textSize" -> styleMap["fontSize"] = it.value
+      "backgroundColor" -> styleMap["backgroundColor"] = it.value
+      "textStyle" -> styleMap["fontStyle"] = it.value
+      "textFont" -> styleMap["fontName"] = it.value
+    }
+  }
+  return styleMap
+}
+
+fun getInAppActionButtonMap(originalMap : Map<String, Any?>): Map<String, Any?> {
+  val actionButtonMap = mutableMapOf<String, Any?>()
+  originalMap.forEach {
+    when (it.key) {
+      "actionText" -> actionButtonMap["actionText"] = it.value
+      "type" -> actionButtonMap["type"] = it.value
+      "action" -> actionButtonMap["action"] = it.value
+    }
+    actionButtonMap["style"] = getInAppStyleMap(originalMap)
+  }
+  return actionButtonMap
+}
+
+fun Action.toMap(): Map<String, Any> {
+  val actionMap = mutableMapOf<String, Any>()
+  actionMap["actionText"] = actionText!!
+  actionMap["type"] = type.name
+  actionMap["action"] = action!!
+  return actionMap
+}
+
+fun JSONObject.toMap(): Map<String, Any?> =
+  keys().asSequence().associateWith { key -> toValue(get(key)) }
+
+fun JSONArray.toList(): List<Any?> =
+  (0 until length()).map { index -> toValue(get(index)) }
+
+private fun toValue(element: Any) = when (element) {
+  JSONObject.NULL -> null
+  is JSONObject -> element.toMap()
+  is JSONArray -> element.toList()
+  else -> element
+}

package/android/src/main/java/com/hydralib/hydrasdk/HydraInAppMessages.kt

@@ -0,0 +1,136 @@
+package com.hydralib.hydrasdk
+
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.capillary.hydra.inapp.database.entity.CampaignPayload
+import com.capillary.hydra.inapp.listener.OnMessageClickListener
+import com.capillary.hydra.inapp.listener.SelfHandledInAppMessageListener
+import com.capillary.hydra.inapp.utils.HydraInAppUIHelper
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.google.gson.Gson
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+object HydraInAppMessages {
+
+  private fun asInAppMessageClickListener() =
+    OnMessageClickListener { _, cta ->
+      Logger.d(
+        "HydraInAppMessages.OnMessageClickListener",
+        "received in app message click with cta = $cta"
+      )
+      val detailMap = mutableMapOf<String, Any>()
+      detailMap["cta"] = cta.toMap()
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_HYDRA_NOTIFICATION_CLICKED,
+        detailMap
+      )
+      true
+    }
+
+  private fun asSelfHandledInAppMessageListener() =
+    SelfHandledInAppMessageListener { message ->
+      Logger.d(
+        "HydraInAppMessages.SelfHandledInAppMessageListener",
+        "message details - type = ${message.templateType}, title = ${message.title?.get("text")}, message = ${message.message["text"]}"
+      )
+
+      suspendCancellableCoroutine<Boolean> { continuation ->
+        HydraEventEmitter.sendEvent(
+          HydraEventType.ON_HYDRA_IN_APP_MESSAGE,
+          message.toMap()
+        ) { result ->
+          val handled = result as? Boolean ?: false
+          continuation.resume(handled)
+          if (handled) {
+            Logger.d("HydraInAppMessages.SelfHandledInAppMessageListener", "message handled in RN")
+            HydraInAppUIHelper.getInstance()
+              .reportInAppMessageShown(HydraCore.appContext!!, message)
+          }
+
+        }
+      }
+    }
+
+  fun registerListener() {
+    HydraInAppUIHelper.getInstance().registerOnMessageClickListener(asInAppMessageClickListener())
+    HydraInAppUIHelper.getInstance()
+      .registerSelfHandledInAppMessageListener(asSelfHandledInAppMessageListener())
+    Logger.d("HydraInAppMessages.registerListener", "message click listener registered")
+  }
+
+  fun reportMessageClicked(
+    message: ReadableMap?,
+    promise: Promise?
+  ) {
+
+    message?.let {
+      val messageMap = message.toMap()
+      messageMap["nativeJsonPayload"]?.let {
+        val jsonString = Gson().toJson(it)
+        val payloadFromJson = Gson().fromJson(jsonString, CampaignPayload::class.java)
+        HydraInAppUIHelper.getInstance()
+          .reportInAppMessageIsClicked(HydraCore.appContext!!, payloadFromJson)
+        promise?.resolve(true)
+      }
+    }
+  }
+
+  fun reportMessageDismissed(
+    message: ReadableMap?,
+    promise: Promise?
+  ) {
+    message?.let {
+      val messageMap = message.toMap()
+      messageMap["nativeJsonPayload"]?.let {
+        val jsonString = Gson().toJson(it)
+        val payloadFromJson = Gson().fromJson(jsonString, CampaignPayload::class.java)
+        HydraInAppUIHelper.getInstance()
+          .reportInAppMessageDismissed(HydraCore.appContext!!, payloadFromJson)
+        promise?.resolve(true)
+      }
+    }
+  }
+
+  fun reportMessageRating(
+    message: ReadableMap?,
+    rating: Double,
+    promise: Promise?
+  ) {
+    message?.let {
+      val messageMap = message.toMap()
+      messageMap["nativeJsonPayload"]?.let {
+        val jsonString = Gson().toJson(it)
+        val payloadFromJson = Gson().fromJson(jsonString, CampaignPayload::class.java)
+        HydraInAppUIHelper.getInstance()
+          .reportInAppMessageRating(HydraCore.appContext!!, payloadFromJson, rating.toInt())
+        promise?.resolve(true)
+      }
+    }
+  }
+
+  fun reportMessageFeedback(
+    message: ReadableMap?,
+    feedback: String?,
+    feedbackOptions: ReadableArray?,
+    promise: Promise?
+  ) {
+    message?.let {
+      val messageMap = message.toMap()
+      messageMap["nativeJsonPayload"]?.let {
+        val jsonString = Gson().toJson(it)
+        val payloadFromJson = Gson().fromJson(jsonString, CampaignPayload::class.java)
+        val feedbackOptionsList = feedbackOptions?.toList()?.mapNotNull { option -> option as? Int } ?: listOf()
+        HydraInAppUIHelper.getInstance().reportInAppMessageFeedback(
+          HydraCore.appContext!!,
+          payloadFromJson,
+          feedbackOptionsList
+        )
+        promise?.resolve(true)
+      }
+    }
+  }
+}

package/android/src/main/java/com/hydralib/hydrasdk/HydraInbox.kt

@@ -0,0 +1,70 @@
+package com.hydralib.hydrasdk
+
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.capillary.hydra.inbox.core.HydraInboxCoreApi
+import com.capillary.hydra.inbox.core.listener.OnMessagesAvailableListener
+import com.capillary.hydra.inbox.core.listener.UnReadCountListener
+import com.facebook.react.bridge.Arguments
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+
+object HydraInbox {
+  fun getInboxMessages(promise: Promise?) {
+    val listener = OnMessagesAvailableListener { inboxMessages ->
+      Logger.d("HydraInbox.getInboxMessages", "got ${inboxMessages.size} messages")
+      val processedList: WritableArray = Arguments.createArray()
+      inboxMessages.forEach {
+        processedList.pushMap(Arguments.makeNativeMap(it.toMap()))
+      }
+      Logger.d("HydraInbox.getInboxMessages", "resolving promise with processedList = $processedList")
+      promise?.resolve(processedList)
+    }
+    Logger.d("HydraInbox.getInboxMessages", "fetching inbox messages")
+    HydraInboxCoreApi.getInstance().fetchInboxMessages(HydraCore.appContext!!, listener)
+  }
+
+  fun getUnreadInboxMessagesCount(promise: Promise?) {
+    val listener = UnReadCountListener {
+      Logger.d("HydraInbox.getUnreadInboxMessagesCount", "Received unread message count is $it")
+      promise?.resolve(it)
+    }
+    Logger.d("HydraInbox.getUnreadInboxMessagesCount", "getting unread message count")
+    HydraInboxCoreApi.getInstance().getUnReadMessagesCount(HydraCore.appContext!!, listener)
+  }
+
+  fun markInboxMessageAsRead(inboxMessage: ReadableMap?, promise: Promise?) {
+    Logger.d("HydraInbox.markInboxMessageAsRead", "marking inboxMessage as read, input message = $inboxMessage")
+    inboxMessage?.toMap()?.toInboxMessage()?.let {
+      HydraInboxCoreApi.getInstance()
+        .trackInboxMessageClick(HydraCore.appContext!!, it)
+      promise?.resolve(true)
+      Logger.d("HydraInbox.markInboxMessageAsRead", "Inbox message marked read successfully")
+      return
+    }
+    Logger.d("HydraInbox.markInboxMessageAsRead", "Invalid inbox message details")
+    promise?.resolve(false)
+  }
+
+  fun deleteInboxMessage(inboxMessage: ReadableMap?, promise: Promise?) {
+    Logger.d("HydraInbox.deleteInboxMessage", "Deleting inbox message, input message = $inboxMessage")
+    inboxMessage?.toMap()?.toInboxMessage()?.let {
+      HydraInboxCoreApi.getInstance()
+        .deleteInboxMessage(HydraCore.appContext!!, it)
+      promise?.resolve(true)
+      Logger.d("HydraInbox.deleteInboxMessage", "Inbox message deleted successfully")
+      return
+    }
+    Logger.d("HydraInbox.deleteInboxMessage", "Invalid inbox message details")
+    promise?.resolve(false)
+  }
+
+  fun deleteAllInboxMessages(promise: Promise?) {
+    Logger.d("HydraInbox.deleteAllInboxMessages", "Deleting all inbox messages")
+    HydraInboxCoreApi.getInstance().deleteAllInboxMessages(HydraCore.appContext!!)
+    Logger.d("HydraInbox.deleteAllInboxMessages", "All Inbox messages deleted successfully")
+    promise?.resolve(true)
+  }
+
+}

package/android/src/main/java/com/hydralib/hydrasdk/HydraInboxUI.kt

@@ -0,0 +1,54 @@
+package com.hydralib.hydrasdk
+
+import android.content.Context
+import android.content.Intent
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.capillary.hydra.inbox.core.model.Action
+import com.capillary.hydra.inbox.ui.HydraInboxUIHelper
+import com.capillary.hydra.inbox.ui.listener.OnMessageClickListener
+import com.capillary.hydra.inbox.ui.view.InboxActivity
+import com.facebook.react.bridge.Promise
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+import java.util.Timer
+import kotlin.concurrent.schedule
+
+object HydraInboxUI {
+  var curInboxActivity : InboxActivity? = null
+  private fun asInboxMessageClickListener() =
+    OnMessageClickListener { _: Context, action: Action ->
+      val detailMap = mutableMapOf<String, Any>()
+      Logger.d("HydraInboxUI.OnMessageClickListener", "received message click with action = $action")
+      detailMap["cta"] = action.toMap()
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_HYDRA_NOTIFICATION_CLICKED,
+        detailMap
+      )
+      true
+    }
+
+  fun registerListener() {
+    HydraInboxUIHelper.getInstance().registerOnMessageClickListener(asInboxMessageClickListener())
+    Logger.d("HydraInboxUI.registerListener", "Registered Click listener successfully")
+  }
+
+  fun showNotificationCenter(promise: Promise?) {
+    Logger.d("HydraInboxUI.showNotificationCenter", "Starting InboxActivity")
+    val inboxActivity = Intent(HydraCore.appContext!!, InboxActivity::class.java)
+    inboxActivity.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    HydraCore.appContext!!.startActivity( inboxActivity, null)
+    Logger.d("HydraInboxUI.showNotificationCenter", "InboxActivity started successfully")
+    promise?.resolve(true)
+  }
+
+  fun hideNotificationCenterIfShowing(promise: Promise?){
+    curInboxActivity?.let {
+      curInboxActivity!!.finish()
+      Timer().schedule(30){
+        promise?.resolve(true)
+      }
+      return
+    }
+    promise?.resolve(true)
+  }
+}