@dashx/react-native 1.3.0 → 1.3.2

package/android/src/main/java/com/dashx/rn/sdk/DashXReactNativeModuleImpl.kt

@@ -17,20 +17,28 @@ import com.dashx.android.data.Asset
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.encodeToJsonElement
+import kotlinx.serialization.json.jsonObject
 
 class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationContext) {
     private val tag = DashXReactNativeModuleImpl::class.java.simpleName
 
+    // Bridges SDK notification-click callbacks to the JS
+    // `DashX.onNotificationClicked` listener. Registered in `initialize`,
+    // removed in `invalidate` so we don't leak across RN reloads.
+    private val notificationClickedListener = DashXNotificationClickedListener(reactContext)
+
     fun initialize() {
         MessageReceivedEventHolder.reactContext = reactContext
+        DashX.registerNotificationListener(notificationClickedListener)
     }
 
     fun invalidate() {
         MessageReceivedEventHolder.reactContext = null
+        DashX.unregisterNotificationListener(notificationClickedListener)
     }
 
     fun setLogLevel(level: Double) {
@@ -148,14 +156,14 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
                 promise.reject(E_UNSPECIFIED, it.message)
             },
             onSuccess = {
-                promise.resolve(convertJsonToMap(convertKJsonToJson(it)))
+                promise.resolve(convertJsonToMap(it))
             }
         )
     }
 
     fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) {
         val jsonFilter = try {
-            convertMapToJson(options?.getMap("filter"))?.let { convertJsonToKJson(it) }
+            convertMapToJson(options?.getMap("filter"))
         } catch (e: Exception) {
             DashXLog.d(tag, e.message)
             promise.reject(E_UNSPECIFIED, "Error parsing filter: ${e.message}")
@@ -209,7 +217,7 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
             onSuccess = { records ->
                 val readableArray = Arguments.createArray()
                 records.forEach {
-                    readableArray.pushMap(convertJsonToMap(convertKJsonToJson(it)))
+                    readableArray.pushMap(convertJsonToMap(it))
                 }
                 promise.resolve(readableArray)
             }
@@ -221,22 +229,32 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
             onError = {
                 promise.reject(E_UNSPECIFIED, it.message)
             },
+            // The SDK hands back a typed wrapper whose `preferenceData`
+            // field is the raw kotlinx `JsonObject`. Unwrap and flatten so
+            // the JS side receives the prefs directly — matches how the iOS
+            // bridge resolves `DashXClient.fetchStoredPreferences`.
             onSuccess = { content ->
-                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+                promise.resolve(convertJsonToMap(content.preferenceData))
             }
         )
     }
 
     fun saveStoredPreferences(preferenceData: ReadableMap?, promise: Promise) {
-        val preferencesString = MapUtil.toJSONElement(preferenceData).toString()
+        // A null/empty payload maps to an empty JSON object — matches the
+        // SDK's "I received preferences but they're empty" contract and
+        // replaces a pre-migration NPE path that crashed when the caller
+        // passed `null`.
+        val preferencesJson = convertMapToJson(preferenceData) ?: buildJsonObject { }
 
         DashX.saveStoredPreferences(
-            Json.decodeFromString<JsonObject>(preferencesString),
+            preferencesJson,
             onError = {
                 promise.reject(E_UNSPECIFIED, it.message)
             },
+            // Mutation response is just `{ success: Boolean }` — resolve the
+            // Promise with that Boolean, matching what the iOS bridge does.
             onSuccess = { content ->
-                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+                promise.resolve(content.success)
             }
         )
     }
