Extending a class that implements Parcelable

Question

I have a class, we'll call it class A, that implements Parcelable.

I have a second class, we'll call it class B, that extends class A.

My question is:

How do I write class B's member variables to the Parcel and then write it's parent class's (ie: class A's) member variables to the Parcel (and, subsequently, read them in)?

Is there some nifty trick to not needing to rewrite class A's Parcel code? Or do I just need to rewrite the Parcel code in class A and add additional code for class B's member variables?

Answer 1

How do I write class B's member variables to the Parcel and then write it's parent class's (ie: class A's) member variables to the Parcel

Class B overrides writeToParcel() from Class A, chaining to the superclass and also adding its own objects to the Parcel.

(and, subsequently, read them in)?

Class B implements public static final Parcelable.Creator<MyParcelable> CREATOR in such a way that it can let both classes read their stuff in. If you take the approach of creating a constructor on Class B that takes a Parcel as a constructor parameter, just chain to the superclass constructor (to let Class A do its work), then read Class B's data.

The key will be to do them both in the same order. If you intend to let Class A read its data first, Class A must write its data first.

Is there some nifty trick to not needing to rewrite class A's Parcel code?

Inheritance and chaining to the superclass.

Answer 2

Adding an example, the marked answer is indeed correct, but something more visual seems more suitable for this situation:

This would be the supper class:

public class BasePojo implements Parcelable {

    private String something;

    //what ever other constructor

    //getters and setters

    protected BasePojo(Parcel in) {
        something = in.readString();
    }

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

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

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

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeString(something);
    }

}

And then this would be the child class:

public class ChildPojo extends BasePojo implements Parcelable {

    private int somethingElse;

    //what ever other constructor

    //getters and setters

    protected ChildPojo(Parcel in) {
        super(in);
        somethingElse = in.readInt();
    }

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

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

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

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        super.writeToParcel(parcel, i);
        parcel.writeInt(somethingElse);
    }

}

The marked answer provides a very good explanation, calling super is the key.