Add more custom serializers for kotlinx serialization

app/src/androidTest/java/com/lagradost/cloudstream3/utils/serializers/UriSerializerTest.kt

@@ -0,0 +1,41 @@
+package com.lagradost.cloudstream3.utils.serializers
+
+import android.net.Uri
+import com.lagradost.cloudstream3.utils.AppUtils.parseJson
+import com.lagradost.cloudstream3.utils.AppUtils.toJson
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+@Serializable
+data class UriData(
+    @Serializable(with = UriSerializer::class)
+    @SerialName("uri") val uri: Uri = Uri.EMPTY,
+)
+
+class UriSerializerTest {
+
+    @Test
+    fun uriSerializerSerializesUriToString() {
+        val data = UriData(uri = Uri.parse("https://example.com/path?query=1"))
+        val result = data.toJson()
+        assertTrue(result.contains("https://example.com/path?query=1"))
+    }
+
+    @Test
+    fun uriSerializerDeserializesStringToUri() {
+        val input = """{"uri":"https://example.com/path?query=1"}"""
+        val result = parseJson<UriData>(input)
+        assertEquals(Uri.parse("https://example.com/path?query=1"), result.uri)
+    }
+
+    @Test
+    fun uriSerializerRoundtripsCorrectly() {
+        val data = UriData(uri = Uri.parse("https://example.com/path?query=1"))
+        val encoded = data.toJson()
+        val decoded = parseJson<UriData>(encoded)
+        assertEquals(data.uri, decoded.uri)
+    }
+}

library/src/commonMain/kotlin/com/lagradost/cloudstream3/utils/serializers/FloatAsIntSerializer.kt

@@ -0,0 +1,42 @@
+package com.lagradost.cloudstream3.utils.serializers
+
+import com.lagradost.cloudstream3.Prerelease
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonDecoder
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.intOrNull
+
+/**
+ * Replicates Jackson's ACCEPT_FLOAT_AS_INT behaviour for Int fields.
+ * A floating-point JSON number is truncated to Int by dropping the
+ * fractional part, exactly like Jackson's default truncation behaviour.
+ *
+ * Usage:
+ *
+ *   @Serializable
+ *   data class MyData(
+ *       @Serializable(with = FloatAsIntSerializer::class)
+ *       @SerialName("count") val count: Int = 0,
+ *   )
+ */
+@Prerelease
+object FloatAsIntSerializer : KSerializer<Int> {
+
+    override val descriptor: SerialDescriptor =
+        PrimitiveSerialDescriptor("FloatAsInt", PrimitiveKind.INT)
+
+    override fun deserialize(decoder: Decoder): Int {
+        val jsonDecoder = decoder as? JsonDecoder ?: return decoder.decodeInt()
+        val element = jsonDecoder.decodeJsonElement()
+        if (element !is JsonPrimitive) return 0
+        return element.intOrNull ?: element.doubleOrNull?.toInt() ?: 0
+    }
+
+    override fun serialize(encoder: Encoder, value: Int) = encoder.encodeInt(value)
+}

library/src/commonMain/kotlin/com/lagradost/cloudstream3/utils/serializers/FloatAsLongSerializer.kt

@@ -0,0 +1,42 @@
+package com.lagradost.cloudstream3.utils.serializers
+
+import com.lagradost.cloudstream3.Prerelease
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonDecoder
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.longOrNull
+
+/**
+ * Replicates Jackson's ACCEPT_FLOAT_AS_INT behaviour for Long fields.
+ * A floating-point JSON number is truncated to Long by dropping the
+ * fractional part, exactly like Jackson's default truncation behaviour.
+ *
+ * Usage:
+ *
+ *   @Serializable
+ *   data class MyData(
+ *       @Serializable(with = FloatAsLongSerializer::class)
+ *       @SerialName("timestamp") val timestamp: Long = 0L,
+ *   )
+ */
+@Prerelease
+object FloatAsLongSerializer : KSerializer<Long> {
+
+    override val descriptor: SerialDescriptor =
+        PrimitiveSerialDescriptor("FloatAsLong", PrimitiveKind.LONG)
+
+    override fun deserialize(decoder: Decoder): Long {
+        val jsonDecoder = decoder as? JsonDecoder ?: return decoder.decodeLong()
+        val element = jsonDecoder.decodeJsonElement()
+        if (element !is JsonPrimitive) return 0L
+        return element.longOrNull ?: element.doubleOrNull?.toLong() ?: 0L
+    }
+
+    override fun serialize(encoder: Encoder, value: Long) = encoder.encodeLong(value)
+}

library/src/commonMain/kotlin/com/lagradost/cloudstream3/utils/serializers/JsonTransformSerializer.kt

@@ -0,0 +1,75 @@
+package com.lagradost.cloudstream3.utils.serializers
+
+import com.lagradost.cloudstream3.Prerelease
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.JsonTransformingSerializer
+
+/**
+ * Composable deserialize transformer that applies multiple Jackson-equivalent
+ * behaviours to specific fields by key. Pass only the sets you need; all
+ * default to empty (no-op).
+ *
+ * Behaviours (applied in order per field):
+ *   singleValueAsListKeys ACCEPT_SINGLE_VALUE_AS_ARRAY
+ *   emptyStringAsNullKeys ACCEPT_EMPTY_STRING_AS_NULL_OBJECT
+ *   emptyArrayAsNullKeys ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT
+ *
+ * Usage:
+ *
+ *   @OptIn(ExperimentalSerializationApi::class) // KeepGeneratedSerializer is an experimental annotation for now
+ *   @KeepGeneratedSerializer
+ *   @Serializable(with = MyData.Serializer::class)
+ *   data class MyData(
+ *       @SerialName("title") val title: String? = null,
+ *       @SerialName("tags") val tags: List<String>? = null,
+ *       @SerialName("meta") val meta: MyMeta? = null,
+ *   ) {
+ *       object Serializer : JsonTransformSerializer<MyData>(
+ *           MyData.generatedSerializer(),
+ *           singleValueAsListKeys = setOf("tags"),
+ *           emptyStringAsNullKeys = setOf("title", "tags"),
+ *           emptyArrayAsNullKeys = setOf("tags", "meta"),
+ *       )
+ *   }
+ */
+@Prerelease
+abstract class JsonTransformSerializer<T : Any>(
+    tSerializer: KSerializer<T>,
+    private val singleValueAsListKeys: Set<String> = emptySet(),
+    private val emptyArrayAsNullKeys: Set<String> = emptySet(),
+    private val emptyStringAsNullKeys: Set<String> = emptySet(),
+) : JsonTransformingSerializer<T>(tSerializer) {
+
+    override fun transformDeserialize(element: JsonElement): JsonElement {
+        if (element !is JsonObject) return element
+        return JsonObject(element.mapValues { (key, value) ->
+            var result = value
+            if (key in singleValueAsListKeys) {
+                result = when (result) {
+                    is JsonArray -> result
+                    JsonNull -> JsonArray(emptyList())
+                    else -> JsonArray(listOf(result))
+                }
+            }
+
+            if (key in emptyStringAsNullKeys) {
+                if (result is JsonPrimitive && result.isString && result.content.isEmpty()) {
+                    result = JsonNull
+                }
+            }
+
+            if (key in emptyArrayAsNullKeys) {
+                if (result is JsonArray && result.isEmpty()) {
+                    result = JsonNull
+                }
+            }
+
+            result
+        })
+    }
+}

library/src/commonMain/kotlin/com/lagradost/cloudstream3/utils/serializers/NonEmptySerializer.kt

@@ -17,13 +17,13 @@ import kotlinx.serialization.json.JsonTransformingSerializer
  *
  * Usage:
  *
- *   @OptIn(ExperimentalSerializationApi::class)
+ *   @OptIn(ExperimentalSerializationApi::class) // KeepGeneratedSerializer is an experimental annotation for now
  *   @KeepGeneratedSerializer
  *   @Serializable(with = MyData.Serializer::class)
  *   data class MyData(
- *       val tags: List<String> = emptyList(),
- *       val title: String = "",
- *       val meta: Map<String, String> = emptyMap(),
+ *       @SerialName("tags") val tags: List<String> = emptyList(),
+ *       @SerialName("title") val title: String = "",
+ *       @SerialName("meta") val meta: Map<String, String> = emptyMap(),
  *   ) {
  *       object Serializer : NonEmptySerializer<MyData>(MyData.generatedSerializer())
  *   }
@@ -34,7 +34,6 @@ abstract class NonEmptySerializer<T : Any>(tSerializer: KSerializer<T>) :
 
     override fun transformSerialize(element: JsonElement): JsonElement {
         if (element !is JsonObject) return element
-
         return JsonObject(element.filterValues { value ->
             when (value) {
                 is JsonPrimitive -> value.content.isNotEmpty()