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?

CommonsWare · Accepted Answer · 2012-05-31T21:38:53.707

24

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.

edited May 31 '12 at 21:38

answered May 31 '12 at 21:24

CommonsWare

986,068
189
2,389
2,491

How do I call the superclass's constructor? – Andrew Jun 04 '12 at 14:42
@Andrew: The same way you do in any Java class: `super(...)` (where `...` is your list of parameters, if any) as the first line in your own constructor. – CommonsWare Jun 04 '12 at 14:49
@CommonsWare Ok so i've added the super(parcel); line in my Class B Constructor; how do I now ensure I call the superclass in writing to the parcel? – Jethro May 31 '16 at 16:00
1

@Jethro: Call `super.writeToParcel()` in the subclass' `writeToParcel()` method. – CommonsWare May 31 '16 at 16:01
@CommonsWare Thanks for the advice! Put me in the right direction :D – Jethro Jun 02 '16 at 13:05

score 4 · Answer 2 · answered Feb 22 '18 at 17:55

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.

score 1 · Answer 3 · edited May 23 '17 at 12:26

1

It is a little complex, but the trick is to use Reflection to get the types of subclass's members and to sort the members so that you can read and write the data back in the same exact order using the proper types.

I have implemented the solution for class A here: https://github.com/awadalaa/Android-Global-Parcelable

so now you can make any class parcelable by simply extending this class.

edited May 23 '17 at 12:26

Community

1
1

answered Sep 27 '13 at 20:50

Alaa Awad

3,612
6
25
35

4

Parcelable concept has been introduced in Android to avoid reflection during the serialization. If you are going to reflection then you can simply implement Serializable marker interface. – Sankar V Oct 05 '15 at 10:03

Extending a class that implements Parcelable

3 Answers3

Linked