Most visited

Recently visited

Results for

Summary: Fields | Methods | Protected Methods | Inherited Methods

Parcel

public final class Parcel
extends Object

java.lang.Object
↳	android.os.Parcel

Container for a message (data and object references) that can be sent through an IBinder. A Parcel can contain both flattened data that will be unflattened on the other side of the IPC (using the various methods here for writing specific types, or the general Parcelable interface), and references to live IBinder objects that will result in the other side receiving a proxy IBinder connected with the original IBinder in the Parcel.

Parcel is not a general-purpose serialization mechanism. This class (and the corresponding Parcelable API for placing arbitrary objects into a Parcel) is designed as a high-performance IPC transport. As such, it is not appropriate to place any Parcel data in to persistent storage: changes in the underlying implementation of any of the data in the Parcel can render older data unreadable.

The bulk of the Parcel API revolves around reading and writing data of various types. There are six major classes of such functions available.

Primitives

The most basic data functions are for writing and reading primitive data types: writeByte(byte), readByte(), writeDouble(double), readDouble(), writeFloat(float), readFloat(), writeInt(int), readInt(), writeLong(long), readLong(), writeString(String), readString(). Most other data operations are built on top of these. The given data is written and read using the endianess of the host CPU.

Primitive Arrays

There are a variety of methods for reading and writing raw arrays of primitive objects, which generally result in writing a 4-byte length followed by the primitive data items. The methods for reading can either read the data into an existing array, or create and return a new array. These available types are:

Parcelables

The Parcelable protocol provides an extremely efficient (but low-level) protocol for objects to write and read themselves from Parcels. You can use the direct methods writeParcelable(android.os.Parcelable, int) and readParcelable(java.lang.ClassLoader) or writeParcelableArray(T[], int) and readParcelableArray(java.lang.ClassLoader) to write or read. These methods write both the class type and its data to the Parcel, allowing that class to be reconstructed from the appropriate class loader when later reading.

