如何創建一個內部類Parcelable

Question

我需要知道如何創建一個內部類Parcelable，以便它的類型的對象可以通過AIDL傳遞給遠程服務。我找不到任何關於此的信息。

這是我正在嘗試完成的示例代碼，但它不能編譯，因爲Bar類中的CREATOR不能是靜態的（即因爲它在內部類中）。我不能讓Bar成爲靜態內部類，並且我無法將Bar移動到Foo類（系統內的其他依賴項）之外。我還需要知道如何從AIDL文件中引用Bar類。任何幫助是極大的讚賞。

public class Foo implements Parcelable 
{ 
    private int a; 

    public Foo() 
    { 
    } 

    public Foo(Parcel source) 
    { 
     this.a = source.readInt(); 
    } 

    public int describeContents() 
    { 
     return 0; 
    } 

    public void writeToParcel(Parcel dest, int flags) 
    { 
     dest.writeInt(this.a); 
    } 

    public static final Parcelable.Creator<Foo> CREATOR 
    = new Parcelable.Creator<Foo>() 
    { 
     ... 
    } 

    public class Bar implements Parcelable 
    { 
     private int b; 

     public Bar() 
     { 
     } 

     public Bar(Parcel source) 
     { 
      this.b = source.readInt(); 
     } 

     public int describeContents() 
     { 
      return 0; 
     } 

     public void writeToParcel(Parcel dest, int flags) 
     { 
      dest.writeInt(this.b); 
     } 

     public static final Parcelable.Creator<Bar> CREATOR 
     = new Parcelable.Creator<Bar>() 
     { 
      ... 
     } 
    } 
} 

Answer 1

答案是內部類總是可以被製成它自己的類。無論內部類需要從外部類實例訪問什麼功能，反之亦然都可以通過接口或公共API完成。嘗試讓Bar成爲自己的班級。無論Foo Bar的哪些組件需要訪問，通過將Foo的實例傳遞給Bar並實現適當的API來提供。

Answer 2

如果外部類保持對內部類實例的引用，你可以做這樣的：

public class OuterClass implements Parcelable 
{ 
    private InnerClass reference; 

    protected OuterClass(Parcel source) 
    { 
     this.reference = new InnerClass(source); 
     // ... 
    } 

    @Override 
    public void writeToParcel(Parcel destination, int flags) 
    { 
     reference.writeToParcel(destination, flags); 
     // ... 
    } 

    public class InnerClass implements Parcelable 
    { 
     protected InnerClass(Parcel source) 
     { 
      // Read from your parcel. 
     } 

     @Override 
     public void writeToParcel(Parcel destination, int flags) 
     { 
      // Write to your parcel. 
     } 
    } 

    public static final Parcelable.Creator<OuterClass> CREATOR = new Creator<OuterClass>() 
    { 
     @Override 
     public OuterClass createFromParcel(Parcel source) 
     { 
      return new OuterClass(source); 
     } 

     @Override 
     public OuterClass[] newArray(int size) 
     { 
      return new OuterClass[size]; 
     } 
    } 
} 

Answer 3

我最近遇到了同樣的問題，使得內部類的靜態在我的處境工作。

我讀到了爲什麼這會實際工作，它對我來說更有意義，所以我想我會分享。內部類是嵌套在另一個類中的類，並且對其包含的類的實例化有一個引用。通過該引用，它可以訪問包含的類成員，就好像它是包含類本身一樣。因此它被綁定到包含類的實例，因此不能有靜態成員（因爲它們不會被綁定到包含類）。

將嵌套類聲明爲static將其從包含類的實例中解耦出來，因此可以擁有自己的靜態變量（以及常規類可以具有的任何其他類）。當然，它將無法訪問包含類的成員。

Answer 4

您的酒吧不必是可以發送的。您可以將條形字段與Foo字段一起保存，並以createFromParcel(Parcel)方法恢復整個對象。

下面是一些代碼脫穎而出例如：

import android.os.Parcel; 
import android.os.Parcelable; 

public class Foo implements Parcelable { 
    private int mFooData = 0; 
    private Bar mBar; 

    public Foo() { 
    } 

    protected Foo(Parcel in) { 
     mFooData = in.readInt(); 

     // Reading Bar 
     int barData = in.readInt(); 
     mBar = new Bar(barData); 
    } 

    @Override 
    public void writeToParcel(Parcel dest, int flags) { 
     dest.writeInt(mFooData); 

     // Writing Bar 
     dest.writeInt(mBar.getBarData()); 
    } 

    @Override 
    public int describeContents() { 
     return 0; 
    } 

    public static final Creator<Foo> CREATOR = new Creator<Foo>() { 
     @Override 
     public Foo createFromParcel(Parcel in) { 
      return new Foo(in); 
     } 

     @Override 
     public Foo[] newArray(int size) { 
      return new Foo[size]; 
     } 
    }; 

    public class Bar { 
     private int mBarData = 0; 

     public Bar(int barData) { 
      mBarData = barData; 
     } 

     public int getBarData() { 
      return mBarData; 
     } 

     public void setBarData(int mBarData) { 
      this.mBarData = mBarData; 
     } 
    } 
}