Working Timestamps and serverTimestamps on Android

Author: litclimbing

firebase-common/src/androidMain/kotlin/dev/gitlive/firebase/_decoders.kt

@@ -10,14 +10,14 @@ import kotlinx.serialization.SerializationException
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.descriptors.StructureKind
 
-actual fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor, decodeDouble: (value: Any?) -> Double?): CompositeDecoder = when(descriptor.kind as StructureKind) {
+actual fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor): CompositeDecoder = when(descriptor.kind as StructureKind) {
         StructureKind.CLASS, StructureKind.OBJECT -> (value as Map<*, *>).let { map ->
-            FirebaseClassDecoder(decodeDouble, map.size, { map.containsKey(it) }) { desc, index -> map[desc.getElementName(index)] }
+            FirebaseClassDecoder(map.size, { map.containsKey(it) }, {v -> getDecoder(v)}) { desc, index -> map[desc.getElementName(index)] }
         }
         StructureKind.LIST -> (value as List<*>).let {
-            FirebaseCompositeDecoder(decodeDouble, it.size) { _, index -> it[index] }
+            FirebaseCompositeDecoder(it.size, {v -> getDecoder(v)}) { _, index -> it[index] }
         }
         StructureKind.MAP -> (value as Map<*, *>).entries.toList().let {
-            FirebaseCompositeDecoder(decodeDouble, it.size) { _, index -> it[index/2].run { if(index % 2 == 0) key else value }  }
+            FirebaseCompositeDecoder(it.size, {v -> getDecoder(v)}) { _, index -> it[index/2].run { if(index % 2 == 0) key else value }  }
         }
     }

firebase-common/src/androidMain/kotlin/dev/gitlive/firebase/_encoders.kt

