利用Kotlin如何實現(xiàn)Android開發(fā)中的Parcelable詳解

更新時間：2017年12月27日 11:09:10 作者：Haruue Icymoon

這篇文章主要給大家介紹了關(guān)于利用Kotlin如何實現(xiàn)Android開發(fā)中的Parcelable的相關(guān)資料，并且給大家介紹了關(guān)于Kotlin使用parcelable出現(xiàn)：BadParcelableException: Parcelable protocol requires a Parcelable.Creator...問題的解決方法，需要的朋友可以參考下。

坑

先來看看 Android Studio 給的自動實現(xiàn)。

新建一個數(shù)據(jù)類，讓它實現(xiàn) Parcelable

data class Worker(
  var id: Int,
  var name: String,
  var tasks: MutableList<Int>
) : Parcelable

使用 Android Studio 自帶的 Add Parcelable Implementation ，然后你就得到了。。。

 data class Worker(
  var id: Int,
  var name: String,
  var tasks: MutableList<Int>
) : Parcelable {
 constructor(parcel: Parcel) : this(
   parcel.readInt(),
   parcel.readString(),
   TODO("tasks")) {
 }
 override fun writeToParcel(parcel: Parcel, flags: Int) {
  parcel.writeInt(id)
  parcel.writeString(name)
 }
 override fun describeContents(): Int {
  return 0
 }
 companion object CREATOR : Parcelable.Creator<Worker> {
  override fun createFromParcel(parcel: Parcel): Worker {
   return Worker(parcel)
  }
  override fun newArray(size: Int): Array<Worker?> {
   return arrayOfNulls(size)
  }
 }
}

有什么問題呢？

~~至少現(xiàn)在可以編譯過了。。。~~

很明顯的，自動生成的 Parcelable 實現(xiàn)沒有包含對 MutableList 的處理，因為 Parcel 原生只支持 ArrayList ，所以這是需要你自己實現(xiàn)的部分。先來解決這個問題。

雖然名字是 MutableList ，但是實際上這只是 Kotlin 的一個輔助類型，可以用 Tools -> Kotlin -> Show Kotlin Bytecode 查看它編譯成 JVM 字節(jié)碼之后的樣子。

// access flags 0x2
// signature Ljava/util/List<Ljava/lang/Integer;>;
// declaration: java.util.List<java.lang.Integer>
private Ljava/util/List; tasks
@Lorg/jetbrains/annotations/NotNull;() // invisible

點擊 [Decompile] 按鈕還可以直接反編譯到 Java 。

編譯之后 MutableList 變成了 Java 的原生類型 java.util.List 。因此我們只需要在對應(yīng)的地方調(diào)用 Parcel 中對 List 和 ArrayList 的處理方法就可以了。

constructor(parcel: Parcel) : this(
  parcel.readInt(),
  parcel.readString(),
  parcel.readArrayList(Int::class.java.classLoader) as MutableList<Int>) {
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
 parcel.writeInt(id)
 parcel.writeString(name)
 parcel.writeList(tasks)
}

writeList 是可以兼容 Kotlin 的 List 與 MutableList 類型的，但是 ArrayList 還需要強轉(zhuǎn)一下才行，雖然能跑但是會很難看，能不能變好看一點呢？

加一個擴展方法就好了

inline fun <reified T> Parcel.readMutableList(): MutableList<T> {
 @Suppress("UNCHECKED_CAST")
 return readArrayList(T::class.java.classLoader) as MutableList<T>
}

然后就可以這樣寫

constructor(parcel: Parcel) : this(
  parcel.readInt(),
  parcel.readString(),
  parcel.readMutableList()) {
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
 parcel.writeInt(id)
 parcel.writeString(name)
 parcel.writeList(tasks)
}

CREATOR 與 companion object 之爭

Parcelable 有個特殊的要求，在 Android 官方文檔里是這樣寫的

Parcelable interface must also have a non-null static field called CREATOR of a type that implements the Parcelable.Creator interface.

這是因為 Java 的泛型有運行時消除機制的限制， Parcel 需要一個輔助對象來協(xié)助構(gòu)造你的對象以及你的對象的數(shù)組，這就是 CREATOR 。 Parcelable 要求每個實現(xiàn)類都有這個 CREATOR 對象，并且它必須是非空的、公有的、靜態(tài)字段。在 Java 程序中，對于每個類 CREATOR 有非常穩(wěn)定的實現(xiàn)。假如上面的例子是用 Java 寫的，由于我們已經(jīng)有了一個以 Parcel 為參數(shù)的構(gòu)造方法，我們只需要這樣實現(xiàn) CREATOR 。

public static final Creator<Worker> CREATOR = new Creator<Worker>() {
 @Override
 public Worker createFromParcel(Parcel in) {
  return new Worker(in);
 }
 @Override
 public Worker[] newArray(int size) {
  return new Worker[size];
 }
};

那么在 Kotlin 中是什么樣的呢，我們可以先看看 Android Studio 生成的實現(xiàn)：

