Transfer Data between Activities with Android Parcelable

By Simon Codrington

Using Android Studio? Download our Handy Cheat Sheet of Keyboard Shortcuts!

An Android app typically consists of more than one activity that need to pass data between each other. For example a primary activity with a list of elements and a corresponding secondary activity to show the details of these elements. To move from one activity to another you use the intent class to connect them together. This lets you launch an activity and optionally return later (If you’re new to intents there’s a good resource in the Google dev docs that explains the process)

Part of the process is sending data between activities and you do that via the putExtra and getExtra methods of our intent object. The idea is to make the process of passing different types of data easy as:

//Inside first activity
Intent intent = new Intent(MainActivity.this, DetailActivity.class);
intent.putExtra("name", "John Smith");
intent.putExtra("age", 26);

//inside second activity
Intent intent = getIntent();
String suburb = intent.getStringExtra("name");
Integer age = intent.getIntExtra("age");

This works well for basic data types such as string, bool, and Integer but doesn’t work for objects. What should you do when you want to pass an object and its data from one activity to the other? You use the parcelableinterface

Introducing the Parcelable Interface

Since objects can contain any number of mixed data types you can’t use putExtra to move values across. Java has had the ability to serialize objects for a while, but it’s a slow process as the system needs to perform heavy lifting to move the data. Parcelable is an Android only Interface used to serialize a class so its properties can be transferred from one activity to another.

Implementing Parcelable

The Parcelable interface adds methods to all classes you want to be able to transfer between activities. These methods are how parcelable deconstructs the object in one activity and reconstructs it in another.

For this example you’ll look at how to implement parcelable in a simple class. I used this class in one of my previous articles where I created a property listing and a corresponding detail activity. The idea is that when you select a property in the list view you’re taken to an expanded detail view to find out more info.

Example Screens

Creating the Property Class

First create a class to hold info about each property. Start by adding the following into a new class file in your project.

public class Property implements {
    //property basics
    private int streetNumber;
    private String streetName;
    private String suburb;
    private String state;
    private String description;
    private String image;
    private Double price;
    private int bedrooms;
    private int bathrooms;
    private int carspots;
    private Boolean featured;

