react-native-netmera 1.11.3 → 2.0.0-alpha01

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraPackage.kt

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

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraPushBroadcastReceiver.kt

@@ -0,0 +1,81 @@
+package com.netmera.reactnativesdk
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.netmera.NetmeraCarouselObject
+import com.netmera.NetmeraPushObject
+import com.netmera.callbacks.NMPushActionCallbacks
+import com.netmera.reactnativesdk.RNNetmeraPushHeadlessService.Companion.TASK_KEY
+import com.netmera.reactnativesdk.RNNetmeraPushHeadlessService.Companion.TASK_MESSAGE
+
+class RNNetmeraPushBroadcastReceiver : NMPushActionCallbacks {
+
+  override fun onPushRegister(context: Context, gcmSenderId: String, pushToken: String) {
+    val bundle = Bundle().apply {
+      putString("gcmSenderId", gcmSenderId)
+      putString("pushToken", pushToken)
+    }
+    sendEvent(context, "onPushRegister", Arguments.fromBundle(bundle))
+  }
+
+  override fun onPushReceive(context: Context, bundle: Bundle?, netmeraPushObject: NetmeraPushObject) {
+    sendEvent(context, "onPushReceive", mergeMap(bundle, netmeraPushObject))
+  }
+
+  override fun onPushOpen(context: Context, bundle: Bundle?, netmeraPushObject: NetmeraPushObject) {
+    sendEvent(context, "onPushOpen", mergeMap(bundle, netmeraPushObject))
+  }
+
+  override fun onPushDismiss(context: Context, bundle: Bundle?, netmeraPushObject: NetmeraPushObject) {
+    sendEvent(context, "onPushDismiss", mergeMap(bundle, netmeraPushObject))
+  }
+
+  override fun onPushButtonClicked(context: Context, bundle: Bundle?, netmeraPushObject: NetmeraPushObject) {
+    sendEvent(context, "onPushButtonClicked", mergeMap(bundle, netmeraPushObject))
+  }
+
+  override fun onCarouselObjectSelected(
+    context: Context,
+    bundle: Bundle?,
+    netmeraPushObject: NetmeraPushObject,
+    selectedIndex: Int,
+    netmeraCarouselObject: NetmeraCarouselObject
+  ) {
+    val newBundle = bundle ?: Bundle()
+    newBundle.putInt("selectedIndex", selectedIndex)
+    val map = RNNetmeraUtil.mapCarouselObject(netmeraCarouselObject)
+    map.merge(mergeMap(newBundle, netmeraPushObject))
+    sendEvent(context, "onCarouselObjectSelected", map)
+  }
+
+  private fun sendEvent(context: Context, eventName: String, map: WritableMap) {
+    try {
+      val backgroundIntent = Intent(context, RNNetmeraPushHeadlessService::class.java).apply {
+        putExtra(TASK_KEY, eventName)
+        putExtra(TASK_MESSAGE, Arguments.toBundle(map))
+      }
+      val ag = Arguments.toBundle(map)
+      val name: ComponentName? = context.startService(backgroundIntent)
+      if (name != null) {
+        HeadlessJsTaskService.acquireWakeLockNow(context)
+      }
+    } catch (ex: IllegalStateException) {
+      Log.d("RNNetmera Background", "RNNetmera Background Event Exception")
+    }
+  }
+
+  private fun mergeMap(bundle: Bundle?, netmeraPushObject: NetmeraPushObject): WritableMap {
+    val mapPushObject = RNNetmeraUtil.mapPushObject(netmeraPushObject)
+    val mapBundle: ReadableMap? = bundle?.let { Arguments.fromBundle(it) }
+    mapBundle?.let { mapPushObject.merge(it) }
+    return mapPushObject
+  }
+
+}

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraPushHeadlessService.kt

