Android Parcelize

Parcel是针对Android的优化序列化格式，旨在使我们能够在进程之间传输数据。 这是大多数Android开发人员偶尔需要做的事情，但不是经常这样做。 制作课程Pareclizable实际上需要一点点努力，但是有一个Kotlin扩展可以极大地简化事情。 在这篇文章中，我们将看看@Parcelize以及它如何让我们的生活更轻松。原文

我确信每次我需要实现Parcelable时我并不孤单我有点绝望，因为我知道我需要写一些样板代码，我需要查阅文档以提醒我如何去做 因为这是我不经常做的事情。 Kotlin来救援！

通常，我们需要在进程之间传递的数据类型可以封装在数据类中。 如果数据类实现了Parcelable，我们通常需要包含一些方法：

SimpleDataClass

data class SimpleDataClass(
    val name: String,
    val age: Int
) : Parcelable {
    
    constructor(parcel: Parcel) : this(
        parcel.readString()!!,
        parcel.readInt()
    )

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(name)
        parcel.writeInt(age)
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<SimpleDataClass> {
        override fun createFromParcel(parcel: Parcel): SimpleDataClass {
            return SimpleDataClass(parcel)
        }

        override fun newArray(size: Int): Array<SimpleDataClass?> {
            return arrayOfNulls(size)
        }
    }
}

值得庆幸的是，IntelliJ IDEA和Android Studio包含帮助程序以自动生成此代码，但它仍然增加了我们的数据类。 @Parcelize注释是我们的朋友！ 它仍然处于实验状态，但已经存在了一段时间，所以我们可以希望它很快就能稳定下来。 非常感谢Olivier Genez指出@Parcelize是在Kotlin 1.3.40中进行实验的(本文最初是在发布之前编写的)。 要在1.3.40之前的Kotlin版本中使用@Parcelize，我们需要启用实验性Android扩展：

应用程序/的build.gradle

.
.
.
androidExtensions {
    experimental = true
}
.
.
.

有了@Parcelize，现在可以非常简化我们的数据类：

SimpleDataClass.kt

@Parcelize
data class SimpleDataClass(
    val name: String,
    val age: Int
) : Parcelable

虽然这似乎是Styling Android历史中最短的帖子，但它并不那么简单。 让我们看一个稍微复杂的例子：

CompoundDataClass.kt

@Parcelize
data class CompoundDataClass @JvmOverloads constructor(
    val name: String,
    val simpleDataClass: SimpleDataClass,
    @Transient val transientString: String = ""
) : Parcelable

如果你喜欢一个谜题，那么请研究那个片段，看看你是否可以找出不能按预期工作的东西。

乍一看，人们可能会认为包括SimpleDataClass类型的字段可能会导致问题，但这实际上很好，因为它已经是Parcelable，我们可以使用任何Parcelable类作为字段。 问题实际上是transientString字段，它看起来并不简单。 读取代码，可以理解的是，假设这个接收器在transientString字段中得到一个空字符串，但这不会发生。 这个问题实际上是双重的：首先，Android框架只有一个Parcelable，当它有to;时，其次，@Parcelize不尊重@Transient注释。

要演示第一个，请查看以下Fragment：

MainFragment.kt

class MainFragment : Fragment() {

    private var simple: SimpleDataClass? = null
    private var compound: CompoundDataClass? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let {
            simple = it.getParcelable(ARG_SIMPLE)
            compound = it.getParcelable(ARG_COMPOUND)
        }
        Timber.d("Simple: \"%s\"; Compound: \"%s\"", simple, compound)
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? = inflater.inflate(R.layout.fragment_main, container, false)

    companion object {
        private const val ARG_SIMPLE = "simple"
        private const val ARG_COMPOUND = "compound"

        @JvmStatic
        fun newInstance(simpleDataClass: SimpleDataClass, compound: CompoundDataClass) =
            MainFragment().apply {
                arguments = Bundle().apply {
                    putParcelable(ARG_SIMPLE, simpleDataClass)
                    putParcelable(ARG_COMPOUND, compound)
                }
            }
    }
}

如果我们称之为如下，我们可能期望不同的行为而不是实际发生：

class MainActivity : AppCompatActivity() {

    private val simple = SimpleDataClass("Simple", 1)
    private val compound = CompoundDataClass("Compound", simple, "Transient")

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        supportFragmentManager.beginTransaction().apply {
            replace(R.id.fragment_main, MainFragment.newInstance(simple, compound))
            commit()
        }
    }
}

尽管MainFragment的newInstance()方法中突出显示的行显示我们正在向Bundle添加Parcelable，但如果Android框架需要在整个流程边界中展平它，它只会变得扁平化。 在这种情况下，它在同一个Activity中传递，没有理由将其展平，因此在onCreate()方法的突出显示行中检索CompoundDataClass的相同实例。

我们可以通过添加一些扩展函数来模拟Parcel的扁平化，这些扩展函数模仿Android框架将如何展平和扩展Parcels：

inline fun <reified T : Parcelable> T.collapse(): ByteArray {
    val parcel = Parcel.obtain()
    parcel.writeParcelable(this, 0)
    val byteArray = parcel.marshall()
    parcel.recycle()
    return byteArray
}

