react-native-klarna-inapp-sdk 2.4.3 → 2.4.4

package/android/build.gradle

@@ -31,8 +31,6 @@ def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
-def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
-
 def supportsNamespace() {
   def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
   def major = parsed[0].toInteger()
@@ -46,6 +44,9 @@ def supportsNamespace() {
   return major >= 8
 }
 
+plugins {
+    id "org.jetbrains.kotlin.plugin.serialization" version "2.2.0"
+}
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 if (isNewArchitectureEnabled()) {
@@ -109,13 +110,19 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:${getExtOrFallback('reactnativeVersion', '+')}"
 
-    implementation 'com.klarna.mobile:sdk:2.6.29'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${getExtOrDefault('kotlinVersion')}"
+    implementation "org.jetbrains.kotlin:kotlin-reflect:${getExtOrDefault('kotlinVersion')}"
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0'
+
+    implementation 'com.klarna.mobile:sdk:2.7.1'
 
     testImplementation "junit:junit:4.13.2"
     testImplementation 'androidx.test:core:1.5.0'
     testImplementation "org.robolectric:robolectric:4.11.1"
     testImplementation "org.mockito:mockito-core:3.12.4"
     testImplementation "org.mockito:mockito-inline:3.12.4"
+    testImplementation "org.jetbrains.kotlin:kotlin-test-junit:${getExtOrDefault('kotlinVersion')}"
+    testImplementation "io.mockk:mockk:1.14.5"
 }
 
 // removed from the docs but we can keep it

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/common/event/KlarnaEventHandlerEventsUtil.java

@@ -5,19 +5,16 @@ import android.view.View;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
-import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
-import com.google.gson.reflect.TypeToken;
 import com.klarna.mobile.sdk.KlarnaMobileSDKError;
 import com.klarna.mobile.sdk.api.KlarnaProductEvent;
-import com.klarna.mobile.sdk.api.signin.model.KlarnaSignInToken;
+import com.klarna.mobile.sdk.reactnative.common.serializer.DynamicMapSerializer;
 import com.klarna.mobile.sdk.reactnative.common.util.ArgumentsUtil;
 import com.klarna.mobile.sdk.reactnative.common.util.ParserUtil;
 import com.klarna.mobile.sdk.reactnative.signin.KlarnaSignInData;
 import com.klarna.mobile.sdk.reactnative.signin.KlarnaSignInEventsMapper;
 
-import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -35,7 +32,7 @@ public class KlarnaEventHandlerEventsUtil {
     private static final String PARAM_NAME_PRODUCT_EVENT = "productEvent";
 
     public static <T extends View> void sendKlarnaProductEvent(@NonNull ComponentEventSender<T> componentEventSender, @Nullable View view, @NonNull KlarnaProductEvent klarnaProductEvent) {
-        String stringifiedParams = ParserUtil.toJson(klarnaProductEvent.getParams());
+        String stringifiedParams = ParserUtil.INSTANCE.toJson(DynamicMapSerializer.INSTANCE, klarnaProductEvent.getParams());
         String paramsJson = stringifiedParams == null ? "{}" : stringifiedParams;
         ReadableMap eventMap = ArgumentsUtil.createMap(new HashMap<String, Object>() {{
             put(PARAM_NAME_ACTION, klarnaProductEvent.getAction());
@@ -64,9 +61,10 @@ public class KlarnaEventHandlerEventsUtil {
             return;
         }
         Map<String, Object> updatedParams = new HashMap<>();
-        for(Map.Entry<String, Object> entry : klarnaProductEvent.getParams().entrySet()) {
+        for (Map.Entry<String, Object> entry : klarnaProductEvent.getParams().entrySet()) {
             String updatedKey = KlarnaSignInEventsMapper.mapSignInParamName(entry.getKey());
-            updatedParams.put(updatedKey, entry.getValue());
+            Object updatedValue = KlarnaSignInEventsMapper.transformSignInParamValue(entry.getKey(), entry.getValue());
+            updatedParams.put(updatedKey, updatedValue);
         }
         String eventName = KlarnaSignInEventsMapper.mapSignInEventName(klarnaProductEvent.getAction());
         ReadableMap eventMap = ArgumentsUtil.createMap(new HashMap<String, Object>() {{

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/common/serializer/DynamicMapSerializer.kt

@@ -0,0 +1,138 @@
+package com.klarna.mobile.sdk.reactnative.common.serializer
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonDecoder
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonEncoder
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.floatOrNull
+import kotlinx.serialization.json.intOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.longOrNull
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.serializerOrNull
+import kotlin.reflect.full.memberProperties
+
+object DynamicMapSerializer : KSerializer<Map<String, Any?>> {
+    override val descriptor: SerialDescriptor =
+        buildClassSerialDescriptor("EnhancedDynamicMap")
+
+    override fun serialize(
+        encoder: Encoder,
+        value: Map<String, Any?>,
+    ) {
+        val jsonEncoder = encoder as? JsonEncoder ?: error("Only JSON is supported")
+        val jsonObject =
+            buildJsonObject {
+                value.forEach { (key, any) ->
+                    put(key, serializeValue(any, jsonEncoder))
+                }
+            }
+        jsonEncoder.encodeJsonElement(jsonObject)
+    }
+
+    override fun deserialize(decoder: Decoder): Map<String, Any?> {
+        val jsonDecoder = decoder as? JsonDecoder ?: error("Only JSON is supported")
+        val jsonObject = jsonDecoder.decodeJsonElement().jsonObject
+        return jsonObject.mapValues { (_, element) -> deserializeValue(element) }
+    }
+
+    private fun serializeValue(value: Any?, encoder: JsonEncoder): JsonElement =
+        when (value) {
+            null -> JsonNull
+            is Boolean -> JsonPrimitive(value)
+            is Byte -> JsonPrimitive(value)
+            is Short -> JsonPrimitive(value)
+            is Int -> JsonPrimitive(value)
+            is Long -> JsonPrimitive(value)
+            is Float -> JsonPrimitive(value)
+            is Double -> JsonPrimitive(value)
+            is String -> JsonPrimitive(value)
+            is Char -> JsonPrimitive(value.toString())
+            is Enum<*> -> JsonPrimitive(value.toString())
+            is Map<*, *> -> {
+                buildJsonObject {
+                    value.forEach { (k, v) ->
+                        put(k.toString(), serializeValue(v, encoder))
+                    }
+                }
+            }
+
+            is Collection<*> -> {
+                buildJsonArray {
+                    value.forEach { add(serializeValue(it, encoder)) }
+                }
+            }
+
+            is Array<*> -> {
+                buildJsonArray {
+                    value.forEach { add(serializeValue(it, encoder)) }
+                }
+            }
+
+            else -> {
+                serializerFor(encoder.serializersModule, value)?.let { serializer ->
+                    // Use the serializer to convert the object to JsonElement
+                    val jsonElement = encoder.json.encodeToJsonElement(serializer, value)
+                    jsonElement
+                } ?: run {
+                    // Check if it's a data class
+                    if (value::class.isData) {
+                        // Convert data class to Map by using reflection
+                        val properties = value::class.memberProperties
+                            .associate { it.name to it.call(value) }
+
+                        buildJsonObject {
+                            properties.forEach { (k, v) ->
+                                put(k, serializeValue(v, encoder))
+                            }
+                        }
+                    } else {
+                        JsonPrimitive(value.toString()) // Fallback to string representation
+                    }
+                }
+            }
+        }
+
+    private fun deserializeValue(element: JsonElement): Any? =
+        when (element) {
+            is JsonNull -> null
+            is JsonPrimitive -> {
+                when {
+                    element.isString -> element.content
+                    element.content.equals("true", ignoreCase = true) -> true
+                    element.content.equals("false", ignoreCase = true) -> false
+                    // Try parsing as numbers with proper type detection
+                    element.content.contains('.') -> {
+                        element.doubleOrNull ?: element.floatOrNull ?: element.content
+                    }
+
+                    else -> {
+                        element.longOrNull ?: element.intOrNull ?: element.content
+                    }
+                }
+            }
+
+            is JsonObject -> element.mapValues { (_, value) -> deserializeValue(value) }
+            is JsonArray -> element.map { deserializeValue(it) }
+        }
+
+    private fun serializerFor(
+        serializersModule: SerializersModule,
+        obj: Any?,
+    ): KSerializer<Any>? {
+        return obj?.let {
+            serializersModule.serializerOrNull(obj::class.java)
+        }
+    }
+}

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/common/util/ArgumentsUtil.java

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
+import com.klarna.mobile.sdk.reactnative.common.serializer.DynamicMapSerializer;
 
 import org.json.JSONException;
 import org.json.JSONObject;
@@ -13,8 +14,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import okhttp3.internal.Util;
-
 public class ArgumentsUtil {
 
     public static WritableMap createMap(Map<String, Object> sourceMap) {
@@ -67,7 +66,7 @@ public class ArgumentsUtil {
     }
 
     public static WritableMap createMapUsingJSONString(Map<String, Object> sourceMap) {
-        String jsonString = ParserUtil.toJson(sourceMap);
+        String jsonString = ParserUtil.INSTANCE.toJson(DynamicMapSerializer.INSTANCE, sourceMap);
         WritableMap map = Arguments.createMap();
         try {
             JSONObject jsonObject = new JSONObject(jsonString);

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/common/util/ParserUtil.kt

@@ -0,0 +1,27 @@
+package com.klarna.mobile.sdk.reactnative.common.util
+
+import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+
+object ParserUtil {
+    val json: Json by lazy {
+        Json {
+            ignoreUnknownKeys = true
+        }
+    }
+
+    fun <T> toJson(
+        serializer: SerializationStrategy<T>,
+        src: T,
+    ): String {
+        val res = json.encodeToString(serializer, src)
+        return res
+    }
+
+    inline fun <reified T> toJson(
+        src: T,
+    ): String = json.encodeToString(src)
+
+    fun parse(json: String): JsonElement = this.json.parseToJsonElement(json)
+}

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/signin/KlarnaSignInEventsMapper.java

@@ -1,5 +1,8 @@
 package com.klarna.mobile.sdk.reactnative.signin;
 
+import com.klarna.mobile.sdk.api.signin.model.KlarnaSignInToken;
+import com.klarna.mobile.sdk.reactnative.signin.model.KlarnaSignInTokenSerializable;
+
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -22,19 +25,45 @@ public class KlarnaSignInEventsMapper {
         return errorsMap.get(key);
     }
 
+    private static final Map<String, String> EVENTS_MAP = new HashMap<>() {
+        {
+            put("KlarnaSignInToken", "KlarnaSignInToken");
+            put("KlarnaSignInUserCancelled", "KlarnaSignInUserCancelled");
+        }
+    };
+
     public static String mapSignInEventName(String key) {
-        Map<String, String> eventsMap = new HashMap<>();
-        eventsMap.put("KlarnaSignInToken", "KlarnaSignInToken");
-        eventsMap.put("KlarnaSignInUserCancelled", "KlarnaSignInUserCancelled");
-        if (eventsMap.get(key) == null) {
+        if (EVENTS_MAP.get(key) == null) {
             return key;
         }
-        return eventsMap.get(key);
+        return EVENTS_MAP.get(key);
     }
 
+    private static final Map<String, String> PARAMS_MAP = Collections.singletonMap("KlarnaSignInToken", "KlarnaSignInToken");
+
     public static String mapSignInParamName(String key) {
-        Map<String, String> paramsMap = new HashMap<>();
-        paramsMap.put("KlarnaSignInToken", "KlarnaSignInToken");
-        return paramsMap.get(key);
+        if (EVENTS_MAP.containsKey(key)) {
+            return PARAMS_MAP.get(key);
+        }
+        return key;
+    }
+
+    private static final Map<String, ValueTransformer<Object>> TRANSFORMER_MAP = Collections.singletonMap("KlarnaSignInToken", value -> {
+        if (value instanceof KlarnaSignInToken) {
+            return KlarnaSignInTokenSerializable.Companion.from((KlarnaSignInToken) value);
+        }
+        return value;
+    });
+
+    public static Object transformSignInParamValue(String key, Object value) {
+        ValueTransformer<Object> transformer = TRANSFORMER_MAP.get(key);
+        if (transformer != null) {
+            return transformer.transform(value);
+        }
+        return value;
+    }
+
+    public interface ValueTransformer<T> {
+        T transform(Object value);
     }
 }

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/signin/model/KlarnaSignInTokenSerializable.kt

@@ -0,0 +1,32 @@
+package com.klarna.mobile.sdk.reactnative.signin.model
+
+import com.klarna.mobile.sdk.api.signin.model.KlarnaSignInToken
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class KlarnaSignInTokenSerializable(
+    @SerialName("access_token")
+    val accessToken: String? = null,
+    @SerialName("refresh_token")
+    val refreshToken: String? = null,
+    @SerialName("id_token")
+    val idToken: String? = null,
+    @SerialName("expires_in")
+    val expiresIn: String? = null,
+    @SerialName("scope")
+    val scope: String? = null,
+    @SerialName("token_type")
+    val tokenType: String? = null,
+) {
+    companion object {
+        fun from(klarnaSignInToken: KlarnaSignInToken) = KlarnaSignInTokenSerializable(
+            accessToken = klarnaSignInToken.accessToken,
+            refreshToken = klarnaSignInToken.refreshToken,
+            idToken = klarnaSignInToken.idToken,
+            expiresIn = klarnaSignInToken.expiresIn,
+            scope = klarnaSignInToken.scope,
+            tokenType = klarnaSignInToken.tokenType
+        )
+    }
+}

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/standalonewebview/KlarnaStandaloneWebViewEventSender.java

@@ -8,10 +8,11 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.events.EventDispatcher;
-import com.google.gson.Gson;
 import com.klarna.mobile.sdk.api.KlarnaProductEvent;
 import com.klarna.mobile.sdk.api.standalonewebview.KlarnaStandaloneWebView;
+import com.klarna.mobile.sdk.reactnative.common.serializer.DynamicMapSerializer;
 import com.klarna.mobile.sdk.reactnative.common.util.ArgumentsUtil;
+import com.klarna.mobile.sdk.reactnative.common.util.ParserUtil;
 
 import java.lang.ref.WeakReference;
 import java.util.HashMap;
@@ -39,7 +40,6 @@ public class KlarnaStandaloneWebViewEventSender {
     private static final String PARAM_NAME_PARAMS = "params";
     private static final String PARAM_NAME_DID_CRASH = "didCrash";
 
-    private final Gson gson = new Gson();
     private final WeakReference<ReactContext> reactContextWeakReference;
     private final Map<WeakReference<KlarnaStandaloneWebView>, EventDispatcher> viewToDispatcher;
 
@@ -78,7 +78,7 @@ public class KlarnaStandaloneWebViewEventSender {
     public void sendKlarnaMessageEvent(@Nullable KlarnaStandaloneWebView view, @NonNull KlarnaProductEvent klarnaProductEvent) {
         String paramsJson = "{}";
         try {
-            paramsJson = gson.toJson(klarnaProductEvent.getParams());
+            paramsJson = ParserUtil.INSTANCE.toJson(DynamicMapSerializer.INSTANCE, klarnaProductEvent.getParams());
         } catch (Exception ignored) {
         }
         String finalParamsJson = paramsJson;

package/android/src/test/java/com/klarna/mobile/sdk/reactnative/common/serializer/DynamicMapSerializerTest.kt

@@ -0,0 +1,229 @@
+package com.klarna.mobile.sdk.reactnative.common.serializer
+
+import com.klarna.mobile.sdk.reactnative.common.util.ParserUtil
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import kotlin.test.assertContentEquals
+
+class DynamicMapSerializerTest {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    @Test
+    fun `test serialization of primitive values`() {
+        val map = mapOf(
+            "nullValue" to null,
+            "booleanValue" to true,
+            "intValue" to 42,
+            "longValue" to 123456789L,
+            "floatValue" to 3.14f,
+            "doubleValue" to 2.71828,
+            "stringValue" to "hello",
+            "charValue" to 'A'
+        )
+
+        val jsonString = json.encodeToString(DynamicMapSerializer, map)
+        val expectedJson =
+            """{"nullValue":null,"booleanValue":true,"intValue":42,"longValue":123456789,"floatValue":3.14,"doubleValue":2.71828,"stringValue":"hello","charValue":"A"}"""
+
+        assertEquals(expectedJson, jsonString)
+    }
+
+    @Test
+    fun `test deserialization of primitive values`() {
+        val jsonString =
+            """{"nullValue":null,"booleanValue":true,"intValue":42,"longValue":123456789,"floatValue":3.14,"doubleValue":2.71828,"stringValue":"hello"}"""
+
+        val map = json.decodeFromString(DynamicMapSerializer, jsonString)
+
+        assertEquals(null, map["nullValue"])
+        assertEquals(true, map["booleanValue"])
+        assertEquals(42L, map["intValue"])
+        assertEquals(123456789L, map["longValue"])
+        assertEquals(3.14, map["floatValue"])
+        assertEquals(2.71828, map["doubleValue"])
+        assertEquals("hello", map["stringValue"])
+    }
+
+    @Test
+    fun `test serialization of nested maps`() {
+        val nestedMap = mapOf(
+            "inner" to mapOf(
+                "key1" to "value1",
+                "key2" to 42
+            )
+        )
+
+        val jsonString = json.encodeToString(DynamicMapSerializer, nestedMap)
+        val expectedJson = """{"inner":{"key1":"value1","key2":42}}"""
+
+        assertEquals(expectedJson, jsonString)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Test
+    fun `test deserialization of nested maps`() {
+        val jsonString = """{"outer":{"inner":{"key1":"value1","key2":42}}}"""
+
+        val map = json.decodeFromString(DynamicMapSerializer, jsonString)
+
+        val outer = map["outer"] as Map<String, Any?>
+        val inner = outer["inner"] as Map<String, Any?>
+
+        assertEquals("value1", inner["key1"])
+        assertEquals(42L, inner["key2"])
+    }
+
+    @Test
+    fun `test serialization of collections`() {
+        val map = mapOf(
+            "list" to listOf(1, 2, 3),
+            "mixedList" to listOf(1, "two", 3.0)
+        )
+
+        val jsonString = json.encodeToString(DynamicMapSerializer, map)
+        val expectedJson = """{"list":[1,2,3],"mixedList":[1,"two",3.0]}"""
+
+        assertEquals(expectedJson, jsonString)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Test
+    fun `test deserialization of collections`() {
+        val jsonString = """{"list":[1,2,3],"mixedList":[1,"two",3.0]}"""
+
+        val map = json.decodeFromString(DynamicMapSerializer, jsonString)
+
+        val list = map["list"] as List<Long>
+        val mixedList = map["mixedList"] as Collection<Any?>
+
+        assertContentEquals(listOf(1L, 2L, 3L), list)
+        assertEquals(1L, mixedList.elementAt(0))
+        assertEquals("two", mixedList.elementAt(1))
+        assertEquals(3.0, mixedList.elementAt(2))
+    }
+
+    @Test
+    fun `test serialization of arrays`() {
+        val map = mapOf(
+            "array" to arrayOf(1, 2, 3)
+        )
+
+        val jsonString = json.encodeToString(DynamicMapSerializer, map)
+        val expectedJson = """{"array":[1,2,3]}"""
+
+        assertEquals(expectedJson, jsonString)
+    }
+
+    @Test
+    fun `test serialization of complex nested structures`() {
+        val complex = mapOf(
+            "name" to "Complex",
+            "properties" to mapOf(
+                "nested" to listOf(
+                    mapOf("id" to 1, "value" to "first"),
+                    mapOf("id" to 2, "value" to "second")
+                )
+            ),
+            "tags" to arrayOf("important", "test")
+        )
+
+        val jsonString = json.encodeToString(DynamicMapSerializer, complex)
+        val expectedJson =
+            """{"name":"Complex","properties":{"nested":[{"id":1,"value":"first"},{"id":2,"value":"second"}]},"tags":["important","test"]}"""
+
+        assertEquals(expectedJson, jsonString)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Test
+    fun `test serialization and deserialization of data classes`() {
+        // Define a data class for testing
+        data class TestDataClass2(
+            val street: String,
+            val city: String,
+            val zipCode: String
+        )
+
+        data class TestDataClass1(
+            val name: String,
+            val age: Int,
+            val address: TestDataClass2
+        )
+
+        // Create test data
+        val address = TestDataClass2("123 Main St", "Anytown", "12345")
+        val person = TestDataClass1("John Doe", 30, address)
+
+        // Create a map with the data class
+        val map = mapOf(
+            "person" to person,
+            "simpleValue" to 42
+        )
+
+        // Serialize
+        val jsonString = json.encodeToString(DynamicMapSerializer, map)
+
+        // Expected JSON structure
+        val expectedJson =
+            """{"person":{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","zipCode":"12345"}},"simpleValue":42}"""
+
+        // Verify serialization
+        assertEquals(ParserUtil.parse(expectedJson), ParserUtil.parse(jsonString))
+
+        // Deserialize
+        val deserializedMap = json.decodeFromString(DynamicMapSerializer, jsonString)
+
+        // Verify deserialization
+        assertEquals(42L, deserializedMap["simpleValue"])
+
+        // Check the nested structure
+        val deserializedPerson = deserializedMap["person"] as Map<String, Any?>
+        assertEquals("John Doe", deserializedPerson["name"])
+        assertEquals(30L, deserializedPerson["age"])
+
+        val deserializedAddress = deserializedPerson["address"] as Map<String, Any?>
+        assertEquals("123 Main St", deserializedAddress["street"])
+        assertEquals("Anytown", deserializedAddress["city"])
+        assertEquals("12345", deserializedAddress["zipCode"])
+    }
+
+    @Test
+    fun `test serialization and deserialization of serializable objects`() {
+        // Define a serializable class
+        @Serializable
+        data class SerializableUser(
+            val id: Int,
+            val username: String
+        )
+
+        // Create test data with serializable object
+        val user = SerializableUser(id = 1001, username = "testuser")
+        val map = mapOf(
+            "user" to user,
+            "timestamp" to 1634567890L
+        )
+
+        // Serialize
+        val jsonString = json.encodeToString(DynamicMapSerializer, map)
+
+        // Expected JSON structure
+        val expectedJson = """{"user":{"id":1001,"username":"testuser"},"timestamp":1634567890}"""
+
+        // Verify serialization
+        assertEquals(ParserUtil.parse(expectedJson), ParserUtil.parse(jsonString))
+
+        // Deserialize
+        val deserializedMap = json.decodeFromString(DynamicMapSerializer, jsonString)
+
+        // Verify deserialization
+        assertEquals(1634567890L, deserializedMap["timestamp"])
+
+        // Check the serializable object
+        val deserializedUser = deserializedMap["user"] as Map<String, Any?>
+        assertEquals(1001L, deserializedUser["id"])
+        assertEquals("testuser", deserializedUser["username"])
+    }
+}

package/android/src/test/java/com/klarna/mobile/sdk/reactnative/common/util/ParserUtilTest.kt

@@ -0,0 +1,39 @@
+package com.klarna.mobile.sdk.reactnative.common.util
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerializationException
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNotNull
+
+internal class ParserUtilTest {
+    @Test
+    fun `test gson is not null`() {
+        assertNotNull(ParserUtil.json)
+    }
+
+    @Test
+    fun `test toJson success`() {
+        val serialized = ParserUtil.toJson(TestData("test"))
+        assertEquals("{\"data\":\"test\"}", serialized)
+    }
+
+    @Test
+    fun `test toJson fail`() {
+        val testData = NonSerializableData("")
+        assertFailsWith(SerializationException::class, "test") {
+            ParserUtil.toJson(testData)
+        }
+    }
+
+    @Serializable
+    private data class TestData(
+        @SerialName("data") val data: String,
+    )
+
+    private data class NonSerializableData(
+        val data: String,
+    )
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-klarna-inapp-sdk",
   "title": "Klarna Mobile SDK React Native",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "This library wraps Klarna Mobile SDK and exposes its functionality as React Native components.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/android/src/main/java/com/klarna/mobile/sdk/reactnative/common/util/ParserUtil.java

@@ -1,36 +0,0 @@
-package com.klarna.mobile.sdk.reactnative.common.util;
-
-import android.util.Log;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-
-public class ParserUtil {
-    public static final Gson gson = new GsonBuilder().create();
-
-    public static String toJson(Object obj) {
-        return gson.toJson(obj);
-    }
-
-    public static String toJsonSafe(Object obj) {
-        try {
-            return gson.toJson(obj);
-        } catch (Throwable t) {
-            Log.e(ParserUtil.class.getSimpleName(), "Failed to serialize object to string with Gson: " + t.getMessage());
-            return null;
-        }
-    }
-
-    public static <T> T fromJson(String json, Class<T> cls) {
-        return gson.fromJson(json, cls);
-    }
-
-    public static <T> T fromJsonSafe(String json, Class<T> cls) {
-        try {
-            return gson.fromJson(json, cls);
-        } catch (Throwable t) {
-            Log.e(ParserUtil.class.getSimpleName(), "Failed to deserialize object from string with Gson: " + t.getMessage());
-            return null;
-        }
-    }
-}