Generatore di implementazioni parcelle

Il plug-in kotlin-parcelize fornisce un Generatore di implementazione di Parcelable.

Per includere il supporto di Parcelable, aggiungi il plug-in Gradle al tuo build.gradle file dell'app:

plugins {
    id 'kotlin-parcelize'
}

plugins {
    id("kotlin-parcelize")
}

Quando annota un corso con @Parcelize, un'implementazione Parcelable viene generato automaticamente, come illustrato nell'esempio seguente:

import kotlinx.parcelize.Parcelize

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

@Parcelize richiede che tutte le proprietà serializzate siano dichiarate nel costruttore principale. Il plug-in genera un avviso per ogni proprietà. con un campo di supporto dichiarato nel corpo della classe. Inoltre, non puoi applica @Parcelize se alcuni dei parametri del costruttore primari sono non proprietà.

Se la classe richiede una logica di serializzazione più avanzata, scrivila all'interno di una classe companion:

@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
        }
    }
}

Tipi supportati

@Parcelize supporta una vasta gamma di tipi:

• Tipi primitivi (e le relative versioni con casella)
• Oggetti ed enum
• String, CharSequence
• Duration
• Exception
• Size, SizeF, Bundle, IBinder, IInterface e FileDescriptor
• SparseArray, SparseIntArray, SparseLongArray, SparseBooleanArray
• Tutte le implementazioni Serializable (incluso Date) e Parcelable
• Raccolte di tutti i tipi supportati: List (mappata a ArrayList), Set (mappato a LinkedHashSet), Map (mappato a LinkedHashMap)
  • Anche alcune implementazioni concrete sono: ArrayList, LinkedList, SortedSet, NavigableSet, HashSet, LinkedHashSet, TreeSet, SortedMap, NavigableMap, HashMap, LinkedHashMap, TreeMap, ConcurrentHashMap
• Array di tutti i tipi supportati
• Versioni nullo di tutti i tipi supportati

Parceler personalizzati

Se il tuo tipo non è supportato direttamente, puoi scrivere un Parceler di mappatura.

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)
    }
}

Puoi applicare parcellatori esterni utilizzando le annotazioni @TypeParceler o @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

Saltare le proprietà dalla serializzazione

Se vuoi evitare che alcune proprietà vengano divise, utilizza la proprietà Annotazione @IgnoredOnParcel. Può essere utilizzato anche nelle proprietà all'interno di un il corpo della classe per silenziare gli avvisi sulla proprietà non serializzata. Le proprietà del costruttore annotate con @IgnoredOnParcel devono avere un valore predefinito valore.

@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
}

Utilizzare android.os.Parcel.writeValue per serializzare una proprietà

Puoi annotare un tipo con @RawValue per utilizzare l'opzione Parcelize Parcel.writeValue per la proprietà.

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

Questa operazione potrebbe non riuscire in fase di runtime se il valore della proprietà non è in modo nativo su Android.

La suddivisione in pacchetti potrebbe richiedere l'uso di questa annotazione quando non sono presenti altre per serializzare la proprietà.

Pacchettizza i dati con classi e interfacce sigillate

Per la pacchettizzazione, la partizione deve essere una classe non astratta. Questa limitazione non sono validi per i corsi chiusi. Quando l'annotazione @Parcelize viene utilizzata su una Sealed, non deve essere ripetuta per le classi risultanti.

@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 riscontri problemi con il plug-in Gradle di kotlin-parcelize, puoi segnalare un bug.