How to Use Parcelable in android Development

How to Use Parcelable in android Development

To transfer objects between two activities, the object must be serialized. There are two methods to serialize an object in android, one is to implement the Serializable interface, which is very simple, just declare it. However, there is a special serialization method in android, that is, implementing the Parcelable interface. The serialization efficiency of this method is higher than implementing the Serializable interface. However, the Serializable interface is too convenient. Therefore, it is a good choice to implement this interface in some cases.
To use Parcelable, follow these steps:
1. Implement the Parcelable Interface
2. Implement two methods in the interface

public int describeContents();public void writeToParcel(Parcel dest, int flags);

The first method is the content interface description. By default, 0 is returned.
The second method is to serialize our object to a Parcel object, that is, to save our object to Parcel.
3. instantiate the Parcelable. CREATOR interface of the static internal Object Creator. Two methods must be implemented when instantiating the CREATOR.createFromParcelThe function is to read our objects from Parcel.

That is to say, we usewriteToParcelMethod To write the object, ReusecreateFromParcelThe read/write order of the two methods must be consistent. Otherwise, data disorder may occur. I will give an example later.
Let's look at a sample code:

Public class Person implements Parcelable {private String username; private String nickname; private int age; public String getUsername () {return username;} public void setUsername (String username) {this. username = username;} public String getNickname () {return nickname;} public void setNickname (String nickname) {this. nickname = nickname;} public int getAge () {return age;} public void setAge (int age) {this. age = age;} public Person (String username, String nickname, int age) {super (); this. username = username; this. nickname = nickname; this. age = age;} public Person () {super () ;}/ *** the read order must be consistent with writeToParcel (Parcel dest, int flags) * The write order in the method is the same, otherwise there will be errors in the data. For example, if your read order is: * nickname = source. readString (); * username = source. readString (); * age = source. readInt (); * That is, the reading sequence of username and nickname is changed, so you will find that the username you get is the data of nickname, * The nick name you get is the username data * @ param source */public Person (Parcel source) {username = source. readString (); nickname = source. readString (); age = source. readInt ();}/*** returns 0 by default. */@ Override public int describeContents () {return 0 ;} /*** write the value to Parcel */@ Override public void writeToParcel (Parcel dest, int flags) {dest. writeString (username); dest. writeString (nickname); dest. writeInt (age);} public static final Creator
  
   
CREATOR = new Creator
   
    
() {/*** For external class deserialization this class array */@ Override public Person [] newArray (int size) {return new Person [size];} /*** read data from Parcel */@ Override public Person createFromParcel (Parcel source) {return new Person (source );}};}
   
  

Source code http://pan.baidu.com/s/1hqzY3go of this project

Finally, paste the Parcelable source code. Google has provided an example:

/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an AS IS BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package android.os;/** * Interface for classes whose instances can be written to * and restored from a {@link Parcel}.  Classes implementing the Parcelable * interface must also have a static field called CREATOR, which * is an object implementing the {@link Parcelable.Creator Parcelable.Creator} * interface. *  * 

A typical implementation of Parcelable is:

* *

 * public class MyParcelable implements Parcelable { *     private int mData; * *     public int describeContents() { *         return 0; *     } * *     public void writeToParcel(Parcel out, int flags) { *         out.writeInt(mData); *     } * *     public static final Parcelable.Creator<MyParcelable> CREATOR *             = new Parcelable.Creator<MyParcelable>() { *         public MyParcelable createFromParcel(Parcel in) { *             return new MyParcelable(in); *         } * *         public MyParcelable[] newArray(int size) { *             return new MyParcelable[size]; *         } *     }; *      *     private MyParcelable(Parcel in) { *         mData = in.readInt(); *     } * }

*/ public interface Parcelable { /** * Flag for use with {@link #writeToParcel}: the object being written * is a return value, that is the result of a function such as * Parcelable someFunction(), * void someFunction(out Parcelable), or * void someFunction(inout Parcelable). Some implementations * may want to release resources at this point. */ public static final int PARCELABLE_WRITE_RETURN_VALUE = 0x0001; /** * Bit masks for use with {@link #describeContents}: each bit represents a * kind of object considered to have potential special significance when * marshalled. */ public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001; /** * Describe the kinds of special objects contained in this Parcelable's * marshalled representation. * * @return a bitmask indicating the set of special object types marshalled * by the Parcelable. */ public int describeContents(); /** * Flatten this object in to a Parcel. * * @param dest The Parcel in which the object should be written. * @param flags Additional flags about how the object should be written. * May be 0 or {@link #PARCELABLE_WRITE_RETURN_VALUE}. */ public void writeToParcel(Parcel dest, int flags); /** * Interface that must be implemented and provided as a public CREATOR * field that generates instances of your Parcelable class from a Parcel. */ public interface Creator { /** * Create a new instance of the Parcelable class, instantiating it * from the given Parcel whose data had previously been written by * {@link Parcelable#writeToParcel Parcelable.writeToParcel()}. * * @param source The Parcel to read the object's data from. * @return Returns a new instance of the Parcelable class. */ public T createFromParcel(Parcel source); /** * Create a new array of the Parcelable class. * * @param size Size of the array. * @return Returns an array of the Parcelable class, with every entry * initialized to null. */ public T[] newArray(int size); } /** * Specialization of {@link Creator} that allows you to receive the * ClassLoader the object is being created in. */ public interface ClassLoaderCreator extends Creator { /** * Create a new instance of the Parcelable class, instantiating it * from the given Parcel whose data had previously been written by * {@link Parcelable#writeToParcel Parcelable.writeToParcel()} and * using the given ClassLoader. * * @param source The Parcel to read the object's data from. * @param loader The ClassLoader that this object is being created in. * @return Returns a new instance of the Parcelable class. */ public T createFromParcel(Parcel source, ClassLoader loader); } }