Parcelable Class

package uk.co.kraya.android.demos.Parcelable;
 
import android.os.Parcel;
import android.os.Parcelable;
 
/**
 * @author Shriram Shri Shrikumar
 *
 * A basic object that can be parcelled to
 * transfer between objects
 *
 */
public class ObjectA implements Parcelable {
 
 private String strValue;
 private Integer intValue;
 
 /**
  * Standard basic constructor for non-parcel
  * object creation
  */
 public ObjectA() { ; };
 
 /**
  *
  * Constructor to use when re-constructing object
  * from a parcel
  *
  * @param in a parcel from which to read this object
  */
 public ObjectA(Parcel in) {
  readFromParcel(in);
 }
 
 /**
  * standard getter
  *
  * @return strValue
  */
 public String getStrValue() {
  return strValue;
 }
 
 /**
  * Standard setter
  *
  * @param strValue
  */
 public void setStrValue(String strValue) {
  this.strValue = strValue;
 }
 
 /**
  * standard getter
  *
  * @return
  */
 public Integer getIntValue() {
  return intValue;
 }
 
 /**
  * Standard setter
  *
  * @param intValue
  */
 public void setIntValue(Integer intValue) {
  this.intValue = intValue;
 }
 
 @Override
 public int describeContents() {
  return 0;
 }
 
 @Override
 public void writeToParcel(Parcel dest, int flags) {
 
  // We just need to write each field into the
  // parcel. When we read from parcel, they
  // will come back in the same order
  dest.writeString(strValue);
  dest.writeInt(intValue);
 }
 
 /**
  *
  * Called from the constructor to create this
  * object from a parcel.
  *
  * @param in parcel from which to re-create object
  */
 private void readFromParcel(Parcel in) {
 
  // We just need to read back each
  // field in the order that it was
  // written to the parcel
  strValue = in.readString();
  intValue = in.readInt();
 }
 
    /**
     *
     * This field is needed for Android to be able to
     * create new objects, individually or as arrays.
     *
     * This also means that you can use use the default
     * constructor to create the object and use another
     * method to hyrdate it as necessary.
     *
     * I just find it easier to use the constructor.
     * It makes sense for the way my brain thinks ;-)
     *
     */
    public static final Parcelable.Creator CREATOR =
     new Parcelable.Creator() {
            public ObjectA createFromParcel(Parcel in) {
                return new ObjectA(in);
            }
 
            public ObjectA[] newArray(int size) {
                return new ObjectA[size];
            }
        };
 
}

--------------------------------------------------------------------------

package uk.co.kraya.android.demos.Parcelable;
 
import android.os.Parcel;
import android.os.Parcelable;
 
public class ObjectB implements Parcelable {
 
 private ObjectA obj;
 private Long longVal;
 
 public ObjectB() { ; }
 
 public ObjectA getObj() {
  return obj;
 }
 
 /**
  *
  * Constructor to use when re-constructing object
  * from a parcel
  *
  * @param in a parcel from which to read this object
  */
 public ObjectB(Parcel in) {
  readFromParcel(in);
 }
 
 public void setObj(ObjectA obj) {
  this.obj = obj;
 }
 
 public Long getLongVal() {
  return longVal;
 }
 
 public void setLongVal(Long longVal) {
  this.longVal = longVal;
 }
 
 @Override
 public int describeContents() {
  return 0;
 }
 
 @Override
 public void writeToParcel(Parcel dest, int flags) {
 
  // The writeParcel method needs the flag
  // as well - but thats easy.
  dest.writeParcelable(obj, flags);
 
  // Same as in ObjectA
  dest.writeLong(longVal);
 }
 
 /**
  *
  * Called from the constructor to create this
  * object from a parcel.
  *
  * @param in parcel from which to re-create object
  */
 private void readFromParcel(Parcel in) {
 
  // readParcelable needs the ClassLoader
  // but that can be picked up from the class
  // This will solve the BadParcelableException
  // because of ClassNotFoundException
  obj = in.readParcelable(ObjectA.class.getClassLoader());
 
  // The rest is the same as in ObjectA
  longVal = in.readLong();
 }
 
    /**
     *
     * This field is needed for Android to be able to
     * create new objects, individually or as arrays.
     *
     * This also means that you can use use the default
     * constructor to create the object and use another
     * method to hyrdate it as necessary.
     *
     * I just find it easier to use the constructor.
     * It makes sense for the way my brain thinks ;-)
     *
     */
    public static final Parcelable.Creator CREATOR =
     new Parcelable.Creator() {
            public ObjectB createFromParcel(Parcel in) {
                return new ObjectB(in);
            }
 
            public ObjectB[] newArray(int size) {
                return new ObjectB[size];
            }
        };
}

--------------------------------------------------------------------------

[Sender]

ObjectA obj = new ObjectA();
 
// Set values etc.
 
Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);

------------------------------------------------

[Receiver] 

Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");