@@ -0,0 +1,32 @@
+package com.netmera.reactnativesdk
+
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+
+class RNNetmeraPushHeadlessService : HeadlessJsTaskService() {
+
+  companion object {
+    private const val TIMEOUT_DEFAULT: Long = 5000
+    const val TASK_KEY = "TASK_KEY"
+    const val TASK_MESSAGE = "TASK_MESSAGE"
+  }
+
+  override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? {
+    if (intent == null) return null
+    val extras = intent.extras
+    val remoteMessage: Bundle? = intent.getParcelableExtra(TASK_MESSAGE)
+    val taskKey = extras?.getString(TASK_KEY)
+    if (extras == null || taskKey == null) return null
+
+    return HeadlessJsTaskConfig(
+      taskKey,
+      Arguments.fromBundle(remoteMessage ?: Bundle()),
+      TIMEOUT_DEFAULT,
+      true
+    )
+  }
+}

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraUtil.kt

@@ -0,0 +1,218 @@
+package com.netmera.reactnativesdk
+
+import android.text.format.DateFormat
+import com.facebook.react.bridge.*
+import com.google.gson.Gson
+import com.netmera.NetmeraCarouselObject
+import com.netmera.NetmeraPushObject
+import com.netmera.NetmeraPushStyle
+import com.netmera.data.NMCategoryPreference
+import com.netmera.data.NMCouponDetail
+import com.netmera.data.NMInboxStatus
+import com.netmera.data.NMInboxStatusCount
+import org.json.JSONArray
+import org.json.JSONObject
+
+object RNNetmeraUtil {
+
+  private fun jsonToWritableMap(jsonObject: JSONObject?): WritableMap? {
+    if (jsonObject == null) return null
+
+    val writableMap: WritableMap = WritableNativeMap()
+    val keys = jsonObject.keys()
+    if (!keys.hasNext()) return null
+
+    while (keys.hasNext()) {
+      val key = keys.next()
+      try {
+        val value = jsonObject.get(key)
+        when (value) {
+          null -> writableMap.putNull(key)
+          is Boolean -> writableMap.putBoolean(key, value)
+          is Int -> writableMap.putInt(key, value)
+          is Double -> writableMap.putDouble(key, value)
+          is String -> writableMap.putString(key, value)
+          is JSONObject -> writableMap.putMap(key, jsonToWritableMap(value))
+          is JSONArray -> writableMap.putArray(key, jsonArrayToWritableArray(value))
+        }
+      } catch (ignored: Exception) {
+      }
+    }
+    return writableMap
+  }
+
+  fun jsonArrayToWritableArray(jsonArray: JSONArray?): WritableArray? {
+    if (jsonArray == null || jsonArray.length() <= 0) return null
+    val writableArray: WritableArray = WritableNativeArray()
+    for (i in 0 until jsonArray.length()) {
+      try {
+        val value = jsonArray.get(i)
+        when (value) {
+          null -> writableArray.pushNull()
+          is Boolean -> writableArray.pushBoolean(value)
+          is Int -> writableArray.pushInt(value)
+          is Double -> writableArray.pushDouble(value)
+          is String -> writableArray.pushString(value)
+          is JSONObject -> writableArray.pushMap(jsonToWritableMap(value))
+          is JSONArray -> writableArray.pushArray(jsonArrayToWritableArray(value))
+        }
+      } catch (ignored: Exception) {
+      }
+    }
+    return writableArray
+  }
+
+  fun toMap(readableMap: ReadableMap?): Map<String, Any?> {
+    val map = mutableMapOf<String, Any?>()
+    if (readableMap == null) return map
+
+    val iterator = readableMap.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (readableMap.getType(key)) {
+        ReadableType.Null -> map[key] = null
+        ReadableType.Boolean -> map[key] = readableMap.getBoolean(key)
+        ReadableType.Number -> {
+          val value = readableMap.getDouble(key)
+          map[key] = if (value % 1 == 0.0) value.toLong() else value
+        }
+        ReadableType.String -> map[key] = readableMap.getString(key)
+        ReadableType.Map -> map[key] = toMap(readableMap.getMap(key))
+        ReadableType.Array -> map[key] = toList(readableMap.getArray(key))
+      }
+    }
+    return map
+  }
+
+  fun toList(readableArray: ReadableArray?): List<Any?> {
+    if (readableArray == null) return emptyList()
+
+    val list = mutableListOf<Any?>()
+    for (i in 0 until readableArray.size()) {
+      when (readableArray.getType(i)) {
+        ReadableType.Null -> list.add(null)
+        ReadableType.Boolean -> list.add(readableArray.getBoolean(i))
+        ReadableType.Number -> {
+          val value = readableArray.getDouble(i)
+          list.add(if (value % 1 == 0.0) value.toLong() else value)
+        }
+        ReadableType.String -> list.add(readableArray.getString(i))
+        ReadableType.Map -> list.add(toMap(readableArray.getMap(i)))
+        ReadableType.Array -> list.add(toList(readableArray.getArray(i)))
+      }
+    }
+    return list
+  }
+
+  fun mapCouponObjects(couponObjects: List<NMCouponDetail>): WritableArray {
+    val array: WritableArray = Arguments.createArray()
+    couponObjects.forEach { array.pushMap(mapCouponObject(it)) }
+    return array
+  }
+
+  fun mapCouponObject(couponObject: NMCouponDetail?): WritableMap {
+    val map: WritableMap = Arguments.createMap()
+    if (couponObject == null) return map
+    map.putString("couponId", couponObject.couponId)
+    map.putString("name", couponObject.name)
+    map.putString("code", couponObject.code)
+    couponObject.assignDate?.let { map.putString("assignDate", it.toString()) }
+    couponObject.expireDate?.let { map.putString("expireDate", it.toString()) }
+    return map
+  }
+
+  fun mapPushObjects(pushObjects: List<NetmeraPushObject>): WritableArray {
+    val array: WritableArray = Arguments.createArray()
+    pushObjects.forEach { array.pushMap(mapPushObject(it)) }
+    return array
+  }
+
+  fun mapPushObject(pushObject: NetmeraPushObject?): WritableMap {
+    val map: WritableMap = Arguments.createMap()
+    if (pushObject == null) return map
+
+    map.putInt("pushType", pushObject.pushType)
+    map.putString("pushId", pushObject.pushId)
+    map.putString("pushInstanceId", pushObject.pushInstanceId)
+    map.putInt("inboxStatus", pushObject.inboxStatus)
+    map.putString("category", pushObject.category)
+
+    pushObject.deepLink?.let { map.putString("deepLink", it.toString()) }
+    pushObject.externalId?.let { map.putString("externalId", it) }
+    pushObject.categories?.let { map.putArray("categories", Arguments.fromList(it)) }
+
+    if (!pushObject.customJson.isJsonNull && pushObject.customJson.size() > 0) {
+      try {
+        val json = JSONObject(pushObject.customJson.toString())
+        map.putMap("customJson", jsonToWritableMap(json))
+      } catch (ignored: Throwable) {
+      }
+    }
+
+    pushObject.popupExpirationTime?.let {
+      map.putString("expireTime", DateFormat.format("yyyy-MM-dd HH:mm:ss", it).toString())
+    }
+
+    pushObject.interactiveActions?.let {
+      if (it.isNotEmpty()) map.putString("interactiveActions", Gson().toJson(it))
+    }
+
+    pushObject.pushStyle?.let { style ->
+      style.contentTitle?.let { map.putString("title", it) }
+      style.subText?.let { map.putString("subtitle", it) }
+      style.contentText?.let { map.putString("body", it) }
+      style.bigPicturePath?.let { map.putString("mediaAttachmentURL", it) }
+      style.retrieveCarouselObjects()?.let { map.putString("carousel", Gson().toJson(it)) }
+    }
+
+    pushObject.sendDate?.let {
+      map.putString(
+        "sendDate", DateFormat.format("yyyy-MM-dd HH:mm:ss", it).toString()
+      )
+    }
+    pushObject.pushAction?.let {
+      map.putString("pushAction", Gson().toJson(it))
+      pushObject.webPageUrl?.let { url -> map.putString("webPage", url) }
+    }
+
+    return map
+  }
+
+  fun mapCarouselObject(carouselObject: NetmeraCarouselObject): WritableMap {
+    val map: WritableMap = Arguments.createMap()
+    map.putString("id", carouselObject.id)
+    map.putString("action", Gson().toJson(carouselObject.action))
+    map.putString("picturePath", carouselObject.picturePath)
+    return map
+  }
+
+  fun getInboxStatus(code: Int): NMInboxStatus {
+    return NMInboxStatus.values().find { it.code == code } ?: NMInboxStatus.STATUS_ALL
+  }
+
+  fun parseInboxCountForStatusToMap(nmInboxStatusCount: NMInboxStatusCount): WritableMap {
+    val map: WritableMap = Arguments.createMap()
+    val allCount = nmInboxStatusCount.getCountForStatus(NMInboxStatus.STATUS_ALL) ?: 0
+    val deletedCount = nmInboxStatusCount.getCountForStatus(NMInboxStatus.STATUS_DELETED) ?: 0
+    val readCount = nmInboxStatusCount.getCountForStatus(NMInboxStatus.STATUS_READ) ?: 0
+    val unreadCount = nmInboxStatusCount.getCountForStatus(NMInboxStatus.STATUS_UNREAD) ?: 0
+    map.putInt(NMInboxStatus.STATUS_ALL.code.toString(), allCount)
+    map.putInt(NMInboxStatus.STATUS_DELETED.code.toString(), deletedCount)
+    map.putInt(NMInboxStatus.STATUS_READ.code.toString(), readCount)
+    map.putInt(NMInboxStatus.STATUS_UNREAD.code.toString(), unreadCount)
+    return map
+  }
+
+  fun parseUserCategoryPreferenceListToMap(preferences: List<NMCategoryPreference>): WritableArray {
+    val array: WritableArray = Arguments.createArray()
+    preferences.forEach { pref ->
+      val map: WritableMap = Arguments.createMap()
+      pref.categoryId?.let { map.putInt("categoryId", it) }
+      map.putString("categoryName", pref.categoryName)
+      pref.optInStatus?.let { map.putBoolean("optInStatus", it) }
+      array.pushMap(map)
+    }
+    return array
+  }
+
+}

