IT. Expert System.

Android Reference

Parcel


android.os

Class Parcel

    • Method Detail

      • obtain

        public static Parcel obtain()
        Retrieve a new Parcel object from the pool.
      • recycle

        public final void recycle()
        Put a Parcel object back into the pool. You must not touch the object after this call.
      • dataSize

        public final int dataSize()
        Returns the total amount of data contained in the parcel.
      • dataAvail

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

        public final int dataPosition()
        Returns the current position in the parcel data. Never more than dataSize().
      • dataCapacity

        public final 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.
      • setDataSize

        public final 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 - The new number of bytes in the Parcel.
      • setDataPosition

        public final void setDataPosition(int pos)
        Move the current read/write position in the parcel.
        Parameters:
        pos - New offset in the parcel; must be between 0 and dataSize().
      • setDataCapacity

        public final void setDataCapacity(int size)
        Change the capacity (current available space) of the parcel.
        Parameters:
        size - 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.
      • pushAllowFds

        public final boolean pushAllowFds(boolean allowFds)
      • restoreAllowFds

        public final void restoreAllowFds(boolean lastValue)
      • marshall

        public final 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.

      • unmarshall

        public final void unmarshall(byte[] data,
                      int offest,
                      int length)
        Set the bytes in data to be the raw bytes of this Parcel.
      • appendFrom

        public final void appendFrom(Parcel parcel,
                      int offset,
                      int length)
      • hasFileDescriptors

        public final boolean hasFileDescriptors()
        Report whether the parcel contains any marshalled file descriptors.
      • writeInterfaceToken

        public final 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.
      • enforceInterface

        public final void enforceInterface(String interfaceName)
      • writeByteArray

        public final void writeByteArray(byte[] b)
        Write a byte array into the parcel at the current dataPosition(), growing dataCapacity() if needed.
        Parameters:
        b - Bytes to place into the parcel.
      • writeByteArray

        public final 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 - Bytes to place into the parcel.
        offset - Index of first byte to be written.
        len - Number of bytes to write.
      • writeInt

        public final void writeInt(int val)
        Write an integer value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeLong

        public final void writeLong(long val)
        Write a long integer value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeFloat

        public final void writeFloat(float val)
        Write a floating point value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeDouble

        public final void writeDouble(double val)
        Write a double precision floating point value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeString

        public final void writeString(String val)
        Write a string value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeCharSequence

        public final void writeCharSequence(CharSequence val)
        Write a CharSequence value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeStrongBinder

        public final void writeStrongBinder(IBinder val)
        Write an object into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeStrongInterface

        public final void writeStrongInterface(IInterface val)
        Write an object into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeByte

        public final void writeByte(byte val)
        Write a byte value into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeMap

        public final void writeMap(Map val)
        Please use writeBundle(android.os.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(java.lang.Object) and must follow the specification there.

        It is strongly recommended to use writeBundle(android.os.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.

      • writeBundle

        public final void writeBundle(Bundle val)
        Flatten a Bundle into the parcel at the current dataPosition(), growing dataCapacity() if needed.
      • writeList

        public final 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(java.lang.Object) and must follow the specification there.
      • writeArray

        public final 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(java.lang.Object) and must follow the specification there.
      • writeSparseArray

        public final void writeSparseArray(SparseArray<Object> val)
        Flatten a generic SparseArray into the parcel at the current dataPosition(), growing dataCapacity() if needed. The SparseArray values are written using writeValue(java.lang.Object) and must follow the specification there.
      • writeSparseBooleanArray

        public final void writeSparseBooleanArray(SparseBooleanArray val)
      • writeBooleanArray

        public final void writeBooleanArray(boolean[] val)
      • createBooleanArray

        public final boolean[] createBooleanArray()
      • readBooleanArray

        public final void readBooleanArray(boolean[] val)
      • writeCharArray

        public final void writeCharArray(char[] val)
      • createCharArray

        public final char[] createCharArray()
      • readCharArray

        public final void readCharArray(char[] val)
      • writeIntArray

        public final void writeIntArray(int[] val)
      • createIntArray

        public final int[] createIntArray()
      • readIntArray

        public final void readIntArray(int[] val)
      • writeLongArray

        public final void writeLongArray(long[] val)
      • createLongArray

        public final long[] createLongArray()
      • readLongArray

        public final void readLongArray(long[] val)
      • writeFloatArray

        public final void writeFloatArray(float[] val)
      • createFloatArray

        public final float[] createFloatArray()
      • readFloatArray

        public final void readFloatArray(float[] val)
      • writeDoubleArray

        public final void writeDoubleArray(double[] val)
      • createDoubleArray

        public final double[] createDoubleArray()
      • readDoubleArray

        public final void readDoubleArray(double[] val)
      • writeStringArray

        public final void writeStringArray(String[] val)
      • createStringArray

        public final String[] createStringArray()
      • readStringArray

        public final void readStringArray(String[] val)
      • writeBinderArray

        public final void writeBinderArray(IBinder[] val)
      • writeCharSequenceArray

        public final void writeCharSequenceArray(CharSequence[] val)
      • createBinderArray

        public final IBinder[] createBinderArray()
      • readBinderArray

        public final void readBinderArray(IBinder[] val)
      • writeParcelable

        public final void writeParcelable(Parcelable p,
                           int parcelableFlags)
        Flatten the name of the class of the Parcelable and its contents into the parcel.
        Parameters:
        p - The Parcelable object to be written.
        parcelableFlags - Contextual flags as per Parcelable.writeToParcel().
      • writeSerializable

        public final 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.
      • readException

        public final 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:
        writeException(java.lang.Exception), writeNoException()
      • readExceptionCode

        public final int readExceptionCode()
        Parses the header of a Binder call's response Parcel and returns the exception code. Deals with lite or fat headers. In the common successful case, this header is generally zero. In less common cases, it's a small negative number and will be followed by an error string. This exists purely for android.database.DatabaseUtils and insulating it from having to handle fat headers as returned by e.g. StrictMode-induced RPC responses.
      • readException

        public final void readException(int code,
                         String msg)
        Use this function for customized exception handling. customized method call this method for all unknown case
        Parameters:
        code - exception code
        msg - exception message
      • readInt

        public final int readInt()
        Read an integer value from the parcel at the current dataPosition().
      • readLong

        public final long readLong()
        Read a long integer value from the parcel at the current dataPosition().
      • readFloat

        public final float readFloat()
        Read a floating point value from the parcel at the current dataPosition().
      • readDouble

        public final double readDouble()
        Read a double precision floating point value from the parcel at the current dataPosition().
      • readString

        public final String readString()
        Read a string value from the parcel at the current dataPosition().
      • readCharSequence

        public final CharSequence readCharSequence()
        Read a CharSequence value from the parcel at the current dataPosition().
      • readStrongBinder

        public final IBinder readStrongBinder()
        Read an object from the parcel at the current dataPosition().
      • readFileDescriptor

        public final ParcelFileDescriptor readFileDescriptor()
        Read a FileDescriptor from the parcel at the current dataPosition().
      • readByte

        public final byte readByte()
        Read a byte value from the parcel at the current dataPosition().
      • readList

        public final 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.
      • readHashMap

        public final HashMap readHashMap(ClassLoader loader)
        Please use readBundle(ClassLoader) instead (whose data must have been written with writeBundle(android.os.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.
      • readBundle

        public final 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.
      • readBundle

        public final 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.
      • createByteArray

        public final byte[] createByteArray()
        Read and return a byte[] object from the parcel.
      • readByteArray

        public final void readByteArray(byte[] val)
        Read a byte[] object from the parcel and copy it into the given byte array.
      • readStringArray

        public final String[] readStringArray()
        Read and return a String[] object from the parcel.
      • readCharSequenceArray

        public final CharSequence[] readCharSequenceArray()
        Read and return a CharSequence[] object from the parcel.
      • readArrayList

        public final 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.
      • readArray

        public final 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.
      • readSparseArray

        public final SparseArray 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.
      • readSparseBooleanArray

        public final 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.
      • createTypedArray

        public final <T> T[] createTypedArray(Parcelable.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.
        Returns:
        A newly created array containing objects with the same data as those that were previously written.
        See Also:
        writeTypedArray(T[], int)
      • writeParcelableArray

        public final <T extends Parcelable> 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 - The array of objects to be written.
        parcelableFlags - Contextual flags as per Parcelable.writeToParcel().
        See Also:
        writeTypedArray(T[], int)
      • readValue

        public final 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.
      • readParcelable

        public final <T extends Parcelable> 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 - A ClassLoader from which to instantiate the Parcelable object, or null for the default class loader.
        Returns:
        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 final 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.
        Returns:
        the Parcelable array, or null if the array is null
      • readSerializable

        public final Serializable readSerializable()
        Read and return a new Serializable object from the parcel.
        Returns:
        the Serializable object, or null if the Serializable name wasn't found in the parcel.
      • obtain

        protected static final Parcel obtain(int obj)
      • finalize

        protected void finalize()
                         throws Throwable
        Description copied from class: Object
        Invoked when the garbage collector has detected that this instance is no longer reachable. The default implementation does nothing, but this method can be overridden to free resources.

        Note that objects that override finalize are significantly more expensive than objects that don't. Finalizers may be run a long time after the object is no longer reachable, depending on memory pressure, so it's a bad idea to rely on them for cleanup. Note also that finalizers are run on a single VM-wide finalizer thread, so doing blocking work in a finalizer is a bad idea. A finalizer is usually only necessary for a class that has a native peer and needs to call a native method to destroy that peer. Even then, it's better to provide an explicit close method (and implement Closeable), and insist that callers manually dispose of instances. This works well for something like files, but less well for something like a BigInteger where typical calling code would have to deal with lots of temporaries. Unfortunately, code that creates lots of temporaries is the worst kind of code from the point of view of the single finalizer thread.

        If you must use finalizers, consider at least providing your own ReferenceQueue and having your own thread process that queue.

        Unlike constructors, finalizers are not automatically chained. You are responsible for calling super.finalize() yourself.

        Uncaught exceptions thrown by finalizers are ignored and do not terminate the finalizer thread. See Effective Java Item 7, "Avoid finalizers" for more.

        Overrides:
        finalize in class Object
        Throws:
        Throwable


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 971 / 96494524. Delta: 0.05362 с