@@ -12,33 +12,22 @@ import kotlin.collections.set
 actual fun FirebaseEncoder.structureEncoder(descriptor: SerialDescriptor): CompositeEncoder = when (descriptor.kind as StructureKind) {
     StructureKind.LIST -> mutableListOf<Any?>()
         .also { value = it }
-        .let { FirebaseCompositeEncoder(shouldEncodeElementDefault, positiveInfinity) { _, index, value -> it.add(index, value) } }
+        .let { FirebaseCompositeEncoder(shouldEncodeElementDefault, {getEncoder(shouldEncodeElementDefault)}) { _, index, value -> it.add(index, value) } }
     StructureKind.MAP -> mutableListOf<Any?>()
         .let {
             FirebaseCompositeEncoder(
                 shouldEncodeElementDefault,
-                positiveInfinity,
+                {getEncoder(shouldEncodeElementDefault)},
                 { value = it.chunked(2).associate { (k, v) -> k to v } }) { _, _, value -> it.add(value) }
         }
-    StructureKind.CLASS -> mutableMapOf<Any?, Any?>()
+    StructureKind.OBJECT, StructureKind.CLASS -> mutableMapOf<Any?, Any?>()
         .also { value = it }
         .let {
-            FirebaseCompositeEncoder(shouldEncodeElementDefault, positiveInfinity) { _, index, value ->
-                it[descriptor.getElementName(index)] = value
+            FirebaseCompositeEncoder(shouldEncodeElementDefault, {getEncoder(shouldEncodeElementDefault)}) { _, index, value ->
+                it[descriptor.getElementName(
+                    index
+                )] = value
             }
         }
-    StructureKind.OBJECT -> {
-        when (descriptor.serialName) {
-            "firebaseTimestamp" -> FirebaseTimestampCompositeEncoder { value = it }
-            else -> mutableMapOf<Any?, Any?>()
-                .also { value = it }
-                .let {
-                    FirebaseCompositeEncoder(shouldEncodeElementDefault, positiveInfinity) { _, index, value ->
-                        it[descriptor.getElementName(
-                            index
-                        )] = value
-                    }
-                }
-        }
-    }
+
 }

firebase-common/src/androidMain/kotlin/dev/gitlive/firebase/_types.kt

@@ -16,28 +16,29 @@ import kotlinx.serialization.modules.SerializersModule
 import kotlinx.serialization.serializer
 
 @Suppress("UNCHECKED_CAST")
-inline fun <reified T> decode(value: Any?, noinline decodeDouble: (value: Any?) -> Double? = { null }): T {
+inline fun <reified T> decode(value: Any?): T {
     val strategy = serializer<T>()
-    return decode(strategy as DeserializationStrategy<T>, value, decodeDouble)
+    return decode(strategy as DeserializationStrategy<T>, value)
 }
 
-fun <T> decode(strategy: DeserializationStrategy<T>, value: Any?, decodeDouble: (value: Any?) -> Double? = { null }): T {
+fun <T> decode(strategy: DeserializationStrategy<T>, value: Any?): T {
     require(value != null || strategy.descriptor.isNullable) { "Value was null for non-nullable type ${strategy.descriptor.serialName}" }
-    return FirebaseDecoder(value, decodeDouble).decodeSerializableValue(strategy)
+    return FirebaseDecoder(value).decodeSerializableValue(strategy)
 }
 
-expect fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor, decodeDouble: (value: Any?) -> Double?): CompositeDecoder
+expect fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor): CompositeDecoder
 
-class FirebaseDecoder(internal val value: Any?, private val decodeDouble: (value: Any?) -> Double?) : Decoder {
+open class FirebaseDecoder(internal val value: Any?) : Decoder {
+    open fun getDecoder(value: Any?) : FirebaseDecoder = FirebaseDecoder(value)
 
     override val serializersModule: SerializersModule
         get() = EmptySerializersModule
 
-    override fun beginStructure(descriptor: SerialDescriptor) = structureDecoder(descriptor, decodeDouble)
+    override fun beginStructure(descriptor: SerialDescriptor) = structureDecoder(descriptor)
 
     override fun decodeString() = decodeString(value)
 
-    override fun decodeDouble() = decodeDouble(value, decodeDouble)
+    override fun decodeDouble() = decodeDouble(value)
 
     override fun decodeLong() = decodeLong(value)
 
@@ -60,15 +61,15 @@ class FirebaseDecoder(internal val value: Any?, private val decodeDouble: (value
     override fun decodeNull() = decodeNull(value)
 
     @ExperimentalSerializationApi
-    override fun decodeInline(inlineDescriptor: SerialDescriptor) = FirebaseDecoder(value, decodeDouble)
+    override fun decodeInline(inlineDescriptor: SerialDescriptor) = FirebaseDecoder(value)
 }
 
 class FirebaseClassDecoder(
-    decodeDouble: (value: Any?) -> Double?,
     size: Int,
     private val containsKey: (name: String) -> Boolean,
+    getDecoder: (Any?)->FirebaseDecoder,
     get: (descriptor: SerialDescriptor, index: Int) -> Any?
-) : FirebaseCompositeDecoder(decodeDouble, size, get) {
+) : FirebaseCompositeDecoder(size, getDecoder, get) {
     private var index: Int = 0
 
     override fun decodeSequentially() = false
@@ -81,8 +82,8 @@ class FirebaseClassDecoder(
 }
 
 open class FirebaseCompositeDecoder constructor(
-    private val decodeDouble: (value: Any?) -> Double?,
     private val size: Int,
+    private val getDecoder: (Any?)->FirebaseDecoder,
     private val get: (descriptor: SerialDescriptor, index: Int) -> Any?
 ): CompositeDecoder {
 
@@ -99,15 +100,15 @@ open class FirebaseCompositeDecoder constructor(
         index: Int,
         deserializer: DeserializationStrategy<T>,
         previousValue: T?
-    ) = deserializer.deserialize(FirebaseDecoder(get(descriptor, index), decodeDouble))
+    ) = deserializer.deserialize(getDecoder(get(descriptor, index)))
 
     override fun decodeBooleanElement(descriptor: SerialDescriptor, index: Int) = decodeBoolean(get(descriptor, index))
 
     override fun decodeByteElement(descriptor: SerialDescriptor, index: Int) = decodeByte(get(descriptor, index))
 
     override fun decodeCharElement(descriptor: SerialDescriptor, index: Int) = decodeChar(get(descriptor, index))
 
-    override fun decodeDoubleElement(descriptor: SerialDescriptor, index: Int) = decodeDouble(get(descriptor, index), decodeDouble)
+    override fun decodeDoubleElement(descriptor: SerialDescriptor, index: Int) = decodeDouble(get(descriptor, index))
 
     override fun decodeFloatElement(descriptor: SerialDescriptor, index: Int) = decodeFloat(get(descriptor, index))
 
@@ -133,15 +134,15 @@ open class FirebaseCompositeDecoder constructor(
 
     @ExperimentalSerializationApi
     override fun decodeInlineElement(descriptor: SerialDescriptor, index: Int): Decoder =
-        FirebaseDecoder(get(descriptor, index), decodeDouble)
+        getDecoder(get(descriptor, index))
 }
 
 private fun decodeString(value: Any?) = value.toString()
 
-private fun decodeDouble(value: Any?, decodeDouble: (value: Any?) -> Double?) = when(value) {
+private fun decodeDouble(value: Any?) = when(value) {
     is Number -> value.toDouble()
     is String -> value.toDouble()
-    else -> decodeDouble(value) ?: throw SerializationException("Expected $value to be double")
+    else -> throw SerializationException("Expected $value to be double")
 }
 
 private fun decodeLong(value: Any?) = when(value) {

firebase-common/src/commonMain/kotlin/dev/gitlive/firebase/decoders.kt

@@ -15,23 +15,24 @@ import kotlinx.serialization.modules.SerializersModule
 fun <T> encode(
     strategy: SerializationStrategy<T>,
     value: T,
-    shouldEncodeElementDefault: Boolean,
-    positiveInfinity: Any = Double.POSITIVE_INFINITY
+    shouldEncodeElementDefault: Boolean
 ): Any? =
-    FirebaseEncoder(shouldEncodeElementDefault, positiveInfinity).apply {
+    FirebaseEncoder(shouldEncodeElementDefault).apply {
         encodeSerializableValue(
             strategy,
             value
         )
     }.value//.also { println("encoded $it") }
 
-inline fun <reified T> encode(value: T, shouldEncodeElementDefault: Boolean, positiveInfinity: Any = Double.POSITIVE_INFINITY): Any? = value?.let {
-    FirebaseEncoder(shouldEncodeElementDefault, positiveInfinity).apply { encodeSerializableValue(it.firebaseSerializer(), it) }.value
+@Suppress("UNCHECKED_CAST")
+inline fun <reified T> encode(value: T, shouldEncodeElementDefault: Boolean): Any? = value?.let {
+    FirebaseEncoder(shouldEncodeElementDefault).apply { encodeSerializableValue(firebaseSerializer(it) as SerializationStrategy<T>, it) }.value
 }
 
 expect fun FirebaseEncoder.structureEncoder(descriptor: SerialDescriptor): CompositeEncoder
 
-class FirebaseEncoder(internal val shouldEncodeElementDefault: Boolean, positiveInfinity: Any) : TimestampEncoder(positiveInfinity), Encoder {
+open class FirebaseEncoder(internal val shouldEncodeElementDefault: Boolean) : Encoder {
+    open fun getEncoder(shouldEncodeElementDefault: Boolean): FirebaseEncoder = FirebaseEncoder(shouldEncodeElementDefault)
 
     var value: Any? = null
 
@@ -51,7 +52,7 @@ class FirebaseEncoder(internal val shouldEncodeElementDefault: Boolean, positive
     }
 
     override fun encodeDouble(value: Double) {
-        this.value = encodeTimestamp(value)
+        this.value = value
     }
 
     override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) {
@@ -88,63 +89,15 @@ class FirebaseEncoder(internal val shouldEncodeElementDefault: Boolean, positive
 
     @ExperimentalSerializationApi
     override fun encodeInline(inlineDescriptor: SerialDescriptor): Encoder =
-        FirebaseEncoder(shouldEncodeElementDefault, positiveInfinity)
-}
-
-abstract class TimestampEncoder(internal val positiveInfinity: Any) {
-    fun encodeTimestamp(value: Double) = when (value) {
-        Double.POSITIVE_INFINITY -> positiveInfinity
-        else -> value
-    }
-}
-
-class FirebaseTimestampCompositeEncoder(val onSet: (Any)->Unit) : CompositeEncoder {
-    var nanos: Int = 0
-    var seconds: Long = 0
-
-    override val serializersModule = EmptySerializersModule
-
-    override fun encodeBooleanElement(descriptor: SerialDescriptor, index: Int, value: Boolean) = throw IllegalStateException()
-    override fun encodeByteElement(descriptor: SerialDescriptor, index: Int, value: Byte) = throw IllegalStateException()
-    override fun encodeCharElement(descriptor: SerialDescriptor, index: Int, value: Char) = throw IllegalStateException()
-    override fun encodeDoubleElement(descriptor: SerialDescriptor, index: Int, value: Double) = throw IllegalStateException()
-    override fun encodeFloatElement(descriptor: SerialDescriptor, index: Int, value: Float) = throw IllegalStateException()
-    @ExperimentalSerializationApi
-    override fun encodeInlineElement(descriptor: SerialDescriptor, index: Int): Encoder = throw IllegalStateException()
-
-    override fun encodeIntElement(descriptor: SerialDescriptor, index: Int, value: Int) {
-        nanos = value
-    }
-
-    override fun encodeLongElement(descriptor: SerialDescriptor, index: Int, value: Long) {
-        seconds = value
-    }
-
-    @ExperimentalSerializationApi
-    override fun <T : Any> encodeNullableSerializableElement(
-        descriptor: SerialDescriptor,
-        index: Int,
-        serializer: SerializationStrategy<T>,
-        value: T?
-    )  = throw IllegalStateException()
-
-    override fun <T> encodeSerializableElement(descriptor: SerialDescriptor, index: Int, serializer: SerializationStrategy<T>, value: T) = throw IllegalStateException()
-
-    override fun encodeShortElement(descriptor: SerialDescriptor, index: Int, value: Short)  = throw IllegalStateException()
-
-    override fun encodeStringElement(descriptor: SerialDescriptor, index: Int, value: String)  = throw IllegalStateException()
-
-    override fun endStructure(descriptor: SerialDescriptor) {
-        onSet(Timestamp(nanos, seconds).asNative())
-    }
+        getEncoder(shouldEncodeElementDefault)
 }
 
 open class FirebaseCompositeEncoder constructor(
     private val shouldEncodeElementDefault: Boolean,
-    positiveInfinity: Any,
+    private val getEncoder: (Boolean)->FirebaseEncoder,
     private val end: () -> Unit = {},
     private val set: (descriptor: SerialDescriptor, index: Int, value: Any?) -> Unit
-) : TimestampEncoder(positiveInfinity), CompositeEncoder {
+) : CompositeEncoder {
 
     override val serializersModule = EmptySerializersModule
 
@@ -167,7 +120,7 @@ open class FirebaseCompositeEncoder constructor(
         descriptor,
         index,
         value?.let {
-            FirebaseEncoder(shouldEncodeElementDefault, positiveInfinity).apply {
+            getEncoder(shouldEncodeElementDefault).apply {
                 encodeSerializableValue(serializer, value)
             }.value
         }
@@ -181,7 +134,7 @@ open class FirebaseCompositeEncoder constructor(
     ) = set(
         descriptor,
         index,
-        FirebaseEncoder(shouldEncodeElementDefault, positiveInfinity).apply {
+        getEncoder(shouldEncodeElementDefault).apply {
             encodeSerializableValue(serializer, value)
         }.value
     )
@@ -192,7 +145,7 @@ open class FirebaseCompositeEncoder constructor(
 
     override fun encodeCharElement(descriptor: SerialDescriptor, index: Int, value: Char) = set(descriptor, index, value)
 
-    override fun encodeDoubleElement(descriptor: SerialDescriptor, index: Int, value: Double) = set(descriptor, index, encodeTimestamp(value))
+    override fun encodeDoubleElement(descriptor: SerialDescriptor, index: Int, value: Double) = set(descriptor, index, value)
 
     override fun encodeFloatElement(descriptor: SerialDescriptor, index: Int, value: Float) = set(descriptor, index, value)
 
@@ -206,7 +159,7 @@ open class FirebaseCompositeEncoder constructor(
 
     @ExperimentalSerializationApi
     override fun encodeInlineElement(descriptor: SerialDescriptor, index: Int): Encoder =
-        FirebaseEncoder(shouldEncodeElementDefault, positiveInfinity)
+        FirebaseEncoder(shouldEncodeElementDefault)
 }