Ability to get elementSerializer from collection serializers like ListLikeSerializer

[kuanyingchou]

What is your use-case and why do you need this feature?

Hi, I'm working on a custom format for converting serializable objects to/from android.os.Bundle at AndroidX. I got a problem for using format-specific types to support types like Parcelable , which is a supported type by our format. To deserialize this type correctly, android.os.Bundle sometimes needs a java.lang.ClassLoader. We can add that to our custom Parcelable serializer, however, it doesn't work well for collection types like Array<Parcelable>, which is also supported by our format. And I have to use reflection to retrieve the classLoader stored in our custom Parcelable serializer from the built-in ArraySerializer, which is pretty bad for us.

User's code could be like this, and the classLoader is a property of MyParcelableSerializer:

val parcelableArr: Array<@Serializable(with = MyParcelableSerializer::class) MyParcelable>

And our decodeSerializableValue() could be like this:

return when (strategy.descriptor) {
    parcelableArrayDescriptor -> {
        val cl = getClassLoader(strategy)
        bundle.classLoader = cl
        bundle.getParcelableArray(key)
    }
    ...
}

Describe the solution you'd like

I think it's a very specific ask and I don't know if it makes sense for other custom formats, but is it possible to open up getting elementSerializer from collection serializers like ListLikeSerializer or CollectionLikeSerializer? Or maybe let them implement some kind of public interface if you want to keep the classes internal:

public interface ContainerSerializer<Element> { public val elementSerializer: KSerializer<Element> }

So that we can implement getClassLoader as something like:

fun getClassLoader(strategy: DeserializationStrategy): ClassLoader = 
        ((strategy as ContainerSerializer<*>).elementSerializer as ParcelableSerializer).classLoader

I don't know if this is the best approach. Any suggestions are welcome. Thanks!

[pdvrieze]

It is possible to do this by having a "special" (canary) decoder that you use to decode the list. The collection serializer will call deserializeSerializableElement(...) with the serializer as parameter (you can store this and throw an exception to get out of serialization). But this is indeed clunky (and an API would be better/desirable).

[kuanyingchou]

Haha, thanks! That's very hacky but super clever! And should still be better than reflection. Let me give it a try!

[kuanyingchou]

Can confirm it works with something like this. Thanks again!

private fun getElementSerializer(strategy: DeserializationStrategy<*>): DeserializationStrategy<*>? {
    val hackyDecoder = HackyDecoder()
    try {
        strategy.deserialize(hackyDecoder)
    } catch(e: Exception) {
        // WAI
    }
    return hackyDecoder.elementSerialzier
}

@OptIn(ExperimentalSerializationApi::class)
private class HackyDecoder: AbstractDecoder() {
    override val serializersModule: SerializersModule = EmptySerializersModule()
    var elementSerialzier: DeserializationStrategy<*>? = null

    override fun <T> decodeSerializableElement(
        descriptor: SerialDescriptor,
        index: Int,
        deserializer: DeserializationStrategy<T>,
        previousValue: T?
    ): T {
        elementSerialzier = deserializer
        error("break")
    }
    override fun decodeElementIndex(descriptor: SerialDescriptor): Int = 0
}

[pdvrieze]

Can confirm it works with something like this. Thanks again!

I know it does work, and you're welcome. I had to do things very similar to this for the xml format (at least in older versions of the serialization library) - things such as figuring out the base class for a polymorphic serializer.