package/android/src/main/java/com/netmera/reactnativesdk/RNNetmeraWebWidgetCallbacks.kt

@@ -0,0 +1,25 @@
+package com.netmera.reactnativesdk
+
+import com.netmera.callbacks.NMWebWidgetCallbacks
+
+class RNNetmeraWebWidgetCallbacks : NMWebWidgetCallbacks {
+  companion object {
+    private const val ON_WIDGET_URL_TRIGGERED = "onWidgetUrlTriggered"
+  }
+
+  override fun onDeeplinkTriggered(s: String) {
+    RNNetmeraModule.emitEvent(ON_WIDGET_URL_TRIGGERED, s)
+  }
+
+  override fun onOpenUrlTriggered(s: String) {
+    RNNetmeraModule.emitEvent(ON_WIDGET_URL_TRIGGERED, s)
+  }
+
+  override fun onWebWidgetShown(s: String) {
+    // There is no equivalent for this feature in iOS
+  }
+
+  override fun onWebWidgetDismiss(s: String) {
+    // There is no equivalent for this feature in iOS
+  }
+}

package/ios/AnyCodable/AnyCodable.swift

@@ -0,0 +1,151 @@
+//
+//  AnyCodable.swift
+//
+
+import Foundation
+/**
+ A type-erased `Codable` value.
+
+ The `AnyCodable` type forwards encoding and decoding responsibilities
+ to an underlying value, hiding its specific underlying type.
+
+ You can encode or decode mixed-type values in dictionaries
+ and other collections that require `Encodable` or `Decodable` conformance
+ by declaring their contained type to be `AnyCodable`.
+
+ - SeeAlso: `AnyEncodable`
+ - SeeAlso: `AnyDecodable`
+ */
+@frozen public struct AnyCodable: Codable {
+    public let value: Any
+
+    public init<T>(_ value: T?) {
+        self.value = value ?? ()
+    }
+}
+
+extension AnyCodable: _AnyEncodable, _AnyDecodable {}
+
+extension AnyCodable: Equatable {
+    public static func == (lhs: AnyCodable, rhs: AnyCodable) -> Bool {
+        switch (lhs.value, rhs.value) {
+        case is (Void, Void):
+            return true
+        case let (lhs as Bool, rhs as Bool):
+            return lhs == rhs
+        case let (lhs as Int, rhs as Int):
+            return lhs == rhs
+        case let (lhs as Int8, rhs as Int8):
+            return lhs == rhs
+        case let (lhs as Int16, rhs as Int16):
+            return lhs == rhs
+        case let (lhs as Int32, rhs as Int32):
+            return lhs == rhs
+        case let (lhs as Int64, rhs as Int64):
+            return lhs == rhs
+        case let (lhs as UInt, rhs as UInt):
+            return lhs == rhs
+        case let (lhs as UInt8, rhs as UInt8):
+            return lhs == rhs
+        case let (lhs as UInt16, rhs as UInt16):
+            return lhs == rhs
+        case let (lhs as UInt32, rhs as UInt32):
+            return lhs == rhs
+        case let (lhs as UInt64, rhs as UInt64):
+            return lhs == rhs
+        case let (lhs as Float, rhs as Float):
+            return lhs == rhs
+        case let (lhs as Double, rhs as Double):
+            return lhs == rhs
+        case let (lhs as String, rhs as String):
+            return lhs == rhs
+        case let (lhs as [String: AnyCodable], rhs as [String: AnyCodable]):
+            return lhs == rhs
+        case let (lhs as [AnyCodable], rhs as [AnyCodable]):
+            return lhs == rhs
+        case let (lhs as [String: Any], rhs as [String: Any]):
+            return NSDictionary(dictionary: lhs) == NSDictionary(dictionary: rhs)
+        case let (lhs as [Any], rhs as [Any]):
+            return NSArray(array: lhs) == NSArray(array: rhs)
+        case is (NSNull, NSNull):
+            return true
+        default:
+            return false
+        }
+    }
+}
+
+extension AnyCodable: CustomStringConvertible {
+    public var description: String {
+        switch value {
+        case is Void:
+            return String(describing: nil as Any?)
+        case let value as CustomStringConvertible:
+            return value.description
+        default:
+            return String(describing: value)
+        }
+    }
+}
+
+extension AnyCodable: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        switch value {
+        case let value as CustomDebugStringConvertible:
+            return "AnyCodable(\(value.debugDescription))"
+        default:
+            return "AnyCodable(\(description))"
+        }
+    }
+}
+
+extension AnyCodable: ExpressibleByNilLiteral {}
+extension AnyCodable: ExpressibleByBooleanLiteral {}
+extension AnyCodable: ExpressibleByIntegerLiteral {}
+extension AnyCodable: ExpressibleByFloatLiteral {}
+extension AnyCodable: ExpressibleByStringLiteral {}
+extension AnyCodable: ExpressibleByStringInterpolation {}
+extension AnyCodable: ExpressibleByArrayLiteral {}
+extension AnyCodable: ExpressibleByDictionaryLiteral {}
+
+
+extension AnyCodable: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        switch value {
+        case let value as Bool:
+            hasher.combine(value)
+        case let value as Int:
+            hasher.combine(value)
+        case let value as Int8:
+            hasher.combine(value)
+        case let value as Int16:
+            hasher.combine(value)
+        case let value as Int32:
+            hasher.combine(value)
+        case let value as Int64:
+            hasher.combine(value)
+        case let value as UInt:
+            hasher.combine(value)
+        case let value as UInt8:
+            hasher.combine(value)
+        case let value as UInt16:
+            hasher.combine(value)
+        case let value as UInt32:
+            hasher.combine(value)
+        case let value as UInt64:
+            hasher.combine(value)
+        case let value as Float:
+            hasher.combine(value)
+        case let value as Double:
+            hasher.combine(value)
+        case let value as String:
+            hasher.combine(value)
+        case let value as [String: AnyCodable]:
+            hasher.combine(value)
+        case let value as [AnyCodable]:
+            hasher.combine(value)
+        default:
+            break
+        }
+    }
+}