Get Class Loader Generika für verschachtelte Parcelgenerische Feld Parsen

Question

ich einen Wrapper von Parcelable generischem Typ, aber Parcel Konstruieren nicht zu kompilieren, weil T Klasse nicht allgemein bestimmt werden kann

class MyItem<T : Parcelable> (val model: T) : Parcelable { 
    constructor(parcel: Parcel) : 
     this(parcel.readParcelable(T::class.java.classLoader)) { 

    } 
} 

Gibt es eine Lösung für diesen Fall?

Answer 1

Um das ganze Bild hier zu bekommen ist, was ich am Ende mit:

Der Anwendungsfall ist man hat eine Parcelable generische Instanz es model nennen lassen, die mit gemeinsamen Eigenschaften von Parcelable Wrapper abgeschlossen sein soll um das Modell nicht mit extrinsischen Feldern zu belasten. Zum Beispiel Item Wrapper.

Im Beispiel unter dem Wrapper zusätzliche Eigenschaft gibt uns irgendeine Art von index:

class Item<T : Parcelable> (val model: T, val index: Int) : Parcelable { 

    constructor(parcel: Parcel) : 
     this(parcel.readParcelable(
      Item<T>::model.javaClass.classLoader), 
      parcel.readInt() 
     ) {} 

    override fun writeToParcel(parcel: Parcel?, flag: Int) { 
     parcel?.writeParcelable(model, 0) 
     parcel?.writeInt(index) 
    } 

    override fun describeContents(): Int { 
     return 0 
    } 

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

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

Also am Ende wir so etwas wie haben: Item(Person("John"), 0), Item(Person("Bill"), 1) ...

class PersonPagerFragment() : BasePagerFragment<Person>() { 
    companion object { 
     fun newInstance(itemList: ArrayList<Item<Person>>) 
      : PersonPagerFragment { 

      val args = Bundle() 
      val fragment = PersonPagerFragment() 
      args.putParcelableArrayList("items", itemList) 
      fragment.arguments = args 

      return fragment 
     } 
    } 
} 

Verlängerung Klasse wie:

class BasePagerFragment<T : Parcelable> : Fragment(){ 
    protected fun readBundle(bundle: Bundle?) { 
     bundle.getParcelableArrayList<Item<T>>("items")  
    } 
} 

Answer 2

Sie können eine reified inline function als eine Fabrikmethode verwenden, um dies zu erreichen. Ich bevorzuge dies auf einem Begleitobjekt. Hier ist ein MCVE:

class MyItem<T> (val model: T) { 
    companion object { 
     inline fun <reified T> from(parcel : T) : MyItem<T> { 
      return MyItem<T>(T::class.java.newInstance()) 
     } 
    } 
} 
fun main(args: Array<String>) { 
    val mi = MyItem.from("hi") 
    println("mi is a ${mi::class}") 
} 

Answer 3

Wenn Sie Notwendigkeit einen Parcel-Typkonstruktor haben, Sie könnten das ändern der primäre Konstruktor zu sein und herauszufinden, die Art des MyItem aus dann.

class Parcel 

class MyItem(val parcel: Parcel) { 
    inline fun <reified T> model() : T { 
     // You code would be calling 
     // `parcel.readParcelable(T::class.java.classLoader)` 
     return T::class.java.newInstance() as T 
    } 
} 
fun main(args: Array<String>) { 
    // You don't ned to know the out type when constructing MyItem. 
    val mi = MyItem(Parcel()) 

    // But you do need to know it when calling model() 
    val model : String = mi.model() 

    println("mi.model is a ${model::class}") 
}