    //main constructor
    public Property(int streetNumber, String streetName, String suburb, String state, String description, Double price, String image, int bedrooms, int bathrooms, int carspots, Boolean featured){

        this.streetNumber = streetNumber;
        this.streetName = streetName;
        this.suburb = suburb;
        this.state = state;
        this.description = description;
        this.price = price;
        this.image = image;
        this.bedrooms = bedrooms;
        this.bathrooms = bathrooms;
        this.carspots = carspots;
        this.featured = featured;

    public int getStreetNumber() { return streetNumber; }
    public String getStreetName() {return streetName; }
    public String getSuburb() {return suburb; }
    public String getState() {return state; }
    public String getDescription() {return description; }
    public Double getPrice() {return price; }
    public String getImage() { return image; }
    public int getBedrooms(){ return bedrooms; }
    public int getBathrooms(){ return bathrooms; }
    public int getCarspots(){ return carspots; }
    public Boolean getFeatured(){return featured; }

The class contains a series of properties, getter functions and a constructor to create a single object of the class.

Add the Parcelable Interface

Here’s the main part, implementing the interface. Change the declaration of the class as follows:

public class Property implements Parcelable {

Add the following methods inside the class. I’ll run through how they work shortly.

//write object values to parcel for storage
public void writeToParcel(Parcel dest, int flags){
    //write all properties to the parcle

//constructor used for parcel
public Property(Parcel parcel){
    //read and set saved values from parcel

//creator - used when un-parceling our parcle (creating the object)
public static final Parcelable.Creator<Property> CREATOR = new Parcelable.Creator<Property>(){

    public Property createFromParcel(Parcel parcel) {
        return new Property(parcel);

    public Property[] newArray(int size) {
        return new Property[0];

//return hashcode of object
public int describeContents() {
    return hashCode();

Parcelable needs this code to function. It handles the process of copying your object data into a parcel for transmission between activities and then re-creating the object on the other side.

Let’s break down how this all works.

Writing Method – writeToParcel

In this method you add all your class properties to the parcel in preparation for transfer. You use each of the write methods to add each of your properties.

//write object values to parcel for storage
public void writeToParcel(Parcel dest, int flags){


  • The order in which you write these values is important. When collecting these values later you will need to collect them in the same order.
  • If you’re going to send boolean values (for example the featured property). You will have to use writeValue and then force cast it to a boolean on the other side as there is no native method for adding booleans.

Reading Method – Property

This method is the constructor, called on the receiving activity, where you will be collecting values.

When the secondary activity calls the getParcelableExtra method of the intent object to start the process. This constructor is where you collect the values and set up the properties of the object:

//constructor used for parcel
public Property(Parcel parcel){
    streetName = parcel.readString();
    suburb = parcel.readString();
    state = parcel.readString();
    description = parcel.readString();
    image = parcel.readString();
    streetNumber = parcel.readInt();
    featured = (Boolean) parcel.readValue(null);
    price = parcel.readDouble();
    bedrooms = parcel.readInt();
    bathrooms = parcel.readInt();
    carspots = parcel.readInt();

At this point you’ve populated the object with data.

If you are using your own object then the name of this function will match the name of your own class e.g person, animal, place, the name has to match the class name.

The Creator Method

Parcelable requires this method to bind everything together. There’s little you need to do here as the createFromParcel method will return your newly populated object.

//used when un-parceling our parcel (creating the object)
public static final Parcelable.Creator<Property> CREATOR = new Parcelable.Creator<Property>(){

    public Property createFromParcel(Parcel parcel) {
        return new Property(parcel);

    public Property[] newArray(int size) {
        return new Property[0];

Other methods – describeContents

This method doesn’t do much.

//return hashcode of object
public int describeContents() {
    return hashCode();

Starting the Intent in the First Activity

Inside the first activity create your intent object and use the putExtra method to add the whole class as an extra. This will only work if you’ve implemented the Parcelable interface correctly (as it’s at this point parcelable starts serializing your object).

Intent intent = new Intent(MainActivity.this, DetailActivity.class);
intent.putExtra("Property", property);

If this works, the new activity will open. You will need to ensure the activity is added to your manifest file.

Collecting Values in the Secondary Activity

Now that you’re in the second activity you need to collect the intent object and extract the property class that’s been converted into a parcel. Once you’ve done this you can call the standard methods to get the data like property name, price and description.

//collect our intent
Intent intent = getIntent();
Property property = intent.getParcelableExtra("Property");

//now collect all property values
String streetName = property.getStreetName();
Integer streetNumber = property.getStreetNumber();
String suburb = property.getSuburb();
String state = property.getState();
String description = property.getDescription();
Double price = property.getPrice();
Integer bedrooms = property.getBedrooms();
Integer bathrooms = property.getBathrooms();
Integer carspots = property.getCarspots();
String image = property.getImage();
Integer imageID = this.getResources().getIdentifier(image, "drawable", this.getPackageName());
String address = streetNumber + " " + streetName + ", " + suburb + ", " + state;

Pass the Parcel

As you have see, there’s work involved in getting parcelable up and running, but once it all works the payoff is worth it.

You can move entire objects from one activity to another, retaining all class methods and abilities. This is great if you have a complex method that transforms your data.

You no longer have to remember the different names which you would normally pass to the intent object as extra data, e.g String streetName = intent.getStringExtra("streetName");. You can get your object and move on.

The process is fast and optimized. Doing it this way is faster than using Java’s serialize functionality as you implicitly tell it how to save and extract your data.

Please let me know if you have any comments or questions.

  • I’m wondering what happens when we have a built in type like an ArrayList? E.g. what happens when I have a class that has lists of atomic data. And then I want to transfer an array list of these to the parceable.

    • simon codrington

      Hey Nicoli, if you wanted to use more complex data structures / lists you could still use parcelable much like what’s shown in this example:

      Also, if you want to pass classes inside of a class (like an ArrayList of classes) then those inner classes also have to implement the parcelable interface to make it all work.

      I wanted the example to be pretty simple so didn’t include adding lists etc


  • simon codrington

    Hi Huzaima, If your class has other classes inside of it then those classes also need to implement the parcelable interface. Once that’s been implemented you should be able to use those in your class.

    • or if the other object have few attributes in it, you can just add them at the end and reconstruct the object using them

  • What about other objects like Socket, BufferedReader or PrintWriter? Is it possible to share them with parcelable?

    • simon codrington

      Hey there. From what I’ve found; To be able to share complex data types like those you need to make your own that inherits them and then implement the parcelable interface. Basically parcelable needs to be implicitly told how to pass your data. This might make your code much more complex if all you want to do is share data.

      Another option is that you stick to standard data types (or classes if they also implement parcelable) and recreate elements like BuffferedReader in the new activity. It’s a bit of duplication but it’s a bit unavoidable sadly.

  • Great write. Adding way to parcel An object that is property of another object will be great (although its an obvious thing for advanced guys)
    Thank you!

    • simon codrington

      Definitely something to look into for a future article. Thanks for the feedback :)

Get the latest in Mobile, once a week, for free.