companion object CREATOR : Parcelable.Creator<Worker> {
 override fun createFromParcel(parcel: Parcel): Worker {
  return Worker(parcel)
 }
 override fun newArray(size: Int): Array<Worker?> {
  return arrayOfNulls(size)
 }
}

在 Kotlin 中，使用命名的 companion object 確實可以生成一個對應(yīng)名字的靜態(tài)字段，并且它是公有的，會隨著類的加載而被創(chuàng)建。但是一個類里只能有一個伴生對象，這個實現(xiàn)把伴生對象給占據(jù)了。雖然并沒有什么影響的樣子，但是看著總是不舒服。

通過 Kotlin 提供的 @JvmField 注解，我們可以讓 Kotlin 編譯器把它作為一個字段進行處理，那我們可以在 companion object 里定義一個 CREATOR ，然后給它加上 @JvmField 注解。

companion object {
 @JvmField val CREATOR = object : Parcelable.Creator<Worker> {
  override fun createFromParcel(parcel: Parcel): Worker {
   return Worker(parcel)
  }
  override fun newArray(size: Int): Array<Worker?> {
   return arrayOfNulls(size)
  }
 }
}

這樣做有什么好處呢？ CREATOR 不再占據(jù)整個 companion object ，而是只是作為 companion object 中的一個字段，代碼干凈了很多。

此外， Kotlin 還對 inline 方法提供了 reified 泛型機制，這種泛型會被編譯器直接具體化而不會像 Java 泛型一樣會被運行時擦除。如果不需要太考慮效率，我們可以定義一個這樣的方法。

inline fun <reified T : Parcelable> parcelableCreatorOf(): Parcelable.Creator<T> = object : Parcelable.Creator<T> {
 override fun newArray(size: Int): Array<T?> = arrayOfNulls(size)
 override fun createFromParcel(source: Parcel?): T =
   T::class.java.getDeclaredConstructor(Parcel::class.java).newInstance(source)
}

在每一個 Parcelable 實現(xiàn)類中就只需要一行代碼了。

companion object {
 @JvmField val CREATOR = parcelableCreatorOf<Worker>()
}

End

最后，再來看看我們的 Parcelable 實現(xiàn)類。

data class Worker(
  var id: Int,
  var name: String,
  var tasks: MutableList<Int>
) : Parcelable {
 constructor(parcel: Parcel) : this(
   parcel.readInt(),
   parcel.readString(),
   parcel.readMutableList())
 override fun writeToParcel(parcel: Parcel, flags: Int) {
  parcel.writeInt(id)
  parcel.writeString(name)
  parcel.writeList(tasks)
 }
 override fun describeContents(): Int = 0
 companion object {
  @JvmField val CREATOR = parcelableCreatorOf<Worker>()
 }
}

本文中的關(guān)鍵代碼，我已經(jīng)封裝成了一個工具類，添加依賴即可使用 -> KotlinUtils

Kotlin使用parcelable出現(xiàn)：BadParcelableException: Parcelable protocol requires a Parcelable.Creator...

在Kotlin編寫代碼過程中，需要用到parcelable來進行傳值，按照以前的寫法，進行序列化：

class PayTypeInfo : Parcelable{
var payMethodId: String? = null//支付方式ID
var payMethodName: String? = null//支付方式名稱
override fun writeToParcel(dest: Parcel, flags: Int) {
dest.writeString(payMethodId)
dest.writeString(payMethodName)
}
override fun describeContents(): Int {
return 0
}
companion object {
val CREATOR: Parcelable.Creator<PayTypeInfo> = object : Parcelable.Creator<PayTypeInfo> {
override fun createFromParcel(source: Parcel): PayTypeInfo {
val payTypeInfo = PayTypeInfo()
payTypeInfo.payMethodId = source.readString()
payTypeInfo.payMethodName = source.readString()
return payTypeInfo
}
override fun newArray(size: Int): Array<PayTypeInfo> {
return newArray(size)
}
}
}
}

這樣序列化的實體類就寫完了，然后進行傳值

val bundle = Bundle()
val typeList = ArrayList<PayTypeInfo>()
bundle.putParcelableArrayList("payType", typeList)

接受數(shù)據(jù)時：

val bundle = intent.extras
val payTypeList = bundle.getParcelableArrayList<PayTypeInfo>("payType")

運行程序，出現(xiàn)錯誤，錯誤代碼為：BadParcelableException: Parcelable protocol requires a Parcelable.Creator...

經(jīng)過查找資料，找到了解決辦法，只需要在代碼CREATOR前面添加@JvmField即可：

@JvmField val CREATOR: Parcelable.Creator<PayTypeInfo> = object : Parcelable.Creator<PayTypeInfo> {
override fun createFromParcel(source: Parcel): PayTypeInfo {
val payTypeInfo = PayTypeInfo()
payTypeInfo.payMethodId = source.readString()
payTypeInfo.payMethodName = source.readString()
return payTypeInfo
}
override fun newArray(size: Int): Array<PayTypeInfo> {
return newArray(size)
}
}

在運行程序，傳值成功

總結(jié)

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。

您可能感興趣的文章: