Android DTT #9 — Generate Parcelable Boilerplate Automatically

We should focus on things that matters

Bundle is very commonly used to pass data between activities or other parts in our application. We can pass an object to a Bundle but it requires the object to be either Serializable or Parcelable.

Everyone know that, although easier to implement, Serializable is 10 times slower than Parcelable. Just doing a quick google search will gives you the impression of how slow a Serializable is.

Note: Pavel Lahoda mentioned that this not always the case in the comment. Be sure to check that out.

The thing with Parcelable is, to implement that, there are many boilerplate that we should create. This is an example of a simple class with two fields, implementing Parcelable:

That’s a lot of boilerplate just for a class with two fields.

Android Studio Default Implementation

Fortunately, Android Studio provides a way to generate those codes by adding Parcelable as one of the interface then press Option + Enter and choose Add Parcelable Implementation.

There’s a catch with this approach. If you add/remove the fields in Data class, then you need to reapply again so that the generated code will match.

Nobody ain’t got time for that.

Generated Code

Other options is to generate the boilerplate automatically. We can do this by creating an Annotation Processor to every class we want to add Parcelable implementation on it. This may very challenging task to do but we don’t have to reinvent the wheel.

There are plenty of libraries that we can use to get the job done. AutoParcel or AutoValueParcel that utilizes Google’s AutoValue, Parceler, and many others.

I personally used Parceler. It only requires us to add @Parcel to the class it will automatically creates the boilerplate code. Later, when adding the class to a Bundle we can do put and get it like this:

Bundle bundle = new Bundle();
bundle.putParcelable("data", Parcels.wrap(data));
Data data = Parcels.unWrap(bundle.getParcelableExtra("data");

Since the code is generated at compile time, everytime we add new fields to the class will be reflected when we build the apps.

Now that’s one less thing to worry about.

If you like this, hit that heart button and recommend it to your friends.

ADTT (Android Development Tips and Tricks) is a 31 series of blog posts that I’m trying to finish in throughout May. Click here for index.