[ECO-5386] Implemented custom serializers for ObjectData type

1. Added JSON serializer/deserializer using ObjectDataJsonSerializer
2, Added msgpack serializer/deserializer using ObjectDataMsgpackSerializer and ObjectDataMsgpackDeserializer

Author: sacOO7

live-objects/src/main/kotlin/io/ably/lib/objects/ObjectMessage.kt

@@ -4,6 +4,9 @@ import com.google.gson.JsonArray
 import com.google.gson.JsonObject
 
 import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.google.gson.annotations.JsonAdapter
 import com.google.gson.annotations.SerializedName
 
 /**
@@ -31,19 +34,16 @@ internal enum class MapSemantics(val code: Int) {
  * An ObjectData represents a value in an object on a channel.
  * Spec: OD1
  */
+@JsonAdapter(ObjectDataJsonSerializer::class)
+@JsonSerialize(using = ObjectDataMsgpackSerializer::class)
+@JsonDeserialize(using = ObjectDataMsgpackDeserializer::class)
 internal data class ObjectData(
   /**
    * A reference to another object, used to support composable object structures.
    * Spec: OD2a
    */
   val objectId: String? = null,
 
-  /**
-   * Can be set by the client to indicate that value in `string` or `bytes` field have an encoding.
-   * Spec: OD2b
-   */
-  val encoding: String? = null,
-
   /**
    * String, number, boolean or binary - a concrete value of the object
    * Spec: OD2c
@@ -214,18 +214,13 @@ internal data class ObjectOperation(
   val nonce: String? = null,
 
   /**
-   * The initial value bytes for the object. These bytes should be used along with the nonce
-   * and timestamp to create the object ID. Frontdoor will use this to verify the object ID.
-   * After verification the bytes will be decoded into the Map or Counter objects and
-   * the initialValue, nonce, and initialValueEncoding will be removed.
+   * The initial value for the object, encoded as a JSON string.
+   * This value should be used along with the nonce and timestamp to create the object ID.
+   * Frontdoor will use this to verify the object ID. After verification, the value will be
+   * decoded into the Map or Counter objects and the initialValue, nonce, and initialValueEncoding will be removed.
    * Spec: OOP3h
    */
-  val initialValue: Binary? = null,
-
-  /** The initial value encoding defines how the initialValue should be interpreted.
-   * Spec: OOP3i
-   */
-  val initialValueEncoding: ProtocolMessageFormat? = null
+  val initialValue: String? = null,
 )
 
 /**

live-objects/src/main/kotlin/io/ably/lib/objects/Serialization.kt

@@ -2,12 +2,17 @@
 
 package io.ably.lib.objects
 
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.databind.DeserializationContext
 import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.SerializerProvider
 import com.google.gson.*
 import org.msgpack.core.MessagePack
 import org.msgpack.core.MessagePacker
 import org.msgpack.core.MessageUnpacker
 import org.msgpack.jackson.dataformat.MessagePackFactory
+import java.lang.reflect.Type
+import java.util.*
 
 // Gson instance for JSON serialization/deserialization
 internal val gson: Gson = GsonBuilder().create()
@@ -86,3 +91,98 @@ internal class DefaultLiveObjectSerializer : LiveObjectSerializer {
     return jsonArray
   }
 }
+
+internal class ObjectDataJsonSerializer : JsonSerializer<ObjectData>, JsonDeserializer<ObjectData> {
+  override fun serialize(src: ObjectData?, typeOfSrc: Type?, context: JsonSerializationContext?): JsonElement {
+    val obj = JsonObject()
+    src?.objectId?.let { obj.addProperty("objectId", it) }
+
+    src?.value?.let { value ->
+      when (val v = value.value) {
+        is Boolean -> obj.addProperty("boolean", v)
+        is String -> obj.addProperty("string", v)
+        is Number -> obj.addProperty("number", v)
+        is Binary -> obj.addProperty("bytes", Base64.getEncoder().encodeToString(v.data))
+        // Spec: OD4c5
+        is JsonObject, is JsonArray -> {
+          obj.addProperty("string", v.toString())
+          obj.addProperty("encoding", "json")
+        }
+      }
+    }
+    return obj
+  }
+
+  override fun deserialize(json: JsonElement?, typeOfT: Type?, context: JsonDeserializationContext?): ObjectData {
+    val obj = if (json?.isJsonObject == true) json.asJsonObject else throw JsonParseException("Expected JsonObject")
+    val objectId = if (obj.has("objectId")) obj.get("objectId").asString else null
+    val encoding = if (obj.has("encoding")) obj.get("encoding").asString else null
+    val value = when {
+      obj.has("boolean") -> ObjectValue(obj.get("boolean").asBoolean)
+      // Spec: OD5b3
+      obj.has("string") && encoding == "json" -> {
+        val jsonStr = obj.get("string").asString
+        val parsed = JsonParser.parseString(jsonStr)
+        ObjectValue(
+          when {
+            parsed.isJsonObject -> parsed.asJsonObject
+            parsed.isJsonArray -> parsed.asJsonArray
+            else -> throw JsonParseException("Invalid JSON string for encoding=json")
+          }
+        )
+      }
+      obj.has("string") -> ObjectValue(obj.get("string").asString)
+      obj.has("number") -> ObjectValue(obj.get("number").asNumber)
+      obj.has("bytes") -> ObjectValue(Binary(Base64.getDecoder().decode(obj.get("bytes").asString)))
+      else -> throw JsonParseException("ObjectData must have one of the fields: boolean, string, number, or bytes")
+    }
+    return ObjectData(objectId, value)
+  }
+}
+
+internal class ObjectDataMsgpackSerializer : com.fasterxml.jackson.databind.JsonSerializer<ObjectData>() {
+  override fun serialize(value: ObjectData?, gen: JsonGenerator, serializers: SerializerProvider) {
+    gen.writeStartObject()
+    value?.objectId?.let { gen.writeStringField("objectId", it) }
+    value?.value?.let { v ->
+      when (val data = v.value) {
+        is Boolean -> gen.writeBooleanField("boolean", data)
+        is String -> gen.writeStringField("string", data)
+        is Number -> gen.writeNumberField("number", data.toDouble())
+        is Binary -> gen.writeBinaryField("bytes", data.data)
+        is JsonObject, is JsonArray -> {
+          gen.writeStringField("string", data.toString())
+          gen.writeStringField("encoding", "json")
+        }
+      }
+    }
+    gen.writeEndObject()
+  }
+}
+
+internal class ObjectDataMsgpackDeserializer : com.fasterxml.jackson.databind.JsonDeserializer<ObjectData>() {
+  override fun deserialize(p: com.fasterxml.jackson.core.JsonParser, ctxt: DeserializationContext): ObjectData {
+    val node = p.codec.readTree<com.fasterxml.jackson.databind.JsonNode>(p)
+    val objectId = node.get("objectId")?.asText()
+    val encoding = node.get("encoding")?.asText()
+    val value = when {
+      node.has("boolean") -> ObjectValue(node.get("boolean").asBoolean())
+      node.has("string") && encoding == "json" -> {
+        val jsonStr = node.get("string").asText()
+        val parsed = JsonParser.parseString(jsonStr)
+        ObjectValue(
+          when {
+            parsed.isJsonObject -> parsed.asJsonObject
+            parsed.isJsonArray -> parsed.asJsonArray
+            else -> throw IllegalArgumentException("Invalid JSON string for encoding=json")
+          }
+        )
+      }
+      node.has("string") -> ObjectValue(node.get("string").asText())
+      node.has("number") -> ObjectValue(node.get("number").numberValue())
+      node.has("bytes") -> ObjectValue(Binary(node.get("bytes").binaryValue()))
+      else -> throw IllegalArgumentException("ObjectData must have one of the fields: boolean, string, number, or bytes")
+    }
+    return ObjectData(objectId, value)
+  }
+}

live-objects/src/test/kotlin/io/ably/lib/objects/unit/ObjectMessageSizeTest.kt

@@ -45,7 +45,6 @@ class ObjectMessageSizeTest {
           key = "mapKey", // Size: 6 bytes (UTF-8 byte length)
           data = ObjectData(
             objectId = "ref_obj", // Not counted in data size
-            encoding = "utf-8", // Not counted in data size
             value = ObjectValue("sample") // Size: 6 bytes (UTF-8 byte length)
           ) // Total ObjectData size: 6 bytes
         ), // Total ObjectMapOp size: 6 + 6 = 12 bytes
@@ -80,8 +79,7 @@ class ObjectMessageSizeTest {
         ), // Total ObjectCounter size: 8 bytes
 
         nonce = "nonce123", // Not counted in operation size
-        initialValue = Binary("initial".toByteArray()), // Not counted in operation size
-        initialValueEncoding = ProtocolMessageFormat.Json // Not counted in operation size
+        initialValue = "some-value", // Not counted in operation size
       ), // Total ObjectOperation size: 12 + 8 + 26 + 8 = 54 bytes
 
       objectState = ObjectState(