Added gson serializers to liveobjects module, declared common protomsg state

field between common to liveobjects and core java sdk

Author: sacOO7

lib/src/main/java/io/ably/lib/types/ProtocolMessage.java

@@ -4,20 +4,24 @@
 import java.lang.reflect.Type;
 import java.util.Map;
 
-import org.msgpack.core.MessageFormat;
-import org.msgpack.core.MessagePacker;
-import org.msgpack.core.MessageUnpacker;
-
+import com.google.gson.JsonArray;
 import com.google.gson.JsonDeserializationContext;
 import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonParseException;
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
+import org.jetbrains.annotations.Nullable;
+import org.msgpack.core.MessageFormat;
+import org.msgpack.core.MessagePacker;
+import org.msgpack.core.MessageUnpacker;
 
 import io.ably.lib.util.Log;
 
+import static io.ably.lib.util.Serialisation.gsonToMsgpack;
+import static io.ably.lib.util.Serialisation.msgpackToGson;
+
 /**
  * A message sent and received over the Realtime protocol.
  * A ProtocolMessage always relates to a single channel only, but
@@ -116,6 +120,11 @@ public ProtocolMessage(Action action, String channel) {
     public ConnectionDetails connectionDetails;
     public AuthDetails auth;
     public Map<String, String> params;
+    /**
+     * This will be null if we skipped decoding this property due to user not requesting Objects functionality
+     */
+    public @Nullable JsonArray state;
+
 
     public boolean hasFlag(final Flag flag) {
         return (flags & flag.getMask()) == flag.getMask();
@@ -139,6 +148,7 @@ void writeMsgpack(MessagePacker packer) throws IOException {
         if(flags != 0) ++fieldCount;
         if(params != null) ++fieldCount;
         if(channelSerial != null) ++fieldCount;
+        if(state != null) ++fieldCount;
         packer.packMapHeader(fieldCount);
         packer.packString("action");
         packer.packInt(action.getValue());
@@ -174,6 +184,10 @@ void writeMsgpack(MessagePacker packer) throws IOException {
             packer.packString("channelSerial");
             packer.packString(channelSerial);
         }
+        if(state != null) {
+            packer.packString("state");
+            gsonToMsgpack(state, packer);
+        }
     }
 
     ProtocolMessage readMsgpack(MessageUnpacker unpacker) throws IOException {
@@ -233,6 +247,9 @@ ProtocolMessage readMsgpack(MessageUnpacker unpacker) throws IOException {
                 case "params":
                     params = MessageSerializer.readStringMap(unpacker);
                     break;
+                case "state":
+                    state = (JsonArray) msgpackToGson(unpacker.unpackValue());
+                    break;
                 default:
                     Log.v(TAG, "Unexpected field: " + fieldName);
                     unpacker.skipValue();

lib/src/main/java/io/ably/lib/util/Base64Coder.java

@@ -233,7 +233,14 @@ public static byte[] decode (char[] in, int iOff, int iLen) {
  if (op<oLen) out[op++] = (byte)o2; }
 return out; }
 
-//Dummy constructor.
+public static boolean isBase64(String s) {
+    if (s == null || s.isEmpty()) {
+        return false;
+    }
+    // Check if the string matches the Base64 pattern
+    return s.matches("^[A-Za-z0-9+/]*={0,2}$") && (s.length() % 4 == 0);
+}
+    //Dummy constructor.
 private Base64Coder() {}
 
-} // end class Base64Coder
+} // end class Base64Coder

lib/src/main/java/io/ably/lib/util/Serialisation.java

@@ -33,6 +33,7 @@
 import java.util.Set;
 
 public class Serialisation {
+    public static final String TAG = Serialisation.class.getName();
     public static final JsonParser gsonParser;
     public static final GsonBuilder gsonBuilder;
     public static final Gson gson;
@@ -194,6 +195,7 @@ public static void gsonToMsgpack(JsonElement json, MessagePacker packer) {
         } else if (json.isJsonPrimitive()) {
             gsonToMsgpack((JsonPrimitive)json, packer);
         } else {
+            Log.e(TAG, "Unsupported JsonElement type: " + json.getClass().getName());
             throw new RuntimeException("unreachable");
         }
     }
@@ -204,7 +206,10 @@ private static void gsonToMsgpack(JsonArray array, MessagePacker packer) {
             for (JsonElement elem : array) {
                 gsonToMsgpack(elem, packer);
             }
-        } catch(IOException e) {}
+        } catch(IOException e) {
+            // Handle IOException, possibly log it or rethrow as a runtime exception
+            Log.e(TAG, "Error packing JsonArray to MsgPack", e);
+        }
     }
 
     private static void gsonToMsgpack(JsonObject object, MessagePacker packer) {
@@ -215,13 +220,17 @@ private static void gsonToMsgpack(JsonObject object, MessagePacker packer) {
                 packer.packString(entry.getKey());
                 gsonToMsgpack(entry.getValue(), packer);
             }
-        } catch(IOException e) {}
+        } catch(IOException e) {
+            Log.e(TAG, "Error packing JsonObject to MsgPack", e);
+        }
     }
 
     private static void gsonToMsgpack(JsonNull n, MessagePacker packer) {
         try {
             packer.packNil();
-        } catch(IOException e) {}
+        } catch(IOException e) {
+            Log.e(TAG, "Error packing JsonNull to MsgPack", e);
+        }
     }
 
     private static void gsonToMsgpack(JsonPrimitive primitive, MessagePacker packer) {
@@ -244,11 +253,24 @@ private static void gsonToMsgpack(JsonPrimitive primitive, MessagePacker packer)
                     packer.packByte(number.byteValue());
                 } else {
                     packer.packString(primitive.getAsString());
+                    Log.e(TAG, "Unsupported number type: " + number.getClass().getName());
                 }
             } else {
-                packer.packString(primitive.getAsString());
+                String value = primitive.getAsString();
+                if (Base64Coder.isBase64(value)) {
+                    byte[] decodedData = Base64Coder.decode(value);
+                    packer.packBinaryHeader(decodedData.length);
+                    packer.writePayload(decodedData);
+                } else {
+                    packer.packString(value);
+                }
+                if (!primitive.isString()) {
+                    Log.e(TAG, "Unsupported JsonPrimitive type: " + primitive.getClass().getName());
+                }
             }