There are also some methods that provide a more efficient way to work with Parcelables: writeTypedObject(T, int), writeTypedArray(T[], int), writeTypedList(List), readTypedObject(Parcelable.Creator), createTypedArray(Parcelable.Creator) and createTypedArrayList(Parcelable.Creator). These methods do not write the class information of the original object: instead, the caller of the read function must know what type to expect and pass in the appropriate Parcelable.Creator instead to properly construct the new object and read its data. (To more efficient write and read a single Parcelable object that is not null, you can directly call Parcelable#writeToParcel and Parcelable.Creator#createFromParcel yourself.)

Bundles

A special type-safe container, called Bundle, is available for key/value maps of heterogeneous values. This has many optimizations for improved performance when reading and writing data, and its type-safe API avoids difficult to debug type errors when finally marshalling the data contents into a Parcel. The methods to use are writeBundle(android.os.Bundle), readBundle(), and readBundle(java.lang.ClassLoader).

Active Objects

An unusual feature of Parcel is the ability to read and write active objects. For these objects the actual contents of the object is not written, rather a special token referencing the object is written. When reading the object back from the Parcel, you do not get a new instance of the object, but rather a handle that operates on the exact same object that was originally written. There are two forms of active objects available.

Binder objects are a core facility of Android's general cross-process communication system. The IBinder interface describes an abstract protocol with a Binder object. Any such interface can be written in to a Parcel, and upon reading you will receive either the original object implementing that interface or a special proxy implementation that communicates calls back to the original object. The methods to use are writeStrongBinder(android.os.IBinder), writeStrongInterface(android.os.IInterface), readStrongBinder(), writeBinderArray(android.os.IBinder[]), readBinderArray(android.os.IBinder[]), createBinderArray(), writeBinderList(java.util.List), readBinderList(java.util.List), createBinderArrayList().

FileDescriptor objects, representing raw Linux file descriptor identifiers, can be written and ParcelFileDescriptor objects returned to operate on the original file descriptor. The returned file descriptor is a dup of the original file descriptor: the object and fd is different, but operating on the same underlying file stream, with the same position, etc. The methods to use are writeFileDescriptor(java.io.FileDescriptor), readFileDescriptor().

Untyped Containers

A final class of methods are for writing and reading standard Java containers of arbitrary types. These all revolve around the writeValue(java.lang.Object) and readValue(java.lang.ClassLoader) methods which define the types of objects allowed. The container methods are writeArray(java.lang.Object[]), readArray(java.lang.ClassLoader), writeList(java.util.List), readList(java.util.List, java.lang.ClassLoader), readArrayList(java.lang.ClassLoader), writeMap(java.util.Map), readMap(java.util.Map, java.lang.ClassLoader), writeSparseArray(android.util.SparseArray), readSparseArray(java.lang.ClassLoader).

Summary

Fields
`public static final Creator<String>`	`STRING_CREATOR`

Public methods
`void`	`appendFrom(Parcel parcel, int offset, int length)`
`IBinder[]`	`createBinderArray()`
`ArrayList<IBinder>`	`createBinderArrayList()` Read and return a new ArrayList containing IBinder objects from the parcel that was written with `writeBinderList(List)` at the current dataPosition().
`boolean[]`	`createBooleanArray()`
`byte[]`	`createByteArray()` Read and return a byte[] object from the parcel.
`char[]`	`createCharArray()`
`double[]`	`createDoubleArray()`
`float[]`	`createFloatArray()`
`int[]`	`createIntArray()`
`long[]`	`createLongArray()`
`String[]`	`createStringArray()`
`ArrayList<String>`	`createStringArrayList()` Read and return a new ArrayList containing String objects from the parcel that was written with `writeStringList(List)` at the current dataPosition().
`<T> T[]`	`createTypedArray(Creator<T> c)` Read and return a new array containing a particular object type from the parcel at the current dataPosition().
`<T> ArrayList<T>`	`createTypedArrayList(Creator<T> c)` Read and return a new ArrayList containing a particular object type from the parcel that was written with `writeTypedList(List)` at the current dataPosition().
`<T extends Parcelable> ArrayMap<String, T>`	`createTypedArrayMap(Creator<T> creator)` Read into a new `ArrayMap` with string keys items containing a particular object type that were written with `writeTypedArrayMap(android.util.ArrayMap, int)` at the current dataPosition().
`<T extends Parcelable> SparseArray<T>`	`createTypedSparseArray(Creator<T> creator)` Read into a new `SparseArray` items containing a particular object type that were written with `writeTypedSparseArray(android.util.SparseArray, int)` at the current dataPosition().
`int`	`dataAvail()` Returns the amount of data remaining to be read from the parcel.
`int`	`dataCapacity()` Returns the total amount of space in the parcel.
`int`	`dataPosition()` Returns the current position in the parcel data.
`int`	`dataSize()` Returns the total amount of data contained in the parcel.
`void`	`enforceInterface(String interfaceName)`
`boolean`	`hasFileDescriptors()` Report whether the parcel contains any marshalled file descriptors.
`byte[]`	`marshall()` Returns the raw bytes of the parcel.
`static Parcel`	`obtain()` Retrieve a new Parcel object from the pool.
`Object[]`	`readArray(ClassLoader loader)` Read and return a new Object array from the parcel at the current dataPosition().
`ArrayList`	`readArrayList(ClassLoader loader)` Read and return a new ArrayList object from the parcel at the current dataPosition().
`void`	`readBinderArray(IBinder[] val)`
`void`	`readBinderList(List<IBinder> list)` Read into the given List items IBinder objects that were written with `writeBinderList(List)` at the current dataPosition().
`boolean`	`readBoolean()` Read a boolean value from the parcel at the current dataPosition().
`void`	`readBooleanArray(boolean[] val)`
`Bundle`	`readBundle()` Read and return a new Bundle object from the parcel at the current dataPosition().
`Bundle`	`readBundle(ClassLoader loader)` Read and return a new Bundle object from the parcel at the current dataPosition(), using the given class loader to initialize the class loader of the Bundle for later retrieval of Parcelable objects.
`byte`	`readByte()` Read a byte value from the parcel at the current dataPosition().
`void`	`readByteArray(byte[] val)` Read a byte[] object from the parcel and copy it into the given byte array.
`void`	`readCharArray(char[] val)`
`double`	`readDouble()` Read a double precision floating point value from the parcel at the current dataPosition().
`void`	`readDoubleArray(double[] val)`
`void`	`readException()` Special function for reading an exception result from the header of a parcel, to be used after receiving the result of a transaction.
`void`	`readException(int code, String msg)` Throw an exception with the given message.
`ParcelFileDescriptor`	`readFileDescriptor()` Read a FileDescriptor from the parcel at the current dataPosition().
`float`	`readFloat()` Read a floating point value from the parcel at the current dataPosition().
`void`	`readFloatArray(float[] val)`
`HashMap`	`readHashMap(ClassLoader loader)` Please use `readBundle(java.lang.ClassLoader)` instead (whose data must have been written with `writeBundle(Bundle)`.
`int`	`readInt()` Read an integer value from the parcel at the current dataPosition().
`void`	`readIntArray(int[] val)`
`void`	`readList(List outVal, ClassLoader loader)` Read into an existing List object from the parcel at the current dataPosition(), using the given class loader to load any enclosed Parcelables.
`long`	`readLong()` Read a long integer value from the parcel at the current dataPosition().
`void`	`readLongArray(long[] val)`
`void`	`readMap(Map outVal, ClassLoader loader)` Please use `readBundle(java.lang.ClassLoader)` instead (whose data must have been written with `writeBundle(Bundle)`.
`<T extends Parcelable> T`	`readParcelable(ClassLoader loader)` Read and return a new Parcelable from the parcel.
`Parcelable[]`	`readParcelableArray(ClassLoader loader)` Read and return a new Parcelable array from the parcel.
`Creator<?>`	`readParcelableCreator(ClassLoader loader)` Read and return a Parcelable.Creator from the parcel.
`<T extends Parcelable> List<T>`	`readParcelableList(List<T> list, ClassLoader cl)` Read the list of `Parcelable` objects at the current data position into the given `list`.
`PersistableBundle`	`readPersistableBundle()` Read and return a new Bundle object from the parcel at the current dataPosition().
`PersistableBundle`	`readPersistableBundle(ClassLoader loader)` Read and return a new Bundle object from the parcel at the current dataPosition(), using the given class loader to initialize the class loader of the Bundle for later retrieval of Parcelable objects.
`Serializable`	`readSerializable()` Read and return a new Serializable object from the parcel.
`Size`	`readSize()` Read a Size from the parcel at the current dataPosition().
`SizeF`	`readSizeF()` Read a SizeF from the parcel at the current dataPosition().
`<T> SparseArray<T>`	`readSparseArray(ClassLoader loader)` Read and return a new SparseArray object from the parcel at the current dataPosition().
`SparseBooleanArray`	`readSparseBooleanArray()` Read and return a new SparseBooleanArray object from the parcel at the current dataPosition().
`String`	`readString()` Read a string value from the parcel at the current dataPosition().
`void`	`readStringArray(String[] val)`
`void`	`readStringList(List<String> list)` Read into the given List items String objects that were written with `writeStringList(List)` at the current dataPosition().
`IBinder`	`readStrongBinder()` Read an object from the parcel at the current dataPosition().
`<T> void`	`readTypedArray(T[] val, Creator<T> c)`
`<T> void`	`readTypedList(List<T> list, Creator<T> c)` Read into the given List items containing a particular object type that were written with `writeTypedList(List)` at the current dataPosition().
`<T> T`	`readTypedObject(Creator<T> c)` Read and return a typed Parcelable object from a parcel.
`Object`	`readValue(ClassLoader loader)` Read a typed object from a parcel.
`void`	`recycle()` Put a Parcel object back into the pool.
`void`	`setDataCapacity(int size)` Change the capacity (current available space) of the parcel.
`void`	`setDataPosition(int pos)` Move the current read/write position in the parcel.
`void`	`setDataSize(int size)` Change the amount of data in the parcel.
`void`	`unmarshall(byte[] data, int offset, int length)` Set the bytes in data to be the raw bytes of this Parcel.
`void`	`writeArray(Object[] val)` Flatten an Object array into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeBinderArray(IBinder[] val)`
`void`	`writeBinderList(List<IBinder> val)` Flatten a List containing IBinder objects into the parcel, at the current dataPosition() and growing dataCapacity() if needed.
`void`	`writeBoolean(boolean val)` Write a boolean value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeBooleanArray(boolean[] val)`
`void`	`writeBundle(Bundle val)` Flatten a Bundle into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeByte(byte val)` Write a byte value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeByteArray(byte[] b)` Write a byte array into the parcel at the current `dataPosition()`, growing `dataCapacity()` if needed.
`void`	`writeByteArray(byte[] b, int offset, int len)` Write a byte array into the parcel at the current `dataPosition()`, growing `dataCapacity()` if needed.
`void`	`writeCharArray(char[] val)`
`void`	`writeDouble(double val)` Write a double precision floating point value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeDoubleArray(double[] val)`
`void`	`writeException(Exception e)` Special function for writing an exception result at the header of a parcel, to be used when returning an exception from a transaction.
`void`	`writeFileDescriptor(FileDescriptor val)` Write a FileDescriptor into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeFloat(float val)` Write a floating point value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeFloatArray(float[] val)`
`void`	`writeInt(int val)` Write an integer value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeIntArray(int[] val)`
`void`	`writeInterfaceToken(String interfaceName)` Store or read an IBinder interface token in the parcel at the current `dataPosition()`.
`void`	`writeList(List val)` Flatten a List into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeLong(long val)` Write a long integer value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeLongArray(long[] val)`
`void`	`writeMap(Map val)` Please use `writeBundle(Bundle)` instead.
`void`	`writeNoException()` Special function for writing information at the front of the Parcel indicating that no exception occurred.
`void`	`writeParcelable(Parcelable p, int parcelableFlags)` Flatten the name of the class of the Parcelable and its contents into the parcel.
`<T extends Parcelable> void`	`writeParcelableArray(T[] value, int parcelableFlags)` Write a heterogeneous array of Parcelable objects into the Parcel.
`void`	`writeParcelableCreator(Parcelable p)` Flatten the name of the class of the Parcelable into this Parcel.
`<T extends Parcelable> void`	`writeParcelableList(List<T> val, int flags)` Flatten a `List` containing arbitrary `Parcelable` objects into this parcel at the current position.
`void`	`writePersistableBundle(PersistableBundle val)` Flatten a PersistableBundle into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeSerializable(Serializable s)` Write a generic serializable object in to a Parcel.
`void`	`writeSize(Size val)` Flatten a Size into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeSizeF(SizeF val)` Flatten a SizeF into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`<T> void`	`writeSparseArray(SparseArray<T> val)` Flatten a generic SparseArray into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeSparseBooleanArray(SparseBooleanArray val)`
`void`	`writeString(String val)` Write a string value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeStringArray(String[] val)`
`void`	`writeStringList(List<String> val)` Flatten a List containing String objects into the parcel, at the current dataPosition() and growing dataCapacity() if needed.
`void`	`writeStrongBinder(IBinder val)` Write an object into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`void`	`writeStrongInterface(IInterface val)` Write an object into the parcel at the current dataPosition(), growing dataCapacity() if needed.
`<T extends Parcelable> void`	`writeTypedArray(T[] val, int parcelableFlags)` Flatten a homogeneous array containing a particular object type into the parcel, at the current dataPosition() and growing dataCapacity() if needed.
`<T extends Parcelable> void`	`writeTypedArrayMap(ArrayMap<String, T> val, int parcelableFlags)` Flatten an `ArrayMap` with string keys containing a particular object type into the parcel at the current dataPosition() and growing dataCapacity() if needed.
`<T extends Parcelable> void`	`writeTypedList(List<T> val)` Flatten a List containing a particular object type into the parcel, at the current dataPosition() and growing dataCapacity() if needed.
`<T extends Parcelable> void`	`writeTypedObject(T val, int parcelableFlags)` Flatten the Parcelable object into the parcel.
`<T extends Parcelable> void`	`writeTypedSparseArray(SparseArray<T> val, int parcelableFlags)` Flatten a `SparseArray` containing a particular object type into the parcel at the current dataPosition() and growing dataCapacity() if needed.
`void`	`writeValue(Object v)` Flatten a generic object in to a parcel.

Protected methods
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.

Inherited methods

From class


        
          java.lang.Object

`Object`	`clone()` Creates and returns a copy of this object.
`boolean`	`equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void`	`finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>`	`getClass()` Returns the runtime class of this `Object`.
`int`	`hashCode()` Returns a hash code value for the object.
`final void`	`notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void`	`notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String`	`toString()` Returns a string representation of the object.
`final void`	`wait(long timeout, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void`	`wait(long timeout)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void`	`wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.

Fields

STRING_CREATOR

public static final Creator<String> STRING_CREATOR

Public methods

appendFrom

public void appendFrom (Parcel parcel, 
                int offset, 
                int length)

Parameters
`parcel`	`Parcel`
`offset`	`int`
`length`	`int`

createBinderArray

public IBinder[] createBinderArray ()

Returns
`IBinder[]`	This value may be `null`.

createBinderArrayList

public ArrayList<IBinder> createBinderArrayList ()

Read and return a new ArrayList containing IBinder objects from the parcel that was written with writeBinderList(List) at the current dataPosition(). Returns null if the previously written list object was null.

Returns
`ArrayList<IBinder>`	A newly created ArrayList containing strings with the same data as those that were previously written.

See also:

writeBinderList(List)

createBooleanArray

public boolean[] createBooleanArray ()

Returns
`boolean[]`	This value may be `null`.

createByteArray

public byte[] createByteArray ()

Read and return a byte[] object from the parcel.

Returns
`byte[]`	This value may be `null`.

createCharArray

public char[] createCharArray ()

Returns
`char[]`	This value may be `null`.

createDoubleArray

public double[] createDoubleArray ()

Returns
`double[]`	This value may be `null`.

createFloatArray

public float[] createFloatArray ()

Returns
`float[]`	This value may be `null`.

createIntArray

public int[] createIntArray ()

Returns
`int[]`	This value may be `null`.

createLongArray

public long[] createLongArray ()

Returns
`long[]`	This value may be `null`.

createStringArray

public String[] createStringArray ()

Returns
`String[]`	This value may be `null`.

createStringArrayList

public ArrayList<String> createStringArrayList ()

Read and return a new ArrayList containing String objects from the parcel that was written with writeStringList(List) at the current dataPosition(). Returns null if the previously written list object was null.

Returns
`ArrayList<String>`	A newly created ArrayList containing strings with the same data as those that were previously written.

See also:

writeStringList(List)

createTypedArray

public T[] createTypedArray (Creator<T> c)

Read and return a new array containing a particular object type from the parcel at the current dataPosition(). Returns null if the previously written array was null. The array must have previously been written via writeTypedArray(T[], int) with the same object type.

Parameters
`c`	`Creator`: This value cannot be `null`.

Returns
`T[]`	A newly created array containing objects with the same data as those that were previously written.

See also:

writeTypedArray(T[], int)

createTypedArrayList

public ArrayList<T> createTypedArrayList (Creator<T> c)

Read and return a new ArrayList containing a particular object type from the parcel that was written with writeTypedList(List) at the current dataPosition(). Returns null if the previously written list object was null. The list must have previously been written via writeTypedList(List) with the same object type.

Parameters
`c`	`Creator`: This value cannot be `null`.

Returns
`ArrayList<T>`	A newly created ArrayList containing objects with the same data as those that were previously written.

See also:

writeTypedList(List)

createTypedArrayMap

public ArrayMap<String, T> createTypedArrayMap (Creator<T> creator)

Read into a new ArrayMap with string keys items containing a particular object type that were written with writeTypedArrayMap(android.util.ArrayMap, int) at the current dataPosition(). The list must have previously been written via writeTypedArrayMap(android.util.ArrayMap, int) with the same object type.

Parameters
`creator`	`Creator`: The creator to use when for instantiation. This value cannot be `null`.

Returns
`ArrayMap<String, T>`	A newly created `ArrayMap` containing objects with the same data as those that were previously written. This value may be `null`.

See also:

writeTypedArrayMap(ArrayMap, int)

createTypedSparseArray

public SparseArray<T> createTypedSparseArray (Creator<T> creator)

Read into a new SparseArray items containing a particular object type that were written with writeTypedSparseArray(android.util.SparseArray, int) at the current dataPosition(). The list must have previously been written via writeTypedSparseArray(android.util.SparseArray, int) with the same object type.

Parameters
`creator`	`Creator`: The creator to use when for instantiation. This value cannot be `null`.

Returns
`SparseArray<T>`	A newly created `SparseArray` containing objects with the same data as those that were previously written. This value may be `null`.

See also:

writeTypedSparseArray(SparseArray, int)

dataAvail

public int dataAvail ()

Returns the amount of data remaining to be read from the parcel. That is, dataSize()-dataPosition().

Returns
`int`

dataCapacity

public int dataCapacity ()

Returns the total amount of space in the parcel. This is always >= dataSize(). The difference between it and dataSize() is the amount of room left until the parcel needs to re-allocate its data buffer.

Returns
`int`

dataPosition

public int dataPosition ()

Returns the current position in the parcel data. Never more than dataSize().

Returns
`int`

dataSize

public int dataSize ()

Returns the total amount of data contained in the parcel.

Returns
`int`

enforceInterface

public void enforceInterface (String interfaceName)

Parameters
`interfaceName`	`String`

hasFileDescriptors

public boolean hasFileDescriptors ()

Report whether the parcel contains any marshalled file descriptors.

Returns
`boolean`

marshall

public byte[] marshall ()

Returns the raw bytes of the parcel.

The data you retrieve here must not be placed in any kind of persistent storage (on local disk, across a network, etc). For that, you should use standard serialization or another kind of general serialization mechanism. The Parcel marshalled representation is highly optimized for local IPC, and as such does not attempt to maintain compatibility with data created in different versions of the platform.

Returns
`byte[]`

obtain

public static Parcel obtain ()

Retrieve a new Parcel object from the pool.

Returns
`Parcel`	This value cannot be `null`.

readArray

public Object[] readArray (ClassLoader loader)

Read and return a new Object array from the parcel at the current dataPosition(). Returns null if the previously written array was null. The given class loader will be used to load any enclosed Parcelables.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`Object[]`

readArrayList

public ArrayList readArrayList (ClassLoader loader)

Read and return a new ArrayList object from the parcel at the current dataPosition(). Returns null if the previously written list object was null. The given class loader will be used to load any enclosed Parcelables.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`ArrayList`

readBinderArray

public void readBinderArray (IBinder[] val)

Parameters
`val`	`IBinder`: This value cannot be `null`.

readBinderList

public void readBinderList (List<IBinder> list)

Read into the given List items IBinder objects that were written with writeBinderList(List) at the current dataPosition().

Parameters
`list`	`List`: This value cannot be `null`.

See also:

writeBinderList(List)

readBoolean

public boolean readBoolean ()

Read a boolean value from the parcel at the current dataPosition().

Returns
`boolean`

readBooleanArray

public void readBooleanArray (boolean[] val)

Parameters
`val`	`boolean`: This value cannot be `null`.

readBundle

public Bundle readBundle ()

Read and return a new Bundle object from the parcel at the current dataPosition(). Returns null if the previously written Bundle object was null.

Returns
`Bundle`

readBundle

public Bundle readBundle (ClassLoader loader)

Read and return a new Bundle object from the parcel at the current dataPosition(), using the given class loader to initialize the class loader of the Bundle for later retrieval of Parcelable objects. Returns null if the previously written Bundle object was null.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`Bundle`

readByte

public byte readByte ()

Read a byte value from the parcel at the current dataPosition().

Returns
`byte`

readByteArray

public void readByteArray (byte[] val)

Read a byte[] object from the parcel and copy it into the given byte array.

Parameters
`val`	`byte`: This value cannot be `null`.

readCharArray

public void readCharArray (char[] val)

Parameters
`val`	`char`: This value cannot be `null`.

readDouble

public double readDouble ()

Read a double precision floating point value from the parcel at the current dataPosition().

Returns
`double`

readDoubleArray

public void readDoubleArray (double[] val)

Parameters
`val`	`double`: This value cannot be `null`.

readException

public void readException ()

Special function for reading an exception result from the header of a parcel, to be used after receiving the result of a transaction. This will throw the exception for you if it had been written to the Parcel, otherwise return and let you read the normal result data from the Parcel.

See also:

readException

public void readException (int code, 
                String msg)

Throw an exception with the given message. Not intended for use outside the Parcel class.

Parameters
`code`	`int`: Used to determine which exception class to throw.
`msg`	`String`: The exception message.

readFileDescriptor

public ParcelFileDescriptor readFileDescriptor ()

Read a FileDescriptor from the parcel at the current dataPosition().

Returns
`ParcelFileDescriptor`

readFloat

public float readFloat ()

Read a floating point value from the parcel at the current dataPosition().

Returns
`float`

readFloatArray

public void readFloatArray (float[] val)

Parameters
`val`	`float`: This value cannot be `null`.

readHashMap

public HashMap readHashMap (ClassLoader loader)

Please use readBundle(java.lang.ClassLoader) instead (whose data must have been written with writeBundle(Bundle). Read and return a new HashMap object from the parcel at the current dataPosition(), using the given class loader to load any enclosed Parcelables. Returns null if the previously written map object was null.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`HashMap`

readInt

public int readInt ()

Read an integer value from the parcel at the current dataPosition().

Returns
`int`

readIntArray

public void readIntArray (int[] val)

Parameters
`val`	`int`: This value cannot be `null`.

readList

public void readList (List outVal, 
                ClassLoader loader)

Read into an existing List object from the parcel at the current dataPosition(), using the given class loader to load any enclosed Parcelables. If it is null, the default class loader is used.

Parameters
`outVal`	`List`: This value cannot be `null`.
`loader`	`ClassLoader`: This value may be `null`.

readLong

public long readLong ()

Read a long integer value from the parcel at the current dataPosition().

Returns
`long`

readLongArray

public void readLongArray (long[] val)

Parameters
`val`	`long`: This value cannot be `null`.

readMap

public void readMap (Map outVal, 
                ClassLoader loader)

Please use readBundle(java.lang.ClassLoader) instead (whose data must have been written with writeBundle(Bundle). Read into an existing Map object from the parcel at the current dataPosition().

Parameters
`outVal`	`Map`: This value cannot be `null`.
`loader`	`ClassLoader`: This value may be `null`.

readParcelable

public T readParcelable (ClassLoader loader)

Read and return a new Parcelable from the parcel. The given class loader will be used to load any enclosed Parcelables. If it is null, the default class loader will be used.

Parameters
`loader`	`ClassLoader`: A ClassLoader from which to instantiate the Parcelable object, or null for the default class loader. This value may be `null`.

Returns
`T`	Returns the newly created Parcelable, or null if a null object has been written.

Throws
`BadParcelableException`	Throws BadParcelableException if there was an error trying to instantiate the Parcelable.

readParcelableArray

public Parcelable[] readParcelableArray (ClassLoader loader)

Read and return a new Parcelable array from the parcel. The given class loader will be used to load any enclosed Parcelables.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`Parcelable[]`	the Parcelable array, or null if the array is null

readParcelableCreator

public Creator<?> readParcelableCreator (ClassLoader loader)

Read and return a Parcelable.Creator from the parcel. The given class loader will be used to load the Parcelable.Creator. If it is null, the default class loader will be used.

Parameters
`loader`	`ClassLoader`: A ClassLoader from which to instantiate the `Parcelable.Creator` object, or null for the default class loader. This value may be `null`.

Returns
`Creator<?>`	the previously written `Parcelable.Creator`, or null if a null Creator was written.

Throws
`BadParcelableException`	Throws BadParcelableException if there was an error trying to read the `Parcelable.Creator`.

See also:

writeParcelableCreator(Parcelable)

readParcelableList

public List<T> readParcelableList (List<T> list, 
                ClassLoader cl)

Read the list of Parcelable objects at the current data position into the given list. The contents of the list are replaced. If the serialized list was null, list is cleared.

Parameters
`list`	`List`: This value cannot be `null`.
`cl`	`ClassLoader`: This value may be `null`.

Returns
`List<T>`

See also:

writeParcelableList(List, int)

readPersistableBundle

public PersistableBundle readPersistableBundle ()

Read and return a new Bundle object from the parcel at the current dataPosition(). Returns null if the previously written Bundle object was null.

Returns
`PersistableBundle`

readPersistableBundle

public PersistableBundle readPersistableBundle (ClassLoader loader)

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`PersistableBundle`

readSerializable

public Serializable readSerializable ()

Read and return a new Serializable object from the parcel.

Returns
`Serializable`	the Serializable object, or null if the Serializable name wasn't found in the parcel.

readSize

public Size readSize ()

Read a Size from the parcel at the current dataPosition().

Returns
`Size`	This value cannot be `null`.

readSizeF

public SizeF readSizeF ()

Read a SizeF from the parcel at the current dataPosition().

Returns
`SizeF`	This value cannot be `null`.

readSparseArray

public SparseArray<T> readSparseArray (ClassLoader loader)

Read and return a new SparseArray object from the parcel at the current dataPosition(). Returns null if the previously written list object was null. The given class loader will be used to load any enclosed Parcelables.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`SparseArray<T>`

readSparseBooleanArray

public SparseBooleanArray readSparseBooleanArray ()

Read and return a new SparseBooleanArray object from the parcel at the current dataPosition(). Returns null if the previously written list object was null.

Returns
`SparseBooleanArray`

readString

public String readString ()

Read a string value from the parcel at the current dataPosition().

Returns
`String`	This value may be `null`.

readStringArray

public void readStringArray (String[] val)

Parameters
`val`	`String`: This value cannot be `null`.

readStringList

public void readStringList (List<String> list)

Read into the given List items String objects that were written with writeStringList(List) at the current dataPosition().

Parameters
`list`	`List`: This value cannot be `null`.

See also:

writeStringList(List)

readStrongBinder

public IBinder readStrongBinder ()

Read an object from the parcel at the current dataPosition().

Returns
`IBinder`

readTypedArray

public void readTypedArray (T[] val, 
                Creator<T> c)

Parameters
`val`	`T`: This value cannot be `null`.
`c`	`Creator`: This value cannot be `null`.

readTypedList

public void readTypedList (List<T> list, 
                Creator<T> c)

Read into the given List items containing a particular object type that were written with writeTypedList(List) at the current dataPosition(). The list must have previously been written via writeTypedList(List) with the same object type.

Parameters
`list`	`List`: This value cannot be `null`.
`c`	`Creator`: This value cannot be `null`.

Returns
`void`	A newly created ArrayList containing objects with the same data as those that were previously written.

See also:

writeTypedList(List)

readTypedObject

public T readTypedObject (Creator<T> c)

Read and return a typed Parcelable object from a parcel. Returns null if the previous written object was null. The object must have previous been written via writeTypedObject(T, int) with the same object type.

Parameters
`c`	`Creator`: This value cannot be `null`.

Returns
`T`	A newly created object of the type that was previously written.

See also:

writeTypedObject(T, int)

readValue

public Object readValue (ClassLoader loader)

Read a typed object from a parcel. The given class loader will be used to load any enclosed Parcelables. If it is null, the default class loader will be used.

Parameters
`loader`	`ClassLoader`: This value may be `null`.

Returns
`Object`

recycle

public void recycle ()

Put a Parcel object back into the pool. You must not touch the object after this call.

setDataCapacity

public void setDataCapacity (int size)

Change the capacity (current available space) of the parcel.

Parameters
`size`	`int`: The new capacity of the parcel, in bytes. Can not be less than `dataSize()` -- that is, you can not drop existing data with this method.

setDataPosition

public void setDataPosition (int pos)

Move the current read/write position in the parcel.

Parameters
`pos`	`int`: New offset in the parcel; must be between 0 and `dataSize()`.

setDataSize

public void setDataSize (int size)

Change the amount of data in the parcel. Can be either smaller or larger than the current size. If larger than the current capacity, more memory will be allocated.

Parameters
`size`	`int`: The new number of bytes in the Parcel.

unmarshall

public void unmarshall (byte[] data, 
                int offset, 
                int length)

Set the bytes in data to be the raw bytes of this Parcel.

Parameters
`data`	`byte`: This value cannot be `null`.
`offset`	`int`
`length`	`int`

writeArray

public void writeArray (Object[] val)

Flatten an Object array into the parcel at the current dataPosition(), growing dataCapacity() if needed. The array values are written using writeValue(Object) and must follow the specification there.

Parameters
`val`	`Object`: This value may be `null`.

writeBinderArray

public void writeBinderArray (IBinder[] val)

Parameters
`val`	`IBinder`: This value may be `null`.

writeBinderList

public void writeBinderList (List<IBinder> val)

Flatten a List containing IBinder objects into the parcel, at the current dataPosition() and growing dataCapacity() if needed. They can later be retrieved with createBinderArrayList() or readBinderList(List).

Parameters
`val`	`List`: The list of strings to be written. This value may be `null`.

See also:

writeBoolean

public void writeBoolean (boolean val)

Write a boolean value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Note: This method currently delegates to writeInt with a value of 1 or 0 for true or false, respectively, but may change in the future.

Parameters
`val`	`boolean`

writeBooleanArray

public void writeBooleanArray (boolean[] val)

Parameters
`val`	`boolean`: This value may be `null`.

writeBundle

public void writeBundle (Bundle val)

Flatten a Bundle into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`Bundle`: This value may be `null`.

writeByte

public void writeByte (byte val)

Write a byte value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Note: This method currently delegates to writeInt but may change in the future.

Parameters
`val`	`byte`

writeByteArray

public void writeByteArray (byte[] b)

Write a byte array into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`b`	`byte`: Bytes to place into the parcel. This value may be `null`.

writeByteArray

public void writeByteArray (byte[] b, 
                int offset, 
                int len)

Write a byte array into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`b`	`byte`: Bytes to place into the parcel. This value may be `null`.
`offset`	`int`: Index of first byte to be written.
`len`	`int`: Number of bytes to write.

writeCharArray

public void writeCharArray (char[] val)

Parameters
`val`	`char`: This value may be `null`.

writeDouble

public void writeDouble (double val)

Write a double precision floating point value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`double`

writeDoubleArray

public void writeDoubleArray (double[] val)

Parameters
`val`	`double`: This value may be `null`.

writeException

public void writeException (Exception e)

Special function for writing an exception result at the header of a parcel, to be used when returning an exception from a transaction. Note that this currently only supports a few exception types; any other exception will be re-thrown by this function as a RuntimeException (to be caught by the system's last-resort exception handling when dispatching a transaction).

The supported exception types are:

Parameters
`e`	`Exception`: The Exception to be written. This value cannot be `null`.

See also:

writeFileDescriptor

public void writeFileDescriptor (FileDescriptor val)

Write a FileDescriptor into the parcel at the current dataPosition(), growing dataCapacity() if needed.

The file descriptor will not be closed, which may result in file descriptor leaks when objects are returned from Binder calls. Use ParcelFileDescriptor#writeToParcel instead, which accepts contextual flags and will close the original file descriptor if Parcelable#PARCELABLE_WRITE_RETURN_VALUE is set.

Parameters
`val`	`FileDescriptor`: This value cannot be `null`.

writeFloat

public void writeFloat (float val)

Write a floating point value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`float`

writeFloatArray

public void writeFloatArray (float[] val)

Parameters
`val`	`float`: This value may be `null`.

writeInt

public void writeInt (int val)

Write an integer value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`int`

writeIntArray

public void writeIntArray (int[] val)

Parameters
`val`	`int`: This value may be `null`.

writeInterfaceToken

public void writeInterfaceToken (String interfaceName)

Store or read an IBinder interface token in the parcel at the current dataPosition(). This is used to validate that the marshalled transaction is intended for the target interface.

Parameters
`interfaceName`	`String`

writeList

public void writeList (List val)

Flatten a List into the parcel at the current dataPosition(), growing dataCapacity() if needed. The List values are written using writeValue(Object) and must follow the specification there.

Parameters
`val`	`List`: This value may be `null`.

writeLong

public void writeLong (long val)

Write a long integer value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`long`

writeLongArray

public void writeLongArray (long[] val)

Parameters
`val`	`long`: This value may be `null`.

writeMap

public void writeMap (Map val)

Please use writeBundle(Bundle) instead. Flattens a Map into the parcel at the current dataPosition(), growing dataCapacity() if needed. The Map keys must be String objects. The Map values are written using writeValue(Object) and must follow the specification there.

It is strongly recommended to use writeBundle(Bundle) instead of this method, since the Bundle class provides a type-safe API that allows you to avoid mysterious type errors at the point of marshalling.

Parameters
`val`	`Map`: This value may be `null`.

writeNoException

public void writeNoException ()

Special function for writing information at the front of the Parcel indicating that no exception occurred.

See also:

writeParcelable

public void writeParcelable (Parcelable p, 
                int parcelableFlags)

Flatten the name of the class of the Parcelable and its contents into the parcel.

Parameters
`p`	`Parcelable`: The Parcelable object to be written. This value may be `null`.
`parcelableFlags`	`int`: Contextual flags as per `Parcelable#writeToParcel(Parcel, int)`.

writeParcelableArray

public void writeParcelableArray (T[] value, 
                int parcelableFlags)

Write a heterogeneous array of Parcelable objects into the Parcel. Each object in the array is written along with its class name, so that the correct class can later be instantiated. As a result, this has significantly more overhead than writeTypedArray(T[], int), but will correctly handle an array containing more than one type of object.

Parameters
`value`	`T`: The array of objects to be written. This value may be `null`.
`parcelableFlags`	`int`: Contextual flags as per `Parcelable#writeToParcel(Parcel, int)`.

See also:

writeTypedArray(T[], int)

writeParcelableCreator

public void writeParcelableCreator (Parcelable p)

Flatten the name of the class of the Parcelable into this Parcel.

Parameters
`p`	`Parcelable`: The Parcelable object to be written. This value cannot be `null`.

See also:

readParcelableCreator(ClassLoader)

writeParcelableList

public void writeParcelableList (List<T> val, 
                int flags)

Flatten a List containing arbitrary Parcelable objects into this parcel at the current position. They can later be retrieved using readParcelableList(java.util.List, java.lang.ClassLoader) if required.

Parameters
`val`	`List`: This value may be `null`.
`flags`	`int`

See also:

readParcelableList(List, ClassLoader)

writePersistableBundle

public void writePersistableBundle (PersistableBundle val)

Flatten a PersistableBundle into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`PersistableBundle`: This value may be `null`.

writeSerializable

public void writeSerializable (Serializable s)

Write a generic serializable object in to a Parcel. It is strongly recommended that this method be avoided, since the serialization overhead is extremely large, and this approach will be much slower than using the other approaches to writing data in to a Parcel.

Parameters
`s`	`Serializable`: This value may be `null`.

writeSize

public void writeSize (Size val)

Flatten a Size into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`Size`: This value cannot be `null`.

writeSizeF

public void writeSizeF (SizeF val)

Flatten a SizeF into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`SizeF`: This value cannot be `null`.

writeSparseArray

public void writeSparseArray (SparseArray<T> val)

Flatten a generic SparseArray into the parcel at the current dataPosition(), growing dataCapacity() if needed. The SparseArray values are written using writeValue(Object) and must follow the specification there.

Parameters
`val`	`SparseArray`: This value may be `null`.

writeSparseBooleanArray

public void writeSparseBooleanArray (SparseBooleanArray val)

Parameters
`val`	`SparseBooleanArray`: This value may be `null`.

writeString

public void writeString (String val)

Write a string value into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`String`: This value may be `null`.

writeStringArray

public void writeStringArray (String[] val)

Parameters
`val`	`String`: This value may be `null`.

writeStringList

public void writeStringList (List<String> val)

Flatten a List containing String objects into the parcel, at the current dataPosition() and growing dataCapacity() if needed. They can later be retrieved with createStringArrayList() or readStringList(List).

Parameters
`val`	`List`: The list of strings to be written. This value may be `null`.

See also:

writeStrongBinder

public void writeStrongBinder (IBinder val)

Write an object into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`IBinder`

writeStrongInterface

public void writeStrongInterface (IInterface val)

Write an object into the parcel at the current dataPosition(), growing dataCapacity() if needed.

Parameters
`val`	`IInterface`

writeTypedArray

public void writeTypedArray (T[] val, 
                int parcelableFlags)

Flatten a homogeneous array containing a particular object type into the parcel, at the current dataPosition() and growing dataCapacity() if needed. The type of the objects in the array must be one that implements Parcelable. Unlike the writeParcelableArray(T[], int) method, however, only the raw data of the objects is written and not their type, so you must use readTypedArray(T[], Parcelable.Creator) with the correct corresponding Parcelable.Creator implementation to unmarshall them.

Parameters
`val`	`T`: The array of objects to be written. This value may be `null`.
`parcelableFlags`	`int`: Contextual flags as per `Parcelable#writeToParcel(Parcel, int)`.

See also:

writeTypedArrayMap

public void writeTypedArrayMap (ArrayMap<String, T> val, 
                int parcelableFlags)

Flatten an ArrayMap with string keys containing a particular object type into the parcel at the current dataPosition() and growing dataCapacity() if needed. The type of the objects in the array must be one that implements Parcelable. Only the raw data of the objects is written and not their type, so you must use the corresponding createTypedArrayMap(android.os.Parcelable.Creator)

Parameters
`val`	`ArrayMap`: The map of objects to be written. This value may be `null`.
`parcelableFlags`	`int`: The parcelable flags to use.

See also:

writeTypedList

public void writeTypedList (List<T> val)

Flatten a List containing a particular object type into the parcel, at the current dataPosition() and growing dataCapacity() if needed. The type of the objects in the list must be one that implements Parcelable. Unlike the generic writeList() method, however, only the raw data of the objects is written and not their type, so you must use the corresponding readTypedList() to unmarshall them.

Parameters
`val`	`List`: The list of objects to be written. This value may be `null`.

See also:

writeTypedObject

public void writeTypedObject (T val, 
                int parcelableFlags)

Flatten the Parcelable object into the parcel.

Parameters
`val`	`T`: The Parcelable object to be written. This value may be `null`.
`parcelableFlags`	`int`: Contextual flags as per `Parcelable#writeToParcel(Parcel, int)`.

See also:

readTypedObject(Parcelable.Creator)

writeTypedSparseArray

public void writeTypedSparseArray (SparseArray<T> val, 
                int parcelableFlags)

Flatten a SparseArray containing a particular object type into the parcel at the current dataPosition() and growing dataCapacity() if needed. The type of the objects in the array must be one that implements Parcelable. Unlike the generic writeSparseArray(android.util.SparseArray) method, however, only the raw data of the objects is written and not their type, so you must use the corresponding createTypedSparseArray(android.os.Parcelable.Creator).

Parameters
`val`	`SparseArray`: The list of objects to be written. This value may be `null`.
`parcelableFlags`	`int`: The parcelable flags to use.

See also:

writeValue

public void writeValue (Object v)

Flatten a generic object in to a parcel. The given Object value may currently be one of the following types:

null
String
Byte
Short
Integer
Long
Float
Double
Boolean
String[]
boolean[]
byte[]
int[]
long[]
Object[] (supporting objects of the same type defined here).
Bundle
Map (as supported by writeMap(Map)).
Any object that implements the Parcelable protocol.
Parcelable[]
CharSequence (as supported by TextUtils#writeToParcel).
List (as supported by writeList(List)).
SparseArray (as supported by writeSparseArray(android.util.SparseArray)).
IBinder
Any object that implements Serializable (but see writeSerializable(Serializable) for caveats). Note that all of the previous types have relatively efficient implementations for writing to a Parcel; having to rely on the generic serialization approach is much less efficient and should be avoided whenever possible.

Parcelable objects are written with Parcelable#writeToParcel using contextual flags of 0. When serializing objects containing ParcelFileDescriptors, this may result in file descriptor leaks when they are returned from Binder calls (where Parcelable#PARCELABLE_WRITE_RETURN_VALUE should be used).

Parameters
`v`	`Object`: This value may be `null`.

Protected methods

finalize

protected void finalize ()

Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.

The general contract of finalize is that it is invoked if and when the Java™ virtual machine has determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, except as a result of an action taken by the finalization of some other object or class which is ready to be finalized. The finalize method may take any action, including making this object available again to other threads; the usual purpose of finalize, however, is to perform cleanup actions before the object is irrevocably discarded. For example, the finalize method for an object that represents an input/output connection might perform explicit I/O transactions to break the connection before the object is permanently discarded.

The finalize method of class Object performs no special action; it simply returns normally. Subclasses of Object may override this definition.

The Java programming language does not guarantee which thread will invoke the finalize method for any given object. It is guaranteed, however, that the thread that invokes finalize will not be holding any user-visible synchronization locks when finalize is invoked. If an uncaught exception is thrown by the finalize method, the exception is ignored and finalization of that object terminates.

After the finalize method has been invoked for an object, no further action is taken until the Java virtual machine has again determined that there is no longer any means by which this object can be accessed by any thread that has not yet died, including possible actions by other objects or classes which are ready to be finalized, at which point the object may be discarded.

The finalize method is never invoked more than once by a Java virtual machine for any given object.

Any exception thrown by the finalize method causes the finalization of this object to be halted, but is otherwise ignored.

Throws
`Throwable`