Android - Easier/Faster/Less tedious way to implement Parcelable?

Question

Whenever I want my class to implement Parcelable, it always goes down to the same thing. My code always looks like this:

public class MyClass implements Parcelable{

    private String stringA;
    private int intA;
    .
    .
    .

    //## Parcelable code - START ################################
    @Override
    public int describeContents() {
          return this.hashCode();
    }
    @Override
    public void writeToParcel(Parcel dest, int flags) {

     dest.writeString(stringA);
     dest.writeInt(intA);
     .
     .
     .
    }
    public static final Parcelable.Creator<MyClass> CREATOR = new Parcelable.Creator<MyClass>() {

    @Override
    public MyClass createFromParcel(Parcel in) {
            return new MyClass(in); 
    }

    @Override
    public MyClass[] newArray(int size) {
            return new MyClass[size];
    }
    };
    public MyClass(Parcel in){

        this.cancellationnote   = in.readString();
        this.intA = in.readInt();
        .
        .
        .
    }
    //## Parcelable code - END ################################
    }

But that is very repetitive, tedious and error prone. Is there an easier way to do it?

You implement an interface, so you HAVE to implement ALL the methods. If you also extend a superclass, you can inherit its functionality. — Ron, Dec 04 '13 at 04:33
You can always use `Serializable` if performance is not an issue for you. Take a look at http://stackoverflow.com/questions/5550670/benefit-of-using-parcelable-instead-of-serializing-object for the differences between the 2. — Ehtesh Choudhury, Dec 04 '13 at 04:46
I'm not very knowlegdeable about Android, but seems like one could use reflection here. Again, if speed is not an issue. — user949300, Dec 04 '13 at 04:48
Thank you for the reply guys. That is an interesting topic @Shurane. I guess there is no way around it other then perhaps using reflection like user949300 suggested (which would defeat the purpose of implementing Parcelable because the performance would be compromised). — Bitcoin Cash - ADA enthusiast, Dec 04 '13 at 21:08

score 1 · Answer 1 · answered Mar 10 '15 at 13:47

1

There is an easier way by using "Parcelabler" by Dallas Gutauckis. It generates the code automatically for your class:

http://www.parcelabler.com/

Still, it doesn't make the code any shorter.

answered Mar 10 '15 at 13:47

W0lfw00ds

2,018
14
23

link not valid anymore... – Lino Feb 01 '22 at 07:58

score 0 · Accepted Answer · answered Jun 01 '15 at 10:55

0

Android Studio 1.3 has now a "Quick Fix" which generates the Parcelable implementation automatically for your class.

It still, however, puts all the boilerplate code in your own class (but I guess there is no way around it).

answered Jun 01 '15 at 10:55

Bitcoin Cash - ADA enthusiast

11,457
16
83
103

John Ericksen · Answer 3 · 2015-10-09T16:38:30.813

Using Parceler, you simply have to annotate your bean with @Parcel and use the Parcels utility class to wrap/unwrap when you want to use the bean as a Parcelable:

@Parcel
public class MyClass {
    String stringA;
    int intA;
}

Be sure to make your fields non-private if you're using the default FIELD sealization strategy.

The Parcels utility class usage:

intent.putExtra("example", Parcels.wrap(myClass));
//...
Example example = MyClass .unwrap(getIntent().getParcelableExtra("example"));

To import Parceler in Gradle, add the following lines along with the apt plugin:

compile "org.parceler:parceler-api:1.0.3"
apt "org.parceler:parceler:1.0.3"

In my book this is the easiest / less tedious way to use Parcelables in Android.

Android - Easier/Faster/Less tedious way to implement Parcelable?

3 Answers3