-        } catch(IOException e) {}
+        } catch(Exception e) {
+            Log.e(TAG, "Error packing JsonPrimitive to MsgPack", e);
+        }
     }
 
     public static JsonElement msgpackToGson(Value value) {

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

@@ -1,5 +1,6 @@
 package io.ably.lib.objects
 
+import com.google.gson.JsonArray
 import io.ably.lib.types.Callback
 import io.ably.lib.types.ProtocolMessage
 import io.ably.lib.util.Log
@@ -55,6 +56,19 @@ internal class DefaultLiveObjects(private val channelName: String, private val a
         adapter.setChannelSerial(channelName, msg.channelSerial)
       }
     }
+    val objectMessages = msg.state?.map { it.toObjectMessage() } ?: emptyList()
+    Log.v(tag, "Received ${objectMessages.size} object messages for channelName: $channelName")
+    objectMessages.forEach { Log.v(tag, "Object message: $it") }
+  }
+
+  suspend fun send(message: ObjectMessage) {
+    Log.v(tag, "Sending message for channelName: $channelName, message: $message")
+    val protocolMsg = ProtocolMessage().apply {
+      state = JsonArray().apply {
+        add(message.toJsonObject())
+      }
+    }
+    adapter.sendAsync(protocolMsg)
   }
 
   fun dispose() {

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

@@ -23,9 +23,21 @@ internal suspend fun LiveObjectsAdapter.sendAsync(message: ProtocolMessage) {
   deferred.await()
 }
 
-internal enum class MessageFormat(private val value: String) {
+internal enum class ProtocolMessageFormat(private val value: String) {
   MSGPACK("msgpack"),
   JSON("json");
 
   override fun toString(): String = value
 }
+
+internal class Binary(val data: ByteArray?) {
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is Binary) return false
+    return data?.contentEquals(other.data) == true
+  }
+
+  override fun hashCode(): Int {
+    return data?.contentHashCode() ?: 0
+  }
+}

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

@@ -1,7 +1,5 @@
 package io.ably.lib.objects
 
-import java.nio.ByteBuffer
-
 /**
  * An enum class representing the different actions that can be performed on an object.
  * Spec: OOP2
@@ -190,12 +188,12 @@ internal data class ObjectOperation(
    * the initialValue, nonce, and initialValueEncoding will be removed.
    * Spec: OOP3h
    */
-  val initialValue: ByteBuffer? = null,
+  val initialValue: Binary? = null,
 
   /** The initial value encoding defines how the initialValue should be interpreted.
    * Spec: OOP3i
    */
-  val initialValueEncoding: MessageFormat? = null
+  val initialValueEncoding: ProtocolMessageFormat? = null
 )
 
 /**

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

@@ -0,0 +1,44 @@
+package io.ably.lib.objects
+
+import com.google.gson.*
+import io.ably.lib.util.Base64Coder
+import java.lang.reflect.Type
+
+/**
+ * Creates a Gson instance with a custom serializer for live objects.
+ * Omits null values during serialization.
+ */
+
+internal fun ObjectMessage.toJsonObject(): JsonObject {
+  return gson.toJsonTree(this).asJsonObject
+}
+
+internal fun JsonElement.toObjectMessage(): ObjectMessage {
+  return gson.fromJson(this, ObjectMessage::class.java)
+}
+
+private val gson: Gson = createGsonSerializer()
+
+private fun createGsonSerializer(): Gson {
+  return GsonBuilder()
+    .registerTypeAdapter(Binary::class.java, BinarySerializer())
+    .create() // Do not call serializeNulls() to omit null values
+}
+
+// Custom serializer for Binary type
+internal class BinarySerializer : JsonSerializer<Binary>, JsonDeserializer<Binary> {
+  override fun serialize(src: Binary?, typeOfSrc: Type, context: JsonSerializationContext): JsonElement? {
+    src?.data?.let {
+      return JsonPrimitive(Base64Coder.encodeToString(it))
+    }
+    return null // Omit null values
+  }
+
+  override fun deserialize(json: JsonElement?, typeOfT: Type, context: JsonDeserializationContext): Binary? {
+    if (json != null && json.isJsonPrimitive) {
+      val decodedData = Base64Coder.decode(json.asString)
+      return Binary(decodedData)
+    }
+    return null // Return null if the JSON element is not valid
+  }
+}