inline fun <reified T : Parcelable> Class<T>.expand(byteArray: ByteArray): T {
    val parcel = Parcel.obtain()
    parcel.apply {
        unmarshall(byteArray, 0, byteArray.size)
        setDataPosition(0)
    }
    val parcelable =
        parcel.readParcelable<T>([e-mail])
            ?: throw InstantiationException("Unable to expand $name")
    parcel.recycle()
    return parcelable
}

然后我们可以调用它们来强制扁平化数据类，然后再次展开它(这真的不是任何人在真实场景中需要做的事情，所以请注意代码的注释)：

@JvmStatic
fun newInstance(simpleDataClass: SimpleDataClass, compound: CompoundDataClass) =
    MainFragment().apply {
        arguments = Bundle().apply {
            putParcelable(ARG_SIMPLE, simpleDataClass)
            putParcelable(
                ARG_COMPOUND,
                /*
                 * Don't do this.
                 *
                 * I've done this here in some sample code to demonstrate
                 * that things don't always get serialised. There is no
                 * reason than you'd actually want to do this in this context.
                 *
                 * So...really...don't do this.
                 *
                 * Look, I'm not joking, you really shouldn't do this.
                 *
                 * Even if you're being attacked by a pack of wild dogs and
                 * think that collapsing then immediately re-expanding a
                 * Parcelable will save your life, then I'm sorry, but
                 * it won't. Rest In Peace.
                 *
                 * Perhaps I forgot to mention: you really shouldn't do this.
                 */
                CompoundDataClass::class.java.expand(compound.collapse())
            )
        }
    }

即使我们这样做，我们仍然得到ARG_COMPOUND值中的“瞬态"值，我们从MainFragment的onCreate()方法中的Fragment参数得到。 正如我之前提到的，这是因为@Parcelize生成的字节码将保留所有字段，包括那些标记为@Transient的字段，这与在持久性期间通常处理瞬态字段的方式略有不一致，但我们可以通过查看Kotlin字节码的反编译来证明这一点：

CompoundDataClass.decompiled.java

@Parcelize
public final class CompoundDataClass implements Parcelable {
   @NotNull
   private final String name;
   @NotNull
   private final SimpleDataClass simpleDataClass;
   @NotNull
   private final transient String transientString;
   public static final android.os.Parcelable.Creator CREATOR = new CompoundDataClass.Creator();
    .
    .
    .
   public void writeToParcel(@NotNull Parcel parcel, int flags) {
      Intrinsics.checkParameterIsNotNull(parcel, "parcel");
      parcel.writeString(this.name);
      this.simpleDataClass.writeToParcel(parcel, 0);
      parcel.writeString(this.transientString);
   }

   @Metadata(
      mv = {1, 1, 15},
      bv = {1, 0, 3},
      k = 3
   )
   public static class Creator implements android.os.Parcelable.Creator {
      @NotNull
      public final Object[] newArray(int size) {
         return new CompoundDataClass[size];
      }

      @NotNull
      public final Object createFromParcel(@NotNull Parcel in) {
         Intrinsics.checkParameterIsNotNull(in, "in");
         return new CompoundDataClass(in.readString(), (SimpleDataClass)SimpleDataClass.CREATOR.createFromParcel(in), in.readString());
      }
   }
}

名为transientString的字段与Parcel进行序列化，尽管使用Java transient关键字进行声明。 如果我们想要为这个领域提供短暂性，我们必须手动完成。 实际上值得覆盖这个因为我们可能还需要这样做，如果我们的字段是third-party对象而不是Parcelable并且我们需要实现一个自定义机制来存储足够的数据到Parcel以允许我们re-实例化特定对象时 Parcel扩展回对象实例：

CompoundDataClass.kt

@Parcelize
data class CompoundDataClass @JvmOverloads constructor(
    val name: String,
    val simpleDataClass: SimpleDataClass,
    @Transient val transientString: String = ""
) : Parcelable {

    companion object : Parceler<CompoundDataClass> {

        override fun create(parcel: Parcel): CompoundDataClass {
            val name: String = parcel.readString()!!
            val simple: SimpleDataClass =
                parcel.readParcelable(SimpleDataClass::class.java.classLoader)!!
            return CompoundDataClass(name, simple)
        }

        override fun CompoundDataClass.write(parcel: Parcel, flags: Int) {
            parcel.writeString(name)
            parcel.writeParcelable(simpleDataClass, flags)
        }
    }
}

拥有一个实现create()和CompoundDataClass.write()方法的Parceler伴侣对象使我们能够自定义Parcel的持久性，在这种情况下，允许我们省略transientString字段。 虽然@Transient注释在这里没有达到直接目的，但我认为将它留在这里是好的，因为它使得阅读代码的任何人都更清楚，该字段将不会被持久化。 因此，我们的代码更易于维护和理解。

虽然可能有人认为必须实施这些方法来执行包裹化，但这又回到了我们刚开始的地方(即必须手动完成)。 但是，如果将其与第一个代码片段进行比较，仍然会为我们生成很多样板代码，并且使用Parcelize的结果仍然少得多。

here提供了本文的源代码。