Gerador de implementação de Parcelable

O plug-in kotlin-parcelize (link em inglês) fornece um gerador de implementação de Parcelable.

Para incluir suporte à interface Parcelable, adicione o plug-in do Gradle ao arquivo build.gradle do app:

plugins {
    id 'kotlin-parcelize'
}

plugins {
    id("kotlin-parcelize")
}

Quando você insere uma anotação com @Parcelize, uma implementação de Parcelable é gerada automaticamente, como mostrado no exemplo a seguir.

import kotlinx.parcelize.Parcelize

@Parcelize
class User(val firstName: String, val lastName: String, val age: Int): Parcelable

@Parcelize requer que todas as propriedades serializadas sejam declaradas no construtor principal. O plug-in emite um aviso em cada propriedade com um campo de backup declarado no corpo da classe. Além disso, não será possível aplicar @Parcelize se alguns dos parâmetros do construtor principal não forem propriedades.

Caso sua classe exija uma lógica de serialização mais avançada, escreva-a dentro de uma classe de acompanhamento:

@Parcelize
data class User(val firstName: String, val lastName: String, val age: Int) : Parcelable {
    private companion object : Parceler<User> {
        override fun User.write(parcel: Parcel, flags: Int) {
            // Custom write implementation
        }

        override fun create(parcel: Parcel): User {
            // Custom read implementation
        }
    }
}

Tipos com suporte

@Parcelize aceita uma grande variedade de tipos:

• Tipos primitivos (e suas versões em caixa)
• Objetos e enumerações
• String, CharSequence
• Duration
• Exception
• Size, SizeF, Bundle, IBinder, IInterface, FileDescriptor
• SparseArray, SparseIntArray, SparseLongArray, SparseBooleanArray
• Todas as implementações de Serializable (incluindo Date) e Parcelable
• Coleções de todos os tipos com suporte: List (mapeado para ArrayList), Set (mapeado para LinkedHashSet), Map (mapeado para LinkedHashMap)
  • Além disso, algumas implementações concretas: ArrayList, LinkedList, SortedSet, NavigableSet, HashSet, LinkedHashSet, TreeSet, SortedMap, NavigableMap, HashMap, LinkedHashMap, TreeMap, ConcurrentHashMap
• Matrizes de todos os tipos com suporte
• Versões anuláveis de todos os tipos com suporte

Parcelers personalizados

Se o tipo não tiver suporte direto, crie um objeto de mapeamento Parceler para ele.

class ExternalClass(val value: Int)

object ExternalClassParceler : Parceler<ExternalClass> {
    override fun create(parcel: Parcel) = ExternalClass(parcel.readInt())

    override fun ExternalClass.write(parcel: Parcel, flags: Int) {
        parcel.writeInt(value)
    }
}

É possível aplicar parcelers externos usando anotações @TypeParceler ou @WriteWith:

// Class-local parceler
@Parcelize
@TypeParceler<ExternalClass, ExternalClassParceler>()
class MyClass(val external: ExternalClass) : Parcelable

// Property-local parceler
@Parcelize
class MyClass(@TypeParceler<ExternalClass, ExternalClassParceler>() val external: ExternalClass) : Parcelable

// Type-local parceler
@Parcelize
class MyClass(val external: @WriteWith<ExternalClassParceler>() ExternalClass) : Parcelable

Ignorar propriedades da serialização

Caso queira evitar que alguma propriedade seja parcelada, use o @IgnoredOnParcel. Ele também pode ser usado em propriedades o corpo da classe para silenciar avisos sobre a propriedade que não está sendo serializada. As propriedades do construtor anotadas com @IgnoredOnParcel precisam ter um valor padrão .

@Parcelize
class MyClass(
    val include: String,
    // Don't serialize this property
    @IgnoredOnParcel val ignore: String = "default"
): Parcelable {
    // Silence a warning
    @IgnoredOnParcel
    val computed: String = include + ignore
}

Usar android.os.Parcel.writeValue para serializar uma propriedade

Você pode anotar um tipo com @RawValue para fazer uso de Parcelize Parcel.writeValue para essa propriedade.

@Parcelize
class MyClass(val external: @RawValue ExternalClass): Parcelable

Isso poderá falhar no tempo de execução se o valor da propriedade não for nativamente compatível com o Android.

O Parcelize também pode exigir que você use essa anotação quando não houver outra serializar a propriedade.

Parceria com classes e interfaces seladas

A divisão requer uma classe para parcelar para não ser abstrata. Essa limitação não não são válidas para classes seladas. Quando a anotação @Parcelize é usada em um selada, ela não precisa ser repetida para as classes derivadas.

@Parcelize
sealed class SealedClass: Parcelable {
    class A(val a: String): SealedClass()
    class B(val b: Int): SealedClass()
}

@Parcelize
class MyClass(val a: SealedClass.A, val b: SealedClass.B, val c: SealedClass): Parcelable

Feedback

Se você encontrar problemas com o plug-in do Gradle kotlin-parcelize, registre um bug.