@@ -275,9 +293,9 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
             attribute = attribute,
             onSuccess = { asset ->
                 try {
-                    val jsonString = Json.encodeToString(asset)
-                    val jsonObject = org.json.JSONObject(jsonString)
-                    promise.resolve(convertJsonToMap(jsonObject))
+                    // `Asset` is `@Serializable` — go straight to a
+                    // `JsonElement` tree without the string + parser hop.
+                    promise.resolve(convertJsonToMap(Json.encodeToJsonElement(asset).jsonObject))
                 } catch (e: Exception) {
                     promise.resolve(null)
                 }
@@ -293,9 +311,7 @@ class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationConte
             assetId = assetId,
             onSuccess = { asset ->
                 try {
-                    val jsonString = Json.encodeToString(asset)
-                    val jsonObject = org.json.JSONObject(jsonString)
-                    promise.resolve(convertJsonToMap(jsonObject))
+                    promise.resolve(convertJsonToMap(Json.encodeToJsonElement(asset).jsonObject))
                 } catch (e: Exception) {
                     promise.resolve(null)
                 }

package/android/src/main/java/com/dashx/rn/sdk/util/Utils.kt

@@ -3,85 +3,173 @@
 package com.dashx.rn.sdk.util
 
 import com.facebook.react.bridge.*
-import com.google.gson.Gson
-import com.google.gson.JsonArray
-import com.google.gson.JsonObject
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonObject as KJsonObject
-import org.json.JSONException
-import kotlinx.serialization.decodeFromString
-
-fun convertKJsonToJson(kotlinxJsonObject: KJsonObject): JsonObject {
-    val jsonString = Json.encodeToString(kotlinxJsonObject)
-    return Gson().fromJson(jsonString, JsonObject::class.java)
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.add
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.put
+
+// JSON conversion helpers between React Native's ReadableMap/ReadableArray/
+// WritableMap/WritableArray types and kotlinx.serialization's JsonObject/
+// JsonArray. Kept kotlinx-only on purpose — the DashX Android SDK uses
+// kotlinx-serialization end-to-end (see `mapScalar("JSON", "kotlinx...JsonObject")`
+// in dashx-android/dashx/build.gradle), so threading a single JSON library
+// through the bridge avoids string round-trips and the type-confusion class
+// of bugs that arose when Gson/org.json/kotlinx all coexisted.
+
+/**
+ * Factory seam for Writable instances. Production defaults to the JNI-backed
+ * `WritableNativeMap` / `WritableNativeArray`. JVM unit tests swap these to
+ * `JavaOnlyMap` / `JavaOnlyArray` (pure-Java, no JNI) — the native writables
+ * crash in a plain JUnit harness because their constructors call into
+ * `initHybrid()`. `internal` visibility keeps the seam invisible to SDK
+ * consumers.
+ */
+internal object WritableFactory {
+    var createMap: () -> WritableMap = { WritableNativeMap() }
+    var createArray: () -> WritableArray = { WritableNativeArray() }
 }
 
-fun convertJsonToKJson(jsonObject: JsonObject?): KJsonObject? {
-    if (jsonObject == null) {
-        return null
+/**
+ * Convert a [ReadableMap] (RN → native boundary) into a kotlinx [JsonObject].
+ * Returns `null` when [readableMap] is null, so callers can distinguish
+ * "absent" from "empty".
+ *
+ * Numbers are coerced to [Double] on purpose — RN has a single JS `Number`
+ * type and the DashX backend's JSON scalars are agnostic to int/double.
+ */
+fun convertMapToJson(readableMap: ReadableMap?): JsonObject? {
+    val iterator = readableMap?.keySetIterator() ?: return null
+    return buildJsonObject {
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            when (readableMap.getType(key)) {
+                ReadableType.Null -> put(key, JsonNull)
+                ReadableType.Boolean -> put(key, readableMap.getBoolean(key))
+                ReadableType.Number -> put(key, readableMap.getDouble(key))
+                ReadableType.String -> put(key, readableMap.getString(key))
+                ReadableType.Map -> put(key, convertMapToJson(readableMap.getMap(key)) ?: JsonNull)
+                ReadableType.Array -> put(key, convertArrayToJson(readableMap.getArray(key)) ?: JsonNull)
+            }
+        }
     }
+}
 
-    val jsonString = jsonObject.toString()
-    return Json.decodeFromString(jsonString)
+/**
+ * Convert a [ReadableArray] into a kotlinx [JsonArray]. Mirrors
+ * [convertMapToJson] — null in, null out.
+ */
+fun convertArrayToJson(readableArray: ReadableArray?): JsonArray? {
+    if (readableArray == null) return null
+    return buildJsonArray {
+        for (i in 0 until readableArray.size()) {
+            when (readableArray.getType(i)) {
+                ReadableType.Null -> add(JsonNull)
+                ReadableType.Boolean -> add(readableArray.getBoolean(i))
+                ReadableType.Number -> add(readableArray.getDouble(i))
+                ReadableType.String -> add(readableArray.getString(i))
+                ReadableType.Map -> add(convertMapToJson(readableArray.getMap(i)) ?: JsonNull)
+                ReadableType.Array -> add(convertArrayToJson(readableArray.getArray(i)) ?: JsonNull)
+            }
+        }
+    }
 }
 
 /**
- * Converts a ReadableArray of maps to a list of kotlinx JsonObjects for DashX.searchRecords options (order, fields, include, exclude).
+ * Convert a [ReadableArray] of maps into a list of [JsonObject]s. Used for
+ * the `fields` / `include` / `exclude` / `order` option arrays on
+ * `fetchRecord` / `searchRecords`. Non-map entries are silently dropped to
+ * preserve the behaviour of the pre-migration helper.
  */
-@Throws(JSONException::class)
-fun convertReadableArrayToKJsonList(readableArray: ReadableArray?): List<KJsonObject>? {
+fun convertReadableArrayToKJsonList(readableArray: ReadableArray?): List<JsonObject>? {
     if (readableArray == null || readableArray.size() == 0) return null
     return (0 until readableArray.size()).mapNotNull { i ->
-        when (readableArray.getType(i)) {
-            ReadableType.Map -> readableArray.getMap(i)?.let { convertMapToJson(it)?.let { gson -> convertJsonToKJson(gson) } }
-            else -> null
+        if (readableArray.getType(i) == ReadableType.Map) {
+            readableArray.getMap(i)?.let { convertMapToJson(it) }
+        } else {
+            null
         }
     }.ifEmpty { null }
 }
 
-@Throws(JSONException::class)
-fun convertMapToJson(readableMap: ReadableMap?): JsonObject? {
-    val iterator = readableMap?.keySetIterator() ?: return null
-    val jsonObject = JsonObject()
-    while (iterator.hasNextKey()) {
-        val key = iterator.nextKey()
-        when (readableMap.getType(key)) {
-            ReadableType.Null -> jsonObject.add(key, null)
-            ReadableType.Boolean -> jsonObject.addProperty(key, readableMap.getBoolean(key))
-            ReadableType.Number -> jsonObject.addProperty(key, readableMap.getDouble(key))
-            ReadableType.String -> jsonObject.addProperty(key, readableMap.getString(key))
-            ReadableType.Map -> jsonObject.add(key, convertMapToJson(readableMap.getMap(key)))
-            ReadableType.Array -> jsonObject.add(key, convertArrayToJson(readableMap.getArray(key)))
+/**
+ * Convert a kotlinx [JsonObject] (native → RN boundary) into a [WritableMap].
+ * Returns `null` when [jsonObject] is null.
+ *
+ * Numeric primitives are coerced to [Double] (`putDouble`) to match JS's
+ * single `Number` type. JSON nulls map to `putNull(key)`. Non-finite /
+ * non-numeric primitives fall back to string form.
+ */
+fun convertJsonToMap(jsonObject: JsonObject?): WritableMap? {
+    jsonObject ?: return null
+    val map: WritableMap = WritableFactory.createMap()
+    for ((key, element) in jsonObject) {
+        when (element) {
+            is JsonNull -> map.putNull(key)
+            is JsonPrimitive -> putPrimitive(map, key, element)
+            is JsonObject -> map.putMap(key, convertJsonToMap(element))
+            is JsonArray -> map.putArray(key, convertJsonToArray(element))
         }
     }
-    return jsonObject
+    return map
 }
 
-@Throws(JSONException::class)
-fun convertArrayToJson(readableArray: ReadableArray?): JsonArray {
-    val jsonArray = JsonArray()
-    for (i in 0 until readableArray!!.size()) {
-        when (readableArray.getType(i)) {
-            ReadableType.Null -> {
-            }
-            ReadableType.Boolean -> jsonArray.add(readableArray.getBoolean(i))
-            ReadableType.Number -> jsonArray.add(readableArray.getDouble(i))
-            ReadableType.String -> jsonArray.add(readableArray.getString(i))
-            ReadableType.Map -> jsonArray.add(convertMapToJson(readableArray.getMap(i)))
-            ReadableType.Array -> jsonArray.add(convertArrayToJson(readableArray.getArray(i)))
+/**
+ * Convert a kotlinx [JsonArray] into a [WritableArray]. Mirrors
+ * [convertJsonToMap]. Null-safe.
+ */
+fun convertJsonToArray(jsonArray: JsonArray?): WritableArray? {
+    jsonArray ?: return null
+    val array: WritableArray = WritableFactory.createArray()
+    for (element in jsonArray) {
+        when (element) {
+            is JsonNull -> array.pushNull()
+            is JsonPrimitive -> pushPrimitive(array, element)
+            is JsonObject -> array.pushMap(convertJsonToMap(element))
+            is JsonArray -> array.pushArray(convertJsonToArray(element))
         }
     }
-    return jsonArray
+    return array
+}
+
+// Shared primitive dispatch — keeps the two public functions free of repeated
+// isString / booleanOrNull / doubleOrNull ladders. [primitive] is guaranteed
+// not to be [JsonNull] by the caller (JsonNull is a subtype of JsonPrimitive).
+private fun putPrimitive(map: WritableMap, key: String, primitive: JsonPrimitive) {
+    when {
+        primitive.isString -> map.putString(key, primitive.content)
+        primitive.booleanOrNull != null -> map.putBoolean(key, primitive.booleanOrNull!!)
+        primitive.doubleOrNull != null -> map.putDouble(key, primitive.doubleOrNull!!)
+        else -> map.putString(key, primitive.content)
+    }
 }
 
+private fun pushPrimitive(array: WritableArray, primitive: JsonPrimitive) {
+    when {
+        primitive.isString -> array.pushString(primitive.content)
+        primitive.booleanOrNull != null -> array.pushBoolean(primitive.booleanOrNull!!)
+        primitive.doubleOrNull != null -> array.pushDouble(primitive.doubleOrNull!!)
+        else -> array.pushString(primitive.content)
+    }
+}
+
+/**
+ * Generic `Map<*, *>` → `WritableMap` converter. Preserved from the original
+ * [Utils] surface — no JSON libraries involved, but used by callers that
+ * need to hand arbitrary Kotlin maps to the RN bridge.
+ */
 @JvmOverloads
 @Throws(Exception::class)
 fun convertToWritableMap(
-        map: Map<*, *>,
-        blacklist: List<String> = emptyList<String>()
+    map: Map<*, *>,
+    blacklist: List<String> = emptyList<String>()
 ): WritableMap {
-    val writableMap: WritableMap = WritableNativeMap()
+    val writableMap: WritableMap = WritableFactory.createMap()
     val iterator: Iterator<String> = map.keys.iterator() as Iterator<String>
     while (iterator.hasNext()) {
         val key = iterator.next()
@@ -91,61 +179,17 @@ fun convertToWritableMap(
         }
 
         when (val value = map[key]) {
-            is Boolean -> writableMap.putBoolean(key, (value as Boolean?)!!)
-            is Int -> writableMap.putInt(key, (value as Int?)!!)
-            is Double -> writableMap.putDouble(key, (value as Double?)!!)
-            is String -> writableMap.putString(key, value as String?)
+            is Boolean -> writableMap.putBoolean(key, value)
+            is Int -> writableMap.putInt(key, value)
+            is Double -> writableMap.putDouble(key, value)
+            is String -> writableMap.putString(key, value)
             else -> writableMap.putString(key, value.toString())
         }
     }
     return writableMap
 }
 
-@Throws(JSONException::class)
-fun convertJsonToMap(jsonObject: JsonObject?): WritableMap? {
-    val entries = jsonObject?.entrySet() ?: return null
-    val map: WritableMap = WritableNativeMap()
-    for ((key) in entries) {
-        val value = jsonObject[key]
-
-        if (value is JsonObject) {
-            map.putMap(key, convertJsonToMap(value))
-        } else if (value is JsonArray) {
-            map.putArray(key, convertJsonToArray(value))
-        } else if (value.asJsonPrimitive.isBoolean) {
-            map.putBoolean(key, value.asBoolean)
-        } else if (value.asJsonPrimitive.isNumber) {
-            map.putDouble(key, value.asDouble)
-        } else if (value.asJsonPrimitive.isString) {
-            map.putString(key, value.asString)
-        } else {
-            map.putString(key, value.toString())
-        }
-    }
-    return map
-}
-
-@Throws(JSONException::class)
-fun convertJsonToArray(jsonArray: JsonArray): WritableArray? {
-    val array: WritableArray = WritableNativeArray()
-    for (i in 0 until jsonArray.size()) {
-        val value = jsonArray[i]
-        if (value is JsonObject) {
-            array.pushMap(convertJsonToMap(value))
-        } else if (value is JsonArray) {
-            array.pushArray(convertJsonToArray(value))
-        } else if (value.asJsonPrimitive.isBoolean) {
-            array.pushBoolean(value.asBoolean)
-        } else if (value.asJsonPrimitive.isNumber) {
-            array.pushDouble(value.asDouble)
-        } else if (value.asJsonPrimitive.isString) {
-            array.pushString(value.asString)
-        } else {
-            array.pushString(value.toString())
-        }
-    }
-    return array
-}
+// --- ReadableMap convenience accessors (unchanged from the previous Utils). ---
 
 fun ReadableMap.getMapIfPresent(key: String): ReadableMap? {
     return if (this.hasKey(key)) this.getMap(key) else null