1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.os;
18
19import android.annotation.IntegerRes;
20import android.annotation.Nullable;
21import android.text.TextUtils;
22import android.util.ArrayMap;
23import android.util.ArraySet;
24import android.util.Log;
25import android.util.Size;
26import android.util.SizeF;
27import android.util.SparseArray;
28import android.util.SparseBooleanArray;
29
30import java.io.ByteArrayInputStream;
31import java.io.ByteArrayOutputStream;
32import java.io.FileDescriptor;
33import java.io.FileNotFoundException;
34import java.io.IOException;
35import java.io.ObjectInputStream;
36import java.io.ObjectOutputStream;
37import java.io.ObjectStreamClass;
38import java.io.Serializable;
39import java.lang.reflect.Field;
40import java.lang.reflect.Modifier;
41import java.util.ArrayList;
42import java.util.Arrays;
43import java.util.HashMap;
44import java.util.List;
45import java.util.Map;
46import java.util.Set;
47
48import dalvik.system.VMRuntime;
49
50/**
51 * Container for a message (data and object references) that can
52 * be sent through an IBinder.  A Parcel can contain both flattened data
53 * that will be unflattened on the other side of the IPC (using the various
54 * methods here for writing specific types, or the general
55 * {@link Parcelable} interface), and references to live {@link IBinder}
56 * objects that will result in the other side receiving a proxy IBinder
57 * connected with the original IBinder in the Parcel.
58 *
59 * <p class="note">Parcel is <strong>not</strong> a general-purpose
60 * serialization mechanism.  This class (and the corresponding
61 * {@link Parcelable} API for placing arbitrary objects into a Parcel) is
62 * designed as a high-performance IPC transport.  As such, it is not
63 * appropriate to place any Parcel data in to persistent storage: changes
64 * in the underlying implementation of any of the data in the Parcel can
65 * render older data unreadable.</p>
66 *
67 * <p>The bulk of the Parcel API revolves around reading and writing data
68 * of various types.  There are six major classes of such functions available.</p>
69 *
70 * <h3>Primitives</h3>
71 *
72 * <p>The most basic data functions are for writing and reading primitive
73 * data types: {@link #writeByte}, {@link #readByte}, {@link #writeDouble},
74 * {@link #readDouble}, {@link #writeFloat}, {@link #readFloat}, {@link #writeInt},
75 * {@link #readInt}, {@link #writeLong}, {@link #readLong},
76 * {@link #writeString}, {@link #readString}.  Most other
77 * data operations are built on top of these.  The given data is written and
78 * read using the endianess of the host CPU.</p>
79 *
80 * <h3>Primitive Arrays</h3>
81 *
82 * <p>There are a variety of methods for reading and writing raw arrays
83 * of primitive objects, which generally result in writing a 4-byte length
84 * followed by the primitive data items.  The methods for reading can either
85 * read the data into an existing array, or create and return a new array.
86 * These available types are:</p>
87 *
88 * <ul>
89 * <li> {@link #writeBooleanArray(boolean[])},
90 * {@link #readBooleanArray(boolean[])}, {@link #createBooleanArray()}
91 * <li> {@link #writeByteArray(byte[])},
92 * {@link #writeByteArray(byte[], int, int)}, {@link #readByteArray(byte[])},
93 * {@link #createByteArray()}
94 * <li> {@link #writeCharArray(char[])}, {@link #readCharArray(char[])},
95 * {@link #createCharArray()}
96 * <li> {@link #writeDoubleArray(double[])}, {@link #readDoubleArray(double[])},
97 * {@link #createDoubleArray()}
98 * <li> {@link #writeFloatArray(float[])}, {@link #readFloatArray(float[])},
99 * {@link #createFloatArray()}
100 * <li> {@link #writeIntArray(int[])}, {@link #readIntArray(int[])},
101 * {@link #createIntArray()}
102 * <li> {@link #writeLongArray(long[])}, {@link #readLongArray(long[])},
103 * {@link #createLongArray()}
104 * <li> {@link #writeStringArray(String[])}, {@link #readStringArray(String[])},
105 * {@link #createStringArray()}.
106 * <li> {@link #writeSparseBooleanArray(SparseBooleanArray)},
107 * {@link #readSparseBooleanArray()}.
108 * </ul>
109 *
110 * <h3>Parcelables</h3>
111 *
112 * <p>The {@link Parcelable} protocol provides an extremely efficient (but
113 * low-level) protocol for objects to write and read themselves from Parcels.
114 * You can use the direct methods {@link #writeParcelable(Parcelable, int)}
115 * and {@link #readParcelable(ClassLoader)} or
116 * {@link #writeParcelableArray} and
117 * {@link #readParcelableArray(ClassLoader)} to write or read.  These
118 * methods write both the class type and its data to the Parcel, allowing
119 * that class to be reconstructed from the appropriate class loader when
120 * later reading.</p>
121 *
122 * <p>There are also some methods that provide a more efficient way to work
123 * with Parcelables: {@link #writeTypedObject}, {@link #writeTypedArray},
124 * {@link #writeTypedList}, {@link #readTypedObject},
125 * {@link #createTypedArray} and {@link #createTypedArrayList}.  These methods
126 * do not write the class information of the original object: instead, the
127 * caller of the read function must know what type to expect and pass in the
128 * appropriate {@link Parcelable.Creator Parcelable.Creator} instead to
129 * properly construct the new object and read its data.  (To more efficient
130 * write and read a single Parceable object that is not null, you can directly
131 * call {@link Parcelable#writeToParcel Parcelable.writeToParcel} and
132 * {@link Parcelable.Creator#createFromParcel Parcelable.Creator.createFromParcel}
133 * yourself.)</p>
134 *
135 * <h3>Bundles</h3>
136 *
137 * <p>A special type-safe container, called {@link Bundle}, is available
138 * for key/value maps of heterogeneous values.  This has many optimizations
139 * for improved performance when reading and writing data, and its type-safe
140 * API avoids difficult to debug type errors when finally marshalling the
141 * data contents into a Parcel.  The methods to use are
142 * {@link #writeBundle(Bundle)}, {@link #readBundle()}, and
143 * {@link #readBundle(ClassLoader)}.
144 *
145 * <h3>Active Objects</h3>
146 *
147 * <p>An unusual feature of Parcel is the ability to read and write active
148 * objects.  For these objects the actual contents of the object is not
149 * written, rather a special token referencing the object is written.  When
150 * reading the object back from the Parcel, you do not get a new instance of
151 * the object, but rather a handle that operates on the exact same object that
152 * was originally written.  There are two forms of active objects available.</p>
153 *
154 * <p>{@link Binder} objects are a core facility of Android's general cross-process
155 * communication system.  The {@link IBinder} interface describes an abstract
156 * protocol with a Binder object.  Any such interface can be written in to
157 * a Parcel, and upon reading you will receive either the original object
158 * implementing that interface or a special proxy implementation
159 * that communicates calls back to the original object.  The methods to use are
160 * {@link #writeStrongBinder(IBinder)},
161 * {@link #writeStrongInterface(IInterface)}, {@link #readStrongBinder()},
162 * {@link #writeBinderArray(IBinder[])}, {@link #readBinderArray(IBinder[])},
163 * {@link #createBinderArray()},
164 * {@link #writeBinderList(List)}, {@link #readBinderList(List)},
165 * {@link #createBinderArrayList()}.</p>
166 *
167 * <p>FileDescriptor objects, representing raw Linux file descriptor identifiers,
168 * can be written and {@link ParcelFileDescriptor} objects returned to operate
169 * on the original file descriptor.  The returned file descriptor is a dup
170 * of the original file descriptor: the object and fd is different, but
171 * operating on the same underlying file stream, with the same position, etc.
172 * The methods to use are {@link #writeFileDescriptor(FileDescriptor)},
173 * {@link #readFileDescriptor()}.
174 *
175 * <h3>Untyped Containers</h3>
176 *
177 * <p>A final class of methods are for writing and reading standard Java
178 * containers of arbitrary types.  These all revolve around the
179 * {@link #writeValue(Object)} and {@link #readValue(ClassLoader)} methods
180 * which define the types of objects allowed.  The container methods are
181 * {@link #writeArray(Object[])}, {@link #readArray(ClassLoader)},
182 * {@link #writeList(List)}, {@link #readList(List, ClassLoader)},
183 * {@link #readArrayList(ClassLoader)},
184 * {@link #writeMap(Map)}, {@link #readMap(Map, ClassLoader)},
185 * {@link #writeSparseArray(SparseArray)},
186 * {@link #readSparseArray(ClassLoader)}.
187 */
188public final class Parcel {
189    private static final boolean DEBUG_RECYCLE = false;
190    private static final boolean DEBUG_ARRAY_MAP = false;
191    private static final String TAG = "Parcel";
192
193    @SuppressWarnings({"UnusedDeclaration"})
194    private long mNativePtr; // used by native code
195
196    /**
197     * Flag indicating if {@link #mNativePtr} was allocated by this object,
198     * indicating that we're responsible for its lifecycle.
199     */
200    private boolean mOwnsNativeParcelObject;
201    private long mNativeSize;
202
203    private RuntimeException mStack;
204
205    private static final int POOL_SIZE = 6;
206    private static final Parcel[] sOwnedPool = new Parcel[POOL_SIZE];
207    private static final Parcel[] sHolderPool = new Parcel[POOL_SIZE];
208
209    // Keep in sync with frameworks/native/libs/binder/PersistableBundle.cpp.
210    private static final int VAL_NULL = -1;
211    private static final int VAL_STRING = 0;
212    private static final int VAL_INTEGER = 1;
213    private static final int VAL_MAP = 2;
214    private static final int VAL_BUNDLE = 3;
215    private static final int VAL_PARCELABLE = 4;
216    private static final int VAL_SHORT = 5;
217    private static final int VAL_LONG = 6;
218    private static final int VAL_FLOAT = 7;
219    private static final int VAL_DOUBLE = 8;
220    private static final int VAL_BOOLEAN = 9;
221    private static final int VAL_CHARSEQUENCE = 10;
222    private static final int VAL_LIST  = 11;
223    private static final int VAL_SPARSEARRAY = 12;
224    private static final int VAL_BYTEARRAY = 13;
225    private static final int VAL_STRINGARRAY = 14;
226    private static final int VAL_IBINDER = 15;
227    private static final int VAL_PARCELABLEARRAY = 16;
228    private static final int VAL_OBJECTARRAY = 17;
229    private static final int VAL_INTARRAY = 18;
230    private static final int VAL_LONGARRAY = 19;
231    private static final int VAL_BYTE = 20;
232    private static final int VAL_SERIALIZABLE = 21;
233    private static final int VAL_SPARSEBOOLEANARRAY = 22;
234    private static final int VAL_BOOLEANARRAY = 23;
235    private static final int VAL_CHARSEQUENCEARRAY = 24;
236    private static final int VAL_PERSISTABLEBUNDLE = 25;
237    private static final int VAL_SIZE = 26;
238    private static final int VAL_SIZEF = 27;
239    private static final int VAL_DOUBLEARRAY = 28;
240
241    // The initial int32 in a Binder call's reply Parcel header:
242    // Keep these in sync with libbinder's binder/Status.h.
243    private static final int EX_SECURITY = -1;
244    private static final int EX_BAD_PARCELABLE = -2;
245    private static final int EX_ILLEGAL_ARGUMENT = -3;
246    private static final int EX_NULL_POINTER = -4;
247    private static final int EX_ILLEGAL_STATE = -5;
248    private static final int EX_NETWORK_MAIN_THREAD = -6;
249    private static final int EX_UNSUPPORTED_OPERATION = -7;
250    private static final int EX_SERVICE_SPECIFIC = -8;
251    private static final int EX_HAS_REPLY_HEADER = -128;  // special; see below
252    // EX_TRANSACTION_FAILED is used exclusively in native code.
253    // see libbinder's binder/Status.h
254    private static final int EX_TRANSACTION_FAILED = -129;
255
256    private static native int nativeDataSize(long nativePtr);
257    private static native int nativeDataAvail(long nativePtr);
258    private static native int nativeDataPosition(long nativePtr);
259    private static native int nativeDataCapacity(long nativePtr);
260    private static native long nativeSetDataSize(long nativePtr, int size);
261    private static native void nativeSetDataPosition(long nativePtr, int pos);
262    private static native void nativeSetDataCapacity(long nativePtr, int size);
263
264    private static native boolean nativePushAllowFds(long nativePtr, boolean allowFds);
265    private static native void nativeRestoreAllowFds(long nativePtr, boolean lastValue);
266
267    private static native void nativeWriteByteArray(long nativePtr, byte[] b, int offset, int len);
268    private static native void nativeWriteBlob(long nativePtr, byte[] b, int offset, int len);
269    private static native void nativeWriteInt(long nativePtr, int val);
270    private static native void nativeWriteLong(long nativePtr, long val);
271    private static native void nativeWriteFloat(long nativePtr, float val);
272    private static native void nativeWriteDouble(long nativePtr, double val);
273    private static native void nativeWriteString(long nativePtr, String val);
274    private static native void nativeWriteStrongBinder(long nativePtr, IBinder val);
275    private static native long nativeWriteFileDescriptor(long nativePtr, FileDescriptor val);
276
277    private static native byte[] nativeCreateByteArray(long nativePtr);
278    private static native byte[] nativeReadBlob(long nativePtr);
279    private static native int nativeReadInt(long nativePtr);
280    private static native long nativeReadLong(long nativePtr);
281    private static native float nativeReadFloat(long nativePtr);
282    private static native double nativeReadDouble(long nativePtr);
283    private static native String nativeReadString(long nativePtr);
284    private static native IBinder nativeReadStrongBinder(long nativePtr);
285    private static native FileDescriptor nativeReadFileDescriptor(long nativePtr);
286
287    private static native long nativeCreate();
288    private static native long nativeFreeBuffer(long nativePtr);
289    private static native void nativeDestroy(long nativePtr);
290
291    private static native byte[] nativeMarshall(long nativePtr);
292    private static native long nativeUnmarshall(
293            long nativePtr, byte[] data, int offset, int length);
294    private static native long nativeAppendFrom(
295            long thisNativePtr, long otherNativePtr, int offset, int length);
296    private static native boolean nativeHasFileDescriptors(long nativePtr);
297    private static native void nativeWriteInterfaceToken(long nativePtr, String interfaceName);
298    private static native void nativeEnforceInterface(long nativePtr, String interfaceName);
299
300    private static native long nativeGetBlobAshmemSize(long nativePtr);
301
302    public final static Parcelable.Creator<String> STRING_CREATOR
303             = new Parcelable.Creator<String>() {
304        public String createFromParcel(Parcel source) {
305            return source.readString();
306        }
307        public String[] newArray(int size) {
308            return new String[size];
309        }
310    };
311
312    /**
313     * Retrieve a new Parcel object from the pool.
314     */
315    public static Parcel obtain() {
316        final Parcel[] pool = sOwnedPool;
317        synchronized (pool) {
318            Parcel p;
319            for (int i=0; i<POOL_SIZE; i++) {
320                p = pool[i];
321                if (p != null) {
322                    pool[i] = null;
323                    if (DEBUG_RECYCLE) {
324                        p.mStack = new RuntimeException();
325                    }
326                    return p;
327                }
328            }
329        }
330        return new Parcel(0);
331    }
332
333    /**
334     * Put a Parcel object back into the pool.  You must not touch
335     * the object after this call.
336     */
337    public final void recycle() {
338        if (DEBUG_RECYCLE) mStack = null;
339        freeBuffer();
340
341        final Parcel[] pool;
342        if (mOwnsNativeParcelObject) {
343            pool = sOwnedPool;
344        } else {
345            mNativePtr = 0;
346            pool = sHolderPool;
347        }
348
349        synchronized (pool) {
350            for (int i=0; i<POOL_SIZE; i++) {
351                if (pool[i] == null) {
352                    pool[i] = this;
353                    return;
354                }
355            }
356        }
357    }
358
359    /** @hide */
360    public static native long getGlobalAllocSize();
361
362    /** @hide */
363    public static native long getGlobalAllocCount();
364
365    /**
366     * Returns the total amount of data contained in the parcel.
367     */
368    public final int dataSize() {
369        return nativeDataSize(mNativePtr);
370    }
371
372    /**
373     * Returns the amount of data remaining to be read from the
374     * parcel.  That is, {@link #dataSize}-{@link #dataPosition}.
375     */
376    public final int dataAvail() {
377        return nativeDataAvail(mNativePtr);
378    }
379
380    /**
381     * Returns the current position in the parcel data.  Never
382     * more than {@link #dataSize}.
383     */
384    public final int dataPosition() {
385        return nativeDataPosition(mNativePtr);
386    }
387
388    /**
389     * Returns the total amount of space in the parcel.  This is always
390     * >= {@link #dataSize}.  The difference between it and dataSize() is the
391     * amount of room left until the parcel needs to re-allocate its
392     * data buffer.
393     */
394    public final int dataCapacity() {
395        return nativeDataCapacity(mNativePtr);
396    }
397
398    /**
399     * Change the amount of data in the parcel.  Can be either smaller or
400     * larger than the current size.  If larger than the current capacity,
401     * more memory will be allocated.
402     *
403     * @param size The new number of bytes in the Parcel.
404     */
405    public final void setDataSize(int size) {
406        updateNativeSize(nativeSetDataSize(mNativePtr, size));
407    }
408
409    /**
410     * Move the current read/write position in the parcel.
411     * @param pos New offset in the parcel; must be between 0 and
412     * {@link #dataSize}.
413     */
414    public final void setDataPosition(int pos) {
415        nativeSetDataPosition(mNativePtr, pos);
416    }
417
418    /**
419     * Change the capacity (current available space) of the parcel.
420     *
421     * @param size The new capacity of the parcel, in bytes.  Can not be
422     * less than {@link #dataSize} -- that is, you can not drop existing data
423     * with this method.
424     */
425    public final void setDataCapacity(int size) {
426        nativeSetDataCapacity(mNativePtr, size);
427    }
428
429    /** @hide */
430    public final boolean pushAllowFds(boolean allowFds) {
431        return nativePushAllowFds(mNativePtr, allowFds);
432    }
433
434    /** @hide */
435    public final void restoreAllowFds(boolean lastValue) {
436        nativeRestoreAllowFds(mNativePtr, lastValue);
437    }
438
439    /**
440     * Returns the raw bytes of the parcel.
441     *
442     * <p class="note">The data you retrieve here <strong>must not</strong>
443     * be placed in any kind of persistent storage (on local disk, across
444     * a network, etc).  For that, you should use standard serialization
445     * or another kind of general serialization mechanism.  The Parcel
446     * marshalled representation is highly optimized for local IPC, and as
447     * such does not attempt to maintain compatibility with data created
448     * in different versions of the platform.
449     */
450    public final byte[] marshall() {
451        return nativeMarshall(mNativePtr);
452    }
453
454    /**
455     * Set the bytes in data to be the raw bytes of this Parcel.
456     */
457    public final void unmarshall(byte[] data, int offset, int length) {
458        updateNativeSize(nativeUnmarshall(mNativePtr, data, offset, length));
459    }
460
461    public final void appendFrom(Parcel parcel, int offset, int length) {
462        updateNativeSize(nativeAppendFrom(mNativePtr, parcel.mNativePtr, offset, length));
463    }
464
465    /**
466     * Report whether the parcel contains any marshalled file descriptors.
467     */
468    public final boolean hasFileDescriptors() {
469        return nativeHasFileDescriptors(mNativePtr);
470    }
471
472    /**
473     * Store or read an IBinder interface token in the parcel at the current
474     * {@link #dataPosition}.  This is used to validate that the marshalled
475     * transaction is intended for the target interface.
476     */
477    public final void writeInterfaceToken(String interfaceName) {
478        nativeWriteInterfaceToken(mNativePtr, interfaceName);
479    }
480
481    public final void enforceInterface(String interfaceName) {
482        nativeEnforceInterface(mNativePtr, interfaceName);
483    }
484
485    /**
486     * Write a byte array into the parcel at the current {@link #dataPosition},
487     * growing {@link #dataCapacity} if needed.
488     * @param b Bytes to place into the parcel.
489     */
490    public final void writeByteArray(byte[] b) {
491        writeByteArray(b, 0, (b != null) ? b.length : 0);
492    }
493
494    /**
495     * Write a byte array into the parcel at the current {@link #dataPosition},
496     * growing {@link #dataCapacity} if needed.
497     * @param b Bytes to place into the parcel.
498     * @param offset Index of first byte to be written.
499     * @param len Number of bytes to write.
500     */
501    public final void writeByteArray(byte[] b, int offset, int len) {
502        if (b == null) {
503            writeInt(-1);
504            return;
505        }
506        Arrays.checkOffsetAndCount(b.length, offset, len);
507        nativeWriteByteArray(mNativePtr, b, offset, len);
508    }
509
510    /**
511     * Write a blob of data into the parcel at the current {@link #dataPosition},
512     * growing {@link #dataCapacity} if needed.
513     * @param b Bytes to place into the parcel.
514     * {@hide}
515     * {@SystemApi}
516     */
517    public final void writeBlob(byte[] b) {
518        writeBlob(b, 0, (b != null) ? b.length : 0);
519    }
520
521    /**
522     * Write a blob of data into the parcel at the current {@link #dataPosition},
523     * growing {@link #dataCapacity} if needed.
524     * @param b Bytes to place into the parcel.
525     * @param offset Index of first byte to be written.
526     * @param len Number of bytes to write.
527     * {@hide}
528     * {@SystemApi}
529     */
530    public final void writeBlob(byte[] b, int offset, int len) {
531        if (b == null) {
532            writeInt(-1);
533            return;
534        }
535        Arrays.checkOffsetAndCount(b.length, offset, len);
536        nativeWriteBlob(mNativePtr, b, offset, len);
537    }
538
539    /**
540     * Write an integer value into the parcel at the current dataPosition(),
541     * growing dataCapacity() if needed.
542     */
543    public final void writeInt(int val) {
544        nativeWriteInt(mNativePtr, val);
545    }
546
547    /**
548     * Write a long integer value into the parcel at the current dataPosition(),
549     * growing dataCapacity() if needed.
550     */
551    public final void writeLong(long val) {
552        nativeWriteLong(mNativePtr, val);
553    }
554
555    /**
556     * Write a floating point value into the parcel at the current
557     * dataPosition(), growing dataCapacity() if needed.
558     */
559    public final void writeFloat(float val) {
560        nativeWriteFloat(mNativePtr, val);
561    }
562
563    /**
564     * Write a double precision floating point value into the parcel at the
565     * current dataPosition(), growing dataCapacity() if needed.
566     */
567    public final void writeDouble(double val) {
568        nativeWriteDouble(mNativePtr, val);
569    }
570
571    /**
572     * Write a string value into the parcel at the current dataPosition(),
573     * growing dataCapacity() if needed.
574     */
575    public final void writeString(String val) {
576        nativeWriteString(mNativePtr, val);
577    }
578
579    /**
580     * Write a CharSequence value into the parcel at the current dataPosition(),
581     * growing dataCapacity() if needed.
582     * @hide
583     */
584    public final void writeCharSequence(CharSequence val) {
585        TextUtils.writeToParcel(val, this, 0);
586    }
587
588    /**
589     * Write an object into the parcel at the current dataPosition(),
590     * growing dataCapacity() if needed.
591     */
592    public final void writeStrongBinder(IBinder val) {
593        nativeWriteStrongBinder(mNativePtr, val);
594    }
595
596    /**
597     * Write an object into the parcel at the current dataPosition(),
598     * growing dataCapacity() if needed.
599     */
600    public final void writeStrongInterface(IInterface val) {
601        writeStrongBinder(val == null ? null : val.asBinder());
602    }
603
604    /**
605     * Write a FileDescriptor into the parcel at the current dataPosition(),
606     * growing dataCapacity() if needed.
607     *
608     * <p class="caution">The file descriptor will not be closed, which may
609     * result in file descriptor leaks when objects are returned from Binder
610     * calls.  Use {@link ParcelFileDescriptor#writeToParcel} instead, which
611     * accepts contextual flags and will close the original file descriptor
612     * if {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE} is set.</p>
613     */
614    public final void writeFileDescriptor(FileDescriptor val) {
615        updateNativeSize(nativeWriteFileDescriptor(mNativePtr, val));
616    }
617
618    private void updateNativeSize(long newNativeSize) {
619        if (mOwnsNativeParcelObject) {
620            if (newNativeSize > Integer.MAX_VALUE) {
621                newNativeSize = Integer.MAX_VALUE;
622            }
623            if (newNativeSize != mNativeSize) {
624                int delta = (int) (newNativeSize - mNativeSize);
625                if (delta > 0) {
626                    VMRuntime.getRuntime().registerNativeAllocation(delta);
627                } else {
628                    VMRuntime.getRuntime().registerNativeFree(-delta);
629                }
630                mNativeSize = newNativeSize;
631            }
632        }
633    }
634
635    /**
636     * {@hide}
637     * This will be the new name for writeFileDescriptor, for consistency.
638     **/
639    public final void writeRawFileDescriptor(FileDescriptor val) {
640        nativeWriteFileDescriptor(mNativePtr, val);
641    }
642
643    /**
644     * {@hide}
645     * Write an array of FileDescriptor objects into the Parcel.
646     *
647     * @param value The array of objects to be written.
648     */
649    public final void writeRawFileDescriptorArray(FileDescriptor[] value) {
650        if (value != null) {
651            int N = value.length;
652            writeInt(N);
653            for (int i=0; i<N; i++) {
654                writeRawFileDescriptor(value[i]);
655            }
656        } else {
657            writeInt(-1);
658        }
659    }
660
661    /**
662     * Write a byte value into the parcel at the current dataPosition(),
663     * growing dataCapacity() if needed.
664     */
665    public final void writeByte(byte val) {
666        writeInt(val);
667    }
668
669    /**
670     * Please use {@link #writeBundle} instead.  Flattens a Map into the parcel
671     * at the current dataPosition(),
672     * growing dataCapacity() if needed.  The Map keys must be String objects.
673     * The Map values are written using {@link #writeValue} and must follow
674     * the specification there.
675     *
676     * <p>It is strongly recommended to use {@link #writeBundle} instead of
677     * this method, since the Bundle class provides a type-safe API that
678     * allows you to avoid mysterious type errors at the point of marshalling.
679     */
680    public final void writeMap(Map val) {
681        writeMapInternal((Map<String, Object>) val);
682    }
683
684    /**
685     * Flatten a Map into the parcel at the current dataPosition(),
686     * growing dataCapacity() if needed.  The Map keys must be String objects.
687     */
688    /* package */ void writeMapInternal(Map<String,Object> val) {
689        if (val == null) {
690            writeInt(-1);
691            return;
692        }
693        Set<Map.Entry<String,Object>> entries = val.entrySet();
694        writeInt(entries.size());
695        for (Map.Entry<String,Object> e : entries) {
696            writeValue(e.getKey());
697            writeValue(e.getValue());
698        }
699    }
700
701    /**
702     * Flatten an ArrayMap into the parcel at the current dataPosition(),
703     * growing dataCapacity() if needed.  The Map keys must be String objects.
704     */
705    /* package */ void writeArrayMapInternal(ArrayMap<String, Object> val) {
706        if (val == null) {
707            writeInt(-1);
708            return;
709        }
710        // Keep the format of this Parcel in sync with writeToParcelInner() in
711        // frameworks/native/libs/binder/PersistableBundle.cpp.
712        final int N = val.size();
713        writeInt(N);
714        if (DEBUG_ARRAY_MAP) {
715            RuntimeException here =  new RuntimeException("here");
716            here.fillInStackTrace();
717            Log.d(TAG, "Writing " + N + " ArrayMap entries", here);
718        }
719        int startPos;
720        for (int i=0; i<N; i++) {
721            if (DEBUG_ARRAY_MAP) startPos = dataPosition();
722            writeString(val.keyAt(i));
723            writeValue(val.valueAt(i));
724            if (DEBUG_ARRAY_MAP) Log.d(TAG, "  Write #" + i + " "
725                    + (dataPosition()-startPos) + " bytes: key=0x"
726                    + Integer.toHexString(val.keyAt(i) != null ? val.keyAt(i).hashCode() : 0)
727                    + " " + val.keyAt(i));
728        }
729    }
730
731    /**
732     * @hide For testing only.
733     */
734    public void writeArrayMap(ArrayMap<String, Object> val) {
735        writeArrayMapInternal(val);
736    }
737
738    /**
739     * Write an array set to the parcel.
740     *
741     * @param val The array set to write.
742     *
743     * @hide
744     */
745    public void writeArraySet(@Nullable ArraySet<? extends Object> val) {
746        final int size = (val != null) ? val.size() : -1;
747        writeInt(size);
748        for (int i = 0; i < size; i++) {
749            writeValue(val.valueAt(i));
750        }
751    }
752
753    /**
754     * Flatten a Bundle into the parcel at the current dataPosition(),
755     * growing dataCapacity() if needed.
756     */
757    public final void writeBundle(Bundle val) {
758        if (val == null) {
759            writeInt(-1);
760            return;
761        }
762
763        val.writeToParcel(this, 0);
764    }
765
766    /**
767     * Flatten a PersistableBundle into the parcel at the current dataPosition(),
768     * growing dataCapacity() if needed.
769     */
770    public final void writePersistableBundle(PersistableBundle val) {
771        if (val == null) {
772            writeInt(-1);
773            return;
774        }
775
776        val.writeToParcel(this, 0);
777    }
778
779    /**
780     * Flatten a Size into the parcel at the current dataPosition(),
781     * growing dataCapacity() if needed.
782     */
783    public final void writeSize(Size val) {
784        writeInt(val.getWidth());
785        writeInt(val.getHeight());
786    }
787
788    /**
789     * Flatten a SizeF into the parcel at the current dataPosition(),
790     * growing dataCapacity() if needed.
791     */
792    public final void writeSizeF(SizeF val) {
793        writeFloat(val.getWidth());
794        writeFloat(val.getHeight());
795    }
796
797    /**
798     * Flatten a List into the parcel at the current dataPosition(), growing
799     * dataCapacity() if needed.  The List values are written using
800     * {@link #writeValue} and must follow the specification there.
801     */
802    public final void writeList(List val) {
803        if (val == null) {
804            writeInt(-1);
805            return;
806        }
807        int N = val.size();
808        int i=0;
809        writeInt(N);
810        while (i < N) {
811            writeValue(val.get(i));
812            i++;
813        }
814    }
815
816    /**
817     * Flatten an Object array into the parcel at the current dataPosition(),
818     * growing dataCapacity() if needed.  The array values are written using
819     * {@link #writeValue} and must follow the specification there.
820     */
821    public final void writeArray(Object[] val) {
822        if (val == null) {
823            writeInt(-1);
824            return;
825        }
826        int N = val.length;
827        int i=0;
828        writeInt(N);
829        while (i < N) {
830            writeValue(val[i]);
831            i++;
832        }
833    }
834
835    /**
836     * Flatten a generic SparseArray into the parcel at the current
837     * dataPosition(), growing dataCapacity() if needed.  The SparseArray
838     * values are written using {@link #writeValue} and must follow the
839     * specification there.
840     */
841    public final void writeSparseArray(SparseArray<Object> val) {
842        if (val == null) {
843            writeInt(-1);
844            return;
845        }
846        int N = val.size();
847        writeInt(N);
848        int i=0;
849        while (i < N) {
850            writeInt(val.keyAt(i));
851            writeValue(val.valueAt(i));
852            i++;
853        }
854    }
855
856    public final void writeSparseBooleanArray(SparseBooleanArray val) {
857        if (val == null) {
858            writeInt(-1);
859            return;
860        }
861        int N = val.size();
862        writeInt(N);
863        int i=0;
864        while (i < N) {
865            writeInt(val.keyAt(i));
866            writeByte((byte)(val.valueAt(i) ? 1 : 0));
867            i++;
868        }
869    }
870
871    public final void writeBooleanArray(boolean[] val) {
872        if (val != null) {
873            int N = val.length;
874            writeInt(N);
875            for (int i=0; i<N; i++) {
876                writeInt(val[i] ? 1 : 0);
877            }
878        } else {
879            writeInt(-1);
880        }
881    }
882
883    public final boolean[] createBooleanArray() {
884        int N = readInt();
885        // >>2 as a fast divide-by-4 works in the create*Array() functions
886        // because dataAvail() will never return a negative number.  4 is
887        // the size of a stored boolean in the stream.
888        if (N >= 0 && N <= (dataAvail() >> 2)) {
889            boolean[] val = new boolean[N];
890            for (int i=0; i<N; i++) {
891                val[i] = readInt() != 0;
892            }
893            return val;
894        } else {
895            return null;
896        }
897    }
898
899    public final void readBooleanArray(boolean[] val) {
900        int N = readInt();
901        if (N == val.length) {
902            for (int i=0; i<N; i++) {
903                val[i] = readInt() != 0;
904            }
905        } else {
906            throw new RuntimeException("bad array lengths");
907        }
908    }
909
910    public final void writeCharArray(char[] val) {
911        if (val != null) {
912            int N = val.length;
913            writeInt(N);
914            for (int i=0; i<N; i++) {
915                writeInt((int)val[i]);
916            }
917        } else {
918            writeInt(-1);
919        }
920    }
921
922    public final char[] createCharArray() {
923        int N = readInt();
924        if (N >= 0 && N <= (dataAvail() >> 2)) {
925            char[] val = new char[N];
926            for (int i=0; i<N; i++) {
927                val[i] = (char)readInt();
928            }
929            return val;
930        } else {
931            return null;
932        }
933    }
934
935    public final void readCharArray(char[] val) {
936        int N = readInt();
937        if (N == val.length) {
938            for (int i=0; i<N; i++) {
939                val[i] = (char)readInt();
940            }
941        } else {
942            throw new RuntimeException("bad array lengths");
943        }
944    }
945
946    public final void writeIntArray(int[] val) {
947        if (val != null) {
948            int N = val.length;
949            writeInt(N);
950            for (int i=0; i<N; i++) {
951                writeInt(val[i]);
952            }
953        } else {
954            writeInt(-1);
955        }
956    }
957
958    public final int[] createIntArray() {
959        int N = readInt();
960        if (N >= 0 && N <= (dataAvail() >> 2)) {
961            int[] val = new int[N];
962            for (int i=0; i<N; i++) {
963                val[i] = readInt();
964            }
965            return val;
966        } else {
967            return null;
968        }
969    }
970
971    public final void readIntArray(int[] val) {
972        int N = readInt();
973        if (N == val.length) {
974            for (int i=0; i<N; i++) {
975                val[i] = readInt();
976            }
977        } else {
978            throw new RuntimeException("bad array lengths");
979        }
980    }
981
982    public final void writeLongArray(long[] val) {
983        if (val != null) {
984            int N = val.length;
985            writeInt(N);
986            for (int i=0; i<N; i++) {
987                writeLong(val[i]);
988            }
989        } else {
990            writeInt(-1);
991        }
992    }
993
994    public final long[] createLongArray() {
995        int N = readInt();
996        // >>3 because stored longs are 64 bits
997        if (N >= 0 && N <= (dataAvail() >> 3)) {
998            long[] val = new long[N];
999            for (int i=0; i<N; i++) {
1000                val[i] = readLong();
1001            }
1002            return val;
1003        } else {
1004            return null;
1005        }
1006    }
1007
1008    public final void readLongArray(long[] val) {
1009        int N = readInt();
1010        if (N == val.length) {
1011            for (int i=0; i<N; i++) {
1012                val[i] = readLong();
1013            }
1014        } else {
1015            throw new RuntimeException("bad array lengths");
1016        }
1017    }
1018
1019    public final void writeFloatArray(float[] val) {
1020        if (val != null) {
1021            int N = val.length;
1022            writeInt(N);
1023            for (int i=0; i<N; i++) {
1024                writeFloat(val[i]);
1025            }
1026        } else {
1027            writeInt(-1);
1028        }
1029    }
1030
1031    public final float[] createFloatArray() {
1032        int N = readInt();
1033        // >>2 because stored floats are 4 bytes
1034        if (N >= 0 && N <= (dataAvail() >> 2)) {
1035            float[] val = new float[N];
1036            for (int i=0; i<N; i++) {
1037                val[i] = readFloat();
1038            }
1039            return val;
1040        } else {
1041            return null;
1042        }
1043    }
1044
1045    public final void readFloatArray(float[] val) {
1046        int N = readInt();
1047        if (N == val.length) {
1048            for (int i=0; i<N; i++) {
1049                val[i] = readFloat();
1050            }
1051        } else {
1052            throw new RuntimeException("bad array lengths");
1053        }
1054    }
1055
1056    public final void writeDoubleArray(double[] val) {
1057        if (val != null) {
1058            int N = val.length;
1059            writeInt(N);
1060            for (int i=0; i<N; i++) {
1061                writeDouble(val[i]);
1062            }
1063        } else {
1064            writeInt(-1);
1065        }
1066    }
1067
1068    public final double[] createDoubleArray() {
1069        int N = readInt();
1070        // >>3 because stored doubles are 8 bytes
1071        if (N >= 0 && N <= (dataAvail() >> 3)) {
1072            double[] val = new double[N];
1073            for (int i=0; i<N; i++) {
1074                val[i] = readDouble();
1075            }
1076            return val;
1077        } else {
1078            return null;
1079        }
1080    }
1081
1082    public final void readDoubleArray(double[] val) {
1083        int N = readInt();
1084        if (N == val.length) {
1085            for (int i=0; i<N; i++) {
1086                val[i] = readDouble();
1087            }
1088        } else {
1089            throw new RuntimeException("bad array lengths");
1090        }
1091    }
1092
1093    public final void writeStringArray(String[] val) {
1094        if (val != null) {
1095            int N = val.length;
1096            writeInt(N);
1097            for (int i=0; i<N; i++) {
1098                writeString(val[i]);
1099            }
1100        } else {
1101            writeInt(-1);
1102        }
1103    }
1104
1105    public final String[] createStringArray() {
1106        int N = readInt();
1107        if (N >= 0) {
1108            String[] val = new String[N];
1109            for (int i=0; i<N; i++) {
1110                val[i] = readString();
1111            }
1112            return val;
1113        } else {
1114            return null;
1115        }
1116    }
1117
1118    public final void readStringArray(String[] val) {
1119        int N = readInt();
1120        if (N == val.length) {
1121            for (int i=0; i<N; i++) {
1122                val[i] = readString();
1123            }
1124        } else {
1125            throw new RuntimeException("bad array lengths");
1126        }
1127    }
1128
1129    public final void writeBinderArray(IBinder[] val) {
1130        if (val != null) {
1131            int N = val.length;
1132            writeInt(N);
1133            for (int i=0; i<N; i++) {
1134                writeStrongBinder(val[i]);
1135            }
1136        } else {
1137            writeInt(-1);
1138        }
1139    }
1140
1141    /**
1142     * @hide
1143     */
1144    public final void writeCharSequenceArray(CharSequence[] val) {
1145        if (val != null) {
1146            int N = val.length;
1147            writeInt(N);
1148            for (int i=0; i<N; i++) {
1149                writeCharSequence(val[i]);
1150            }
1151        } else {
1152            writeInt(-1);
1153        }
1154    }
1155
1156    /**
1157     * @hide
1158     */
1159    public final void writeCharSequenceList(ArrayList<CharSequence> val) {
1160        if (val != null) {
1161            int N = val.size();
1162            writeInt(N);
1163            for (int i=0; i<N; i++) {
1164                writeCharSequence(val.get(i));
1165            }
1166        } else {
1167            writeInt(-1);
1168        }
1169    }
1170
1171    public final IBinder[] createBinderArray() {
1172        int N = readInt();
1173        if (N >= 0) {
1174            IBinder[] val = new IBinder[N];
1175            for (int i=0; i<N; i++) {
1176                val[i] = readStrongBinder();
1177            }
1178            return val;
1179        } else {
1180            return null;
1181        }
1182    }
1183
1184    public final void readBinderArray(IBinder[] val) {
1185        int N = readInt();
1186        if (N == val.length) {
1187            for (int i=0; i<N; i++) {
1188                val[i] = readStrongBinder();
1189            }
1190        } else {
1191            throw new RuntimeException("bad array lengths");
1192        }
1193    }
1194
1195    /**
1196     * Flatten a List containing a particular object type into the parcel, at
1197     * the current dataPosition() and growing dataCapacity() if needed.  The
1198     * type of the objects in the list must be one that implements Parcelable.
1199     * Unlike the generic writeList() method, however, only the raw data of the
1200     * objects is written and not their type, so you must use the corresponding
1201     * readTypedList() to unmarshall them.
1202     *
1203     * @param val The list of objects to be written.
1204     *
1205     * @see #createTypedArrayList
1206     * @see #readTypedList
1207     * @see Parcelable
1208     */
1209    public final <T extends Parcelable> void writeTypedList(List<T> val) {
1210        if (val == null) {
1211            writeInt(-1);
1212            return;
1213        }
1214        int N = val.size();
1215        int i=0;
1216        writeInt(N);
1217        while (i < N) {
1218            T item = val.get(i);
1219            if (item != null) {
1220                writeInt(1);
1221                item.writeToParcel(this, 0);
1222            } else {
1223                writeInt(0);
1224            }
1225            i++;
1226        }
1227    }
1228
1229    /**
1230     * Flatten a List containing String objects into the parcel, at
1231     * the current dataPosition() and growing dataCapacity() if needed.  They
1232     * can later be retrieved with {@link #createStringArrayList} or
1233     * {@link #readStringList}.
1234     *
1235     * @param val The list of strings to be written.
1236     *
1237     * @see #createStringArrayList
1238     * @see #readStringList
1239     */
1240    public final void writeStringList(List<String> val) {
1241        if (val == null) {
1242            writeInt(-1);
1243            return;
1244        }
1245        int N = val.size();
1246        int i=0;
1247        writeInt(N);
1248        while (i < N) {
1249            writeString(val.get(i));
1250            i++;
1251        }
1252    }
1253
1254    /**
1255     * Flatten a List containing IBinder objects into the parcel, at
1256     * the current dataPosition() and growing dataCapacity() if needed.  They
1257     * can later be retrieved with {@link #createBinderArrayList} or
1258     * {@link #readBinderList}.
1259     *
1260     * @param val The list of strings to be written.
1261     *
1262     * @see #createBinderArrayList
1263     * @see #readBinderList
1264     */
1265    public final void writeBinderList(List<IBinder> val) {
1266        if (val == null) {
1267            writeInt(-1);
1268            return;
1269        }
1270        int N = val.size();
1271        int i=0;
1272        writeInt(N);
1273        while (i < N) {
1274            writeStrongBinder(val.get(i));
1275            i++;
1276        }
1277    }
1278
1279    /**
1280     * Flatten a heterogeneous array containing a particular object type into
1281     * the parcel, at
1282     * the current dataPosition() and growing dataCapacity() if needed.  The
1283     * type of the objects in the array must be one that implements Parcelable.
1284     * Unlike the {@link #writeParcelableArray} method, however, only the
1285     * raw data of the objects is written and not their type, so you must use
1286     * {@link #readTypedArray} with the correct corresponding
1287     * {@link Parcelable.Creator} implementation to unmarshall them.
1288     *
1289     * @param val The array of objects to be written.
1290     * @param parcelableFlags Contextual flags as per
1291     * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}.
1292     *
1293     * @see #readTypedArray
1294     * @see #writeParcelableArray
1295     * @see Parcelable.Creator
1296     */
1297    public final <T extends Parcelable> void writeTypedArray(T[] val,
1298            int parcelableFlags) {
1299        if (val != null) {
1300            int N = val.length;
1301            writeInt(N);
1302            for (int i=0; i<N; i++) {
1303                T item = val[i];
1304                if (item != null) {
1305                    writeInt(1);
1306                    item.writeToParcel(this, parcelableFlags);
1307                } else {
1308                    writeInt(0);
1309                }
1310            }
1311        } else {
1312            writeInt(-1);
1313        }
1314    }
1315
1316    /**
1317     * Flatten the Parcelable object into the parcel.
1318     *
1319     * @param val The Parcelable object to be written.
1320     * @param parcelableFlags Contextual flags as per
1321     * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}.
1322     *
1323     * @see #readTypedObject
1324     */
1325    public final <T extends Parcelable> void writeTypedObject(T val, int parcelableFlags) {
1326        if (val != null) {
1327            writeInt(1);
1328            val.writeToParcel(this, parcelableFlags);
1329        } else {
1330            writeInt(0);
1331        }
1332    }
1333
1334    /**
1335     * Flatten a generic object in to a parcel.  The given Object value may
1336     * currently be one of the following types:
1337     *
1338     * <ul>
1339     * <li> null
1340     * <li> String
1341     * <li> Byte
1342     * <li> Short
1343     * <li> Integer
1344     * <li> Long
1345     * <li> Float
1346     * <li> Double
1347     * <li> Boolean
1348     * <li> String[]
1349     * <li> boolean[]
1350     * <li> byte[]
1351     * <li> int[]
1352     * <li> long[]
1353     * <li> Object[] (supporting objects of the same type defined here).
1354     * <li> {@link Bundle}
1355     * <li> Map (as supported by {@link #writeMap}).
1356     * <li> Any object that implements the {@link Parcelable} protocol.
1357     * <li> Parcelable[]
1358     * <li> CharSequence (as supported by {@link TextUtils#writeToParcel}).
1359     * <li> List (as supported by {@link #writeList}).
1360     * <li> {@link SparseArray} (as supported by {@link #writeSparseArray(SparseArray)}).
1361     * <li> {@link IBinder}
1362     * <li> Any object that implements Serializable (but see
1363     *      {@link #writeSerializable} for caveats).  Note that all of the
1364     *      previous types have relatively efficient implementations for
1365     *      writing to a Parcel; having to rely on the generic serialization
1366     *      approach is much less efficient and should be avoided whenever
1367     *      possible.
1368     * </ul>
1369     *
1370     * <p class="caution">{@link Parcelable} objects are written with
1371     * {@link Parcelable#writeToParcel} using contextual flags of 0.  When
1372     * serializing objects containing {@link ParcelFileDescriptor}s,
1373     * this may result in file descriptor leaks when they are returned from
1374     * Binder calls (where {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE}
1375     * should be used).</p>
1376     */
1377    public final void writeValue(Object v) {
1378        if (v == null) {
1379            writeInt(VAL_NULL);
1380        } else if (v instanceof String) {
1381            writeInt(VAL_STRING);
1382            writeString((String) v);
1383        } else if (v instanceof Integer) {
1384            writeInt(VAL_INTEGER);
1385            writeInt((Integer) v);
1386        } else if (v instanceof Map) {
1387            writeInt(VAL_MAP);
1388            writeMap((Map) v);
1389        } else if (v instanceof Bundle) {
1390            // Must be before Parcelable
1391            writeInt(VAL_BUNDLE);
1392            writeBundle((Bundle) v);
1393        } else if (v instanceof PersistableBundle) {
1394            writeInt(VAL_PERSISTABLEBUNDLE);
1395            writePersistableBundle((PersistableBundle) v);
1396        } else if (v instanceof Parcelable) {
1397            // IMPOTANT: cases for classes that implement Parcelable must
1398            // come before the Parcelable case, so that their specific VAL_*
1399            // types will be written.
1400            writeInt(VAL_PARCELABLE);
1401            writeParcelable((Parcelable) v, 0);
1402        } else if (v instanceof Short) {
1403            writeInt(VAL_SHORT);
1404            writeInt(((Short) v).intValue());
1405        } else if (v instanceof Long) {
1406            writeInt(VAL_LONG);
1407            writeLong((Long) v);
1408        } else if (v instanceof Float) {
1409            writeInt(VAL_FLOAT);
1410            writeFloat((Float) v);
1411        } else if (v instanceof Double) {
1412            writeInt(VAL_DOUBLE);
1413            writeDouble((Double) v);
1414        } else if (v instanceof Boolean) {
1415            writeInt(VAL_BOOLEAN);
1416            writeInt((Boolean) v ? 1 : 0);
1417        } else if (v instanceof CharSequence) {
1418            // Must be after String
1419            writeInt(VAL_CHARSEQUENCE);
1420            writeCharSequence((CharSequence) v);
1421        } else if (v instanceof List) {
1422            writeInt(VAL_LIST);
1423            writeList((List) v);
1424        } else if (v instanceof SparseArray) {
1425            writeInt(VAL_SPARSEARRAY);
1426            writeSparseArray((SparseArray) v);
1427        } else if (v instanceof boolean[]) {
1428            writeInt(VAL_BOOLEANARRAY);
1429            writeBooleanArray((boolean[]) v);
1430        } else if (v instanceof byte[]) {
1431            writeInt(VAL_BYTEARRAY);
1432            writeByteArray((byte[]) v);
1433        } else if (v instanceof String[]) {
1434            writeInt(VAL_STRINGARRAY);
1435            writeStringArray((String[]) v);
1436        } else if (v instanceof CharSequence[]) {
1437            // Must be after String[] and before Object[]
1438            writeInt(VAL_CHARSEQUENCEARRAY);
1439            writeCharSequenceArray((CharSequence[]) v);
1440        } else if (v instanceof IBinder) {
1441            writeInt(VAL_IBINDER);
1442            writeStrongBinder((IBinder) v);
1443        } else if (v instanceof Parcelable[]) {
1444            writeInt(VAL_PARCELABLEARRAY);
1445            writeParcelableArray((Parcelable[]) v, 0);
1446        } else if (v instanceof int[]) {
1447            writeInt(VAL_INTARRAY);
1448            writeIntArray((int[]) v);
1449        } else if (v instanceof long[]) {
1450            writeInt(VAL_LONGARRAY);
1451            writeLongArray((long[]) v);
1452        } else if (v instanceof Byte) {
1453            writeInt(VAL_BYTE);
1454            writeInt((Byte) v);
1455        } else if (v instanceof Size) {
1456            writeInt(VAL_SIZE);
1457            writeSize((Size) v);
1458        } else if (v instanceof SizeF) {
1459            writeInt(VAL_SIZEF);
1460            writeSizeF((SizeF) v);
1461        } else if (v instanceof double[]) {
1462            writeInt(VAL_DOUBLEARRAY);
1463            writeDoubleArray((double[]) v);
1464        } else {
1465            Class<?> clazz = v.getClass();
1466            if (clazz.isArray() && clazz.getComponentType() == Object.class) {
1467                // Only pure Object[] are written here, Other arrays of non-primitive types are
1468                // handled by serialization as this does not record the component type.
1469                writeInt(VAL_OBJECTARRAY);
1470                writeArray((Object[]) v);
1471            } else if (v instanceof Serializable) {
1472                // Must be last
1473                writeInt(VAL_SERIALIZABLE);
1474                writeSerializable((Serializable) v);
1475            } else {
1476                throw new RuntimeException("Parcel: unable to marshal value " + v);
1477            }
1478        }
1479    }
1480
1481    /**
1482     * Flatten the name of the class of the Parcelable and its contents
1483     * into the parcel.
1484     *
1485     * @param p The Parcelable object to be written.
1486     * @param parcelableFlags Contextual flags as per
1487     * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}.
1488     */
1489    public final void writeParcelable(Parcelable p, int parcelableFlags) {
1490        if (p == null) {
1491            writeString(null);
1492            return;
1493        }
1494        writeParcelableCreator(p);
1495        p.writeToParcel(this, parcelableFlags);
1496    }
1497
1498    /** @hide */
1499    public final void writeParcelableCreator(Parcelable p) {
1500        String name = p.getClass().getName();
1501        writeString(name);
1502    }
1503
1504    /**
1505     * Write a generic serializable object in to a Parcel.  It is strongly
1506     * recommended that this method be avoided, since the serialization
1507     * overhead is extremely large, and this approach will be much slower than
1508     * using the other approaches to writing data in to a Parcel.
1509     */
1510    public final void writeSerializable(Serializable s) {
1511        if (s == null) {
1512            writeString(null);
1513            return;
1514        }
1515        String name = s.getClass().getName();
1516        writeString(name);
1517
1518        ByteArrayOutputStream baos = new ByteArrayOutputStream();
1519        try {
1520            ObjectOutputStream oos = new ObjectOutputStream(baos);
1521            oos.writeObject(s);
1522            oos.close();
1523
1524            writeByteArray(baos.toByteArray());
1525        } catch (IOException ioe) {
1526            throw new RuntimeException("Parcelable encountered " +
1527                "IOException writing serializable object (name = " + name +
1528                ")", ioe);
1529        }
1530    }
1531
1532    /**
1533     * Special function for writing an exception result at the header of
1534     * a parcel, to be used when returning an exception from a transaction.
1535     * Note that this currently only supports a few exception types; any other
1536     * exception will be re-thrown by this function as a RuntimeException
1537     * (to be caught by the system's last-resort exception handling when
1538     * dispatching a transaction).
1539     *
1540     * <p>The supported exception types are:
1541     * <ul>
1542     * <li>{@link BadParcelableException}
1543     * <li>{@link IllegalArgumentException}
1544     * <li>{@link IllegalStateException}
1545     * <li>{@link NullPointerException}
1546     * <li>{@link SecurityException}
1547     * <li>{@link NetworkOnMainThreadException}
1548     * </ul>
1549     *
1550     * @param e The Exception to be written.
1551     *
1552     * @see #writeNoException
1553     * @see #readException
1554     */
1555    public final void writeException(Exception e) {
1556        int code = 0;
1557        if (e instanceof SecurityException) {
1558            code = EX_SECURITY;
1559        } else if (e instanceof BadParcelableException) {
1560            code = EX_BAD_PARCELABLE;
1561        } else if (e instanceof IllegalArgumentException) {
1562            code = EX_ILLEGAL_ARGUMENT;
1563        } else if (e instanceof NullPointerException) {
1564            code = EX_NULL_POINTER;
1565        } else if (e instanceof IllegalStateException) {
1566            code = EX_ILLEGAL_STATE;
1567        } else if (e instanceof NetworkOnMainThreadException) {
1568            code = EX_NETWORK_MAIN_THREAD;
1569        } else if (e instanceof UnsupportedOperationException) {
1570            code = EX_UNSUPPORTED_OPERATION;
1571        } else if (e instanceof ServiceSpecificException) {
1572            code = EX_SERVICE_SPECIFIC;
1573        }
1574        writeInt(code);
1575        StrictMode.clearGatheredViolations();
1576        if (code == 0) {
1577            if (e instanceof RuntimeException) {
1578                throw (RuntimeException) e;
1579            }
1580            throw new RuntimeException(e);
1581        }
1582        writeString(e.getMessage());
1583        if (e instanceof ServiceSpecificException) {
1584            writeInt(((ServiceSpecificException)e).errorCode);
1585        }
1586    }
1587
1588    /**
1589     * Special function for writing information at the front of the Parcel
1590     * indicating that no exception occurred.
1591     *
1592     * @see #writeException
1593     * @see #readException
1594     */
1595    public final void writeNoException() {
1596        // Despite the name of this function ("write no exception"),
1597        // it should instead be thought of as "write the RPC response
1598        // header", but because this function name is written out by
1599        // the AIDL compiler, we're not going to rename it.
1600        //
1601        // The response header, in the non-exception case (see also
1602        // writeException above, also called by the AIDL compiler), is
1603        // either a 0 (the default case), or EX_HAS_REPLY_HEADER if
1604        // StrictMode has gathered up violations that have occurred
1605        // during a Binder call, in which case we write out the number
1606        // of violations and their details, serialized, before the
1607        // actual RPC respons data.  The receiving end of this is
1608        // readException(), below.
1609        if (StrictMode.hasGatheredViolations()) {
1610            writeInt(EX_HAS_REPLY_HEADER);
1611            final int sizePosition = dataPosition();
1612            writeInt(0);  // total size of fat header, to be filled in later
1613            StrictMode.writeGatheredViolationsToParcel(this);
1614            final int payloadPosition = dataPosition();
1615            setDataPosition(sizePosition);
1616            writeInt(payloadPosition - sizePosition);  // header size
1617            setDataPosition(payloadPosition);
1618        } else {
1619            writeInt(0);
1620        }
1621    }
1622
1623    /**
1624     * Special function for reading an exception result from the header of
1625     * a parcel, to be used after receiving the result of a transaction.  This
1626     * will throw the exception for you if it had been written to the Parcel,
1627     * otherwise return and let you read the normal result data from the Parcel.
1628     *
1629     * @see #writeException
1630     * @see #writeNoException
1631     */
1632    public final void readException() {
1633        int code = readExceptionCode();
1634        if (code != 0) {
1635            String msg = readString();
1636            readException(code, msg);
1637        }
1638    }
1639
1640    /**
1641     * Parses the header of a Binder call's response Parcel and
1642     * returns the exception code.  Deals with lite or fat headers.
1643     * In the common successful case, this header is generally zero.
1644     * In less common cases, it's a small negative number and will be
1645     * followed by an error string.
1646     *
1647     * This exists purely for android.database.DatabaseUtils and
1648     * insulating it from having to handle fat headers as returned by
1649     * e.g. StrictMode-induced RPC responses.
1650     *
1651     * @hide
1652     */
1653    public final int readExceptionCode() {
1654        int code = readInt();
1655        if (code == EX_HAS_REPLY_HEADER) {
1656            int headerSize = readInt();
1657            if (headerSize == 0) {
1658                Log.e(TAG, "Unexpected zero-sized Parcel reply header.");
1659            } else {
1660                // Currently the only thing in the header is StrictMode stacks,
1661                // but discussions around event/RPC tracing suggest we might
1662                // put that here too.  If so, switch on sub-header tags here.
1663                // But for now, just parse out the StrictMode stuff.
1664                StrictMode.readAndHandleBinderCallViolations(this);
1665            }
1666            // And fat response headers are currently only used when
1667            // there are no exceptions, so return no error:
1668            return 0;
1669        }
1670        return code;
1671    }
1672
1673    /**
1674     * Throw an exception with the given message. Not intended for use
1675     * outside the Parcel class.
1676     *
1677     * @param code Used to determine which exception class to throw.
1678     * @param msg The exception message.
1679     */
1680    public final void readException(int code, String msg) {
1681        switch (code) {
1682            case EX_SECURITY:
1683                throw new SecurityException(msg);
1684            case EX_BAD_PARCELABLE:
1685                throw new BadParcelableException(msg);
1686            case EX_ILLEGAL_ARGUMENT:
1687                throw new IllegalArgumentException(msg);
1688            case EX_NULL_POINTER:
1689                throw new NullPointerException(msg);
1690            case EX_ILLEGAL_STATE:
1691                throw new IllegalStateException(msg);
1692            case EX_NETWORK_MAIN_THREAD:
1693                throw new NetworkOnMainThreadException();
1694            case EX_UNSUPPORTED_OPERATION:
1695                throw new UnsupportedOperationException(msg);
1696            case EX_SERVICE_SPECIFIC:
1697                throw new ServiceSpecificException(readInt(), msg);
1698        }
1699        throw new RuntimeException("Unknown exception code: " + code
1700                + " msg " + msg);
1701    }
1702
1703    /**
1704     * Read an integer value from the parcel at the current dataPosition().
1705     */
1706    public final int readInt() {
1707        return nativeReadInt(mNativePtr);
1708    }
1709
1710    /**
1711     * Read a long integer value from the parcel at the current dataPosition().
1712     */
1713    public final long readLong() {
1714        return nativeReadLong(mNativePtr);
1715    }
1716
1717    /**
1718     * Read a floating point value from the parcel at the current
1719     * dataPosition().
1720     */
1721    public final float readFloat() {
1722        return nativeReadFloat(mNativePtr);
1723    }
1724
1725    /**
1726     * Read a double precision floating point value from the parcel at the
1727     * current dataPosition().
1728     */
1729    public final double readDouble() {
1730        return nativeReadDouble(mNativePtr);
1731    }
1732
1733    /**
1734     * Read a string value from the parcel at the current dataPosition().
1735     */
1736    public final String readString() {
1737        return nativeReadString(mNativePtr);
1738    }
1739
1740    /**
1741     * Read a CharSequence value from the parcel at the current dataPosition().
1742     * @hide
1743     */
1744    public final CharSequence readCharSequence() {
1745        return TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(this);
1746    }
1747
1748    /**
1749     * Read an object from the parcel at the current dataPosition().
1750     */
1751    public final IBinder readStrongBinder() {
1752        return nativeReadStrongBinder(mNativePtr);
1753    }
1754
1755    /**
1756     * Read a FileDescriptor from the parcel at the current dataPosition().
1757     */
1758    public final ParcelFileDescriptor readFileDescriptor() {
1759        FileDescriptor fd = nativeReadFileDescriptor(mNativePtr);
1760        return fd != null ? new ParcelFileDescriptor(fd) : null;
1761    }
1762
1763    /** {@hide} */
1764    public final FileDescriptor readRawFileDescriptor() {
1765        return nativeReadFileDescriptor(mNativePtr);
1766    }
1767
1768    /**
1769     * {@hide}
1770     * Read and return a new array of FileDescriptors from the parcel.
1771     * @return the FileDescriptor array, or null if the array is null.
1772     **/
1773    public final FileDescriptor[] createRawFileDescriptorArray() {
1774        int N = readInt();
1775        if (N < 0) {
1776            return null;
1777        }
1778        FileDescriptor[] f = new FileDescriptor[N];
1779        for (int i = 0; i < N; i++) {
1780            f[i] = readRawFileDescriptor();
1781        }
1782        return f;
1783    }
1784
1785    /**
1786     * {@hide}
1787     * Read an array of FileDescriptors from a parcel.
1788     * The passed array must be exactly the length of the array in the parcel.
1789     * @return the FileDescriptor array, or null if the array is null.
1790     **/
1791    public final void readRawFileDescriptorArray(FileDescriptor[] val) {
1792        int N = readInt();
1793        if (N == val.length) {
1794            for (int i=0; i<N; i++) {
1795                val[i] = readRawFileDescriptor();
1796            }
1797        } else {
1798            throw new RuntimeException("bad array lengths");
1799        }
1800    }
1801
1802
1803    /*package*/ static native FileDescriptor openFileDescriptor(String file,
1804            int mode) throws FileNotFoundException;
1805    /*package*/ static native FileDescriptor dupFileDescriptor(FileDescriptor orig)
1806            throws IOException;
1807    /*package*/ static native void closeFileDescriptor(FileDescriptor desc)
1808            throws IOException;
1809    /*package*/ static native void clearFileDescriptor(FileDescriptor desc);
1810
1811    /**
1812     * Read a byte value from the parcel at the current dataPosition().
1813     */
1814    public final byte readByte() {
1815        return (byte)(readInt() & 0xff);
1816    }
1817
1818    /**
1819     * Please use {@link #readBundle(ClassLoader)} instead (whose data must have
1820     * been written with {@link #writeBundle}.  Read into an existing Map object
1821     * from the parcel at the current dataPosition().
1822     */
1823    public final void readMap(Map outVal, ClassLoader loader) {
1824        int N = readInt();
1825        readMapInternal(outVal, N, loader);
1826    }
1827
1828    /**
1829     * Read into an existing List object from the parcel at the current
1830     * dataPosition(), using the given class loader to load any enclosed
1831     * Parcelables.  If it is null, the default class loader is used.
1832     */
1833    public final void readList(List outVal, ClassLoader loader) {
1834        int N = readInt();
1835        readListInternal(outVal, N, loader);
1836    }
1837
1838    /**
1839     * Please use {@link #readBundle(ClassLoader)} instead (whose data must have
1840     * been written with {@link #writeBundle}.  Read and return a new HashMap
1841     * object from the parcel at the current dataPosition(), using the given
1842     * class loader to load any enclosed Parcelables.  Returns null if
1843     * the previously written map object was null.
1844     */
1845    public final HashMap readHashMap(ClassLoader loader)
1846    {
1847        int N = readInt();
1848        if (N < 0) {
1849            return null;
1850        }
1851        HashMap m = new HashMap(N);
1852        readMapInternal(m, N, loader);
1853        return m;
1854    }
1855
1856    /**
1857     * Read and return a new Bundle object from the parcel at the current
1858     * dataPosition().  Returns null if the previously written Bundle object was
1859     * null.
1860     */
1861    public final Bundle readBundle() {
1862        return readBundle(null);
1863    }
1864
1865    /**
1866     * Read and return a new Bundle object from the parcel at the current
1867     * dataPosition(), using the given class loader to initialize the class
1868     * loader of the Bundle for later retrieval of Parcelable objects.
1869     * Returns null if the previously written Bundle object was null.
1870     */
1871    public final Bundle readBundle(ClassLoader loader) {
1872        int length = readInt();
1873        if (length < 0) {
1874            if (Bundle.DEBUG) Log.d(TAG, "null bundle: length=" + length);
1875            return null;
1876        }
1877
1878        final Bundle bundle = new Bundle(this, length);
1879        if (loader != null) {
1880            bundle.setClassLoader(loader);
1881        }
1882        return bundle;
1883    }
1884
1885    /**
1886     * Read and return a new Bundle object from the parcel at the current
1887     * dataPosition().  Returns null if the previously written Bundle object was
1888     * null.
1889     */
1890    public final PersistableBundle readPersistableBundle() {
1891        return readPersistableBundle(null);
1892    }
1893
1894    /**
1895     * Read and return a new Bundle object from the parcel at the current
1896     * dataPosition(), using the given class loader to initialize the class
1897     * loader of the Bundle for later retrieval of Parcelable objects.
1898     * Returns null if the previously written Bundle object was null.
1899     */
1900    public final PersistableBundle readPersistableBundle(ClassLoader loader) {
1901        int length = readInt();
1902        if (length < 0) {
1903            if (Bundle.DEBUG) Log.d(TAG, "null bundle: length=" + length);
1904            return null;
1905        }
1906
1907        final PersistableBundle bundle = new PersistableBundle(this, length);
1908        if (loader != null) {
1909            bundle.setClassLoader(loader);
1910        }
1911        return bundle;
1912    }
1913
1914    /**
1915     * Read a Size from the parcel at the current dataPosition().
1916     */
1917    public final Size readSize() {
1918        final int width = readInt();
1919        final int height = readInt();
1920        return new Size(width, height);
1921    }
1922
1923    /**
1924     * Read a SizeF from the parcel at the current dataPosition().
1925     */
1926    public final SizeF readSizeF() {
1927        final float width = readFloat();
1928        final float height = readFloat();
1929        return new SizeF(width, height);
1930    }
1931
1932    /**
1933     * Read and return a byte[] object from the parcel.
1934     */
1935    public final byte[] createByteArray() {
1936        return nativeCreateByteArray(mNativePtr);
1937    }
1938
1939    /**
1940     * Read a byte[] object from the parcel and copy it into the
1941     * given byte array.
1942     */
1943    public final void readByteArray(byte[] val) {
1944        // TODO: make this a native method to avoid the extra copy.
1945        byte[] ba = createByteArray();
1946        if (ba.length == val.length) {
1947           System.arraycopy(ba, 0, val, 0, ba.length);
1948        } else {
1949            throw new RuntimeException("bad array lengths");
1950        }
1951    }
1952
1953    /**
1954     * Read a blob of data from the parcel and return it as a byte array.
1955     * {@hide}
1956     * {@SystemApi}
1957     */
1958    public final byte[] readBlob() {
1959        return nativeReadBlob(mNativePtr);
1960    }
1961
1962    /**
1963     * Read and return a String[] object from the parcel.
1964     * {@hide}
1965     */
1966    public final String[] readStringArray() {
1967        String[] array = null;
1968
1969        int length = readInt();
1970        if (length >= 0)
1971        {
1972            array = new String[length];
1973
1974            for (int i = 0 ; i < length ; i++)
1975            {
1976                array[i] = readString();
1977            }
1978        }
1979
1980        return array;
1981    }
1982
1983    /**
1984     * Read and return a CharSequence[] object from the parcel.
1985     * {@hide}
1986     */
1987    public final CharSequence[] readCharSequenceArray() {
1988        CharSequence[] array = null;
1989
1990        int length = readInt();
1991        if (length >= 0)
1992        {
1993            array = new CharSequence[length];
1994
1995            for (int i = 0 ; i < length ; i++)
1996            {
1997                array[i] = readCharSequence();
1998            }
1999        }
2000
2001        return array;
2002    }
2003
2004    /**
2005     * Read and return an ArrayList&lt;CharSequence&gt; object from the parcel.
2006     * {@hide}
2007     */
2008    public final ArrayList<CharSequence> readCharSequenceList() {
2009        ArrayList<CharSequence> array = null;
2010
2011        int length = readInt();
2012        if (length >= 0) {
2013            array = new ArrayList<CharSequence>(length);
2014
2015            for (int i = 0 ; i < length ; i++) {
2016                array.add(readCharSequence());
2017            }
2018        }
2019
2020        return array;
2021    }
2022
2023    /**
2024     * Read and return a new ArrayList object from the parcel at the current
2025     * dataPosition().  Returns null if the previously written list object was
2026     * null.  The given class loader will be used to load any enclosed
2027     * Parcelables.
2028     */
2029    public final ArrayList readArrayList(ClassLoader loader) {
2030        int N = readInt();
2031        if (N < 0) {
2032            return null;
2033        }
2034        ArrayList l = new ArrayList(N);
2035        readListInternal(l, N, loader);
2036        return l;
2037    }
2038
2039    /**
2040     * Read and return a new Object array from the parcel at the current
2041     * dataPosition().  Returns null if the previously written array was
2042     * null.  The given class loader will be used to load any enclosed
2043     * Parcelables.
2044     */
2045    public final Object[] readArray(ClassLoader loader) {
2046        int N = readInt();
2047        if (N < 0) {
2048            return null;
2049        }
2050        Object[] l = new Object[N];
2051        readArrayInternal(l, N, loader);
2052        return l;
2053    }
2054
2055    /**
2056     * Read and return a new SparseArray object from the parcel at the current
2057     * dataPosition().  Returns null if the previously written list object was
2058     * null.  The given class loader will be used to load any enclosed
2059     * Parcelables.
2060     */
2061    public final SparseArray readSparseArray(ClassLoader loader) {
2062        int N = readInt();
2063        if (N < 0) {
2064            return null;
2065        }
2066        SparseArray sa = new SparseArray(N);
2067        readSparseArrayInternal(sa, N, loader);
2068        return sa;
2069    }
2070
2071    /**
2072     * Read and return a new SparseBooleanArray object from the parcel at the current
2073     * dataPosition().  Returns null if the previously written list object was
2074     * null.
2075     */
2076    public final SparseBooleanArray readSparseBooleanArray() {
2077        int N = readInt();
2078        if (N < 0) {
2079            return null;
2080        }
2081        SparseBooleanArray sa = new SparseBooleanArray(N);
2082        readSparseBooleanArrayInternal(sa, N);
2083        return sa;
2084    }
2085
2086    /**
2087     * Read and return a new ArrayList containing a particular object type from
2088     * the parcel that was written with {@link #writeTypedList} at the
2089     * current dataPosition().  Returns null if the
2090     * previously written list object was null.  The list <em>must</em> have
2091     * previously been written via {@link #writeTypedList} with the same object
2092     * type.
2093     *
2094     * @return A newly created ArrayList containing objects with the same data
2095     *         as those that were previously written.
2096     *
2097     * @see #writeTypedList
2098     */
2099    public final <T> ArrayList<T> createTypedArrayList(Parcelable.Creator<T> c) {
2100        int N = readInt();
2101        if (N < 0) {
2102            return null;
2103        }
2104        ArrayList<T> l = new ArrayList<T>(N);
2105        while (N > 0) {
2106            if (readInt() != 0) {
2107                l.add(c.createFromParcel(this));
2108            } else {
2109                l.add(null);
2110            }
2111            N--;
2112        }
2113        return l;
2114    }
2115
2116    /**
2117     * Read into the given List items containing a particular object type
2118     * that were written with {@link #writeTypedList} at the
2119     * current dataPosition().  The list <em>must</em> have
2120     * previously been written via {@link #writeTypedList} with the same object
2121     * type.
2122     *
2123     * @return A newly created ArrayList containing objects with the same data
2124     *         as those that were previously written.
2125     *
2126     * @see #writeTypedList
2127     */
2128    public final <T> void readTypedList(List<T> list, Parcelable.Creator<T> c) {
2129        int M = list.size();
2130        int N = readInt();
2131        int i = 0;
2132        for (; i < M && i < N; i++) {
2133            if (readInt() != 0) {
2134                list.set(i, c.createFromParcel(this));
2135            } else {
2136                list.set(i, null);
2137            }
2138        }
2139        for (; i<N; i++) {
2140            if (readInt() != 0) {
2141                list.add(c.createFromParcel(this));
2142            } else {
2143                list.add(null);
2144            }
2145        }
2146        for (; i<M; i++) {
2147            list.remove(N);
2148        }
2149    }
2150
2151    /**
2152     * Read and return a new ArrayList containing String objects from
2153     * the parcel that was written with {@link #writeStringList} at the
2154     * current dataPosition().  Returns null if the
2155     * previously written list object was null.
2156     *
2157     * @return A newly created ArrayList containing strings with the same data
2158     *         as those that were previously written.
2159     *
2160     * @see #writeStringList
2161     */
2162    public final ArrayList<String> createStringArrayList() {
2163        int N = readInt();
2164        if (N < 0) {
2165            return null;
2166        }
2167        ArrayList<String> l = new ArrayList<String>(N);
2168        while (N > 0) {
2169            l.add(readString());
2170            N--;
2171        }
2172        return l;
2173    }
2174
2175    /**
2176     * Read and return a new ArrayList containing IBinder objects from
2177     * the parcel that was written with {@link #writeBinderList} at the
2178     * current dataPosition().  Returns null if the
2179     * previously written list object was null.
2180     *
2181     * @return A newly created ArrayList containing strings with the same data
2182     *         as those that were previously written.
2183     *
2184     * @see #writeBinderList
2185     */
2186    public final ArrayList<IBinder> createBinderArrayList() {
2187        int N = readInt();
2188        if (N < 0) {
2189            return null;
2190        }
2191        ArrayList<IBinder> l = new ArrayList<IBinder>(N);
2192        while (N > 0) {
2193            l.add(readStrongBinder());
2194            N--;
2195        }
2196        return l;
2197    }
2198
2199    /**
2200     * Read into the given List items String objects that were written with
2201     * {@link #writeStringList} at the current dataPosition().
2202     *
2203     * @return A newly created ArrayList containing strings with the same data
2204     *         as those that were previously written.
2205     *
2206     * @see #writeStringList
2207     */
2208    public final void readStringList(List<String> list) {
2209        int M = list.size();
2210        int N = readInt();
2211        int i = 0;
2212        for (; i < M && i < N; i++) {
2213            list.set(i, readString());
2214        }
2215        for (; i<N; i++) {
2216            list.add(readString());
2217        }
2218        for (; i<M; i++) {
2219            list.remove(N);
2220        }
2221    }
2222
2223    /**
2224     * Read into the given List items IBinder objects that were written with
2225     * {@link #writeBinderList} at the current dataPosition().
2226     *
2227     * @return A newly created ArrayList containing strings with the same data
2228     *         as those that were previously written.
2229     *
2230     * @see #writeBinderList
2231     */
2232    public final void readBinderList(List<IBinder> list) {
2233        int M = list.size();
2234        int N = readInt();
2235        int i = 0;
2236        for (; i < M && i < N; i++) {
2237            list.set(i, readStrongBinder());
2238        }
2239        for (; i<N; i++) {
2240            list.add(readStrongBinder());
2241        }
2242        for (; i<M; i++) {
2243            list.remove(N);
2244        }
2245    }
2246
2247    /**
2248     * Read and return a new array containing a particular object type from
2249     * the parcel at the current dataPosition().  Returns null if the
2250     * previously written array was null.  The array <em>must</em> have
2251     * previously been written via {@link #writeTypedArray} with the same
2252     * object type.
2253     *
2254     * @return A newly created array containing objects with the same data
2255     *         as those that were previously written.
2256     *
2257     * @see #writeTypedArray
2258     */
2259    public final <T> T[] createTypedArray(Parcelable.Creator<T> c) {
2260        int N = readInt();
2261        if (N < 0) {
2262            return null;
2263        }
2264        T[] l = c.newArray(N);
2265        for (int i=0; i<N; i++) {
2266            if (readInt() != 0) {
2267                l[i] = c.createFromParcel(this);
2268            }
2269        }
2270        return l;
2271    }
2272
2273    public final <T> void readTypedArray(T[] val, Parcelable.Creator<T> c) {
2274        int N = readInt();
2275        if (N == val.length) {
2276            for (int i=0; i<N; i++) {
2277                if (readInt() != 0) {
2278                    val[i] = c.createFromParcel(this);
2279                } else {
2280                    val[i] = null;
2281                }
2282            }
2283        } else {
2284            throw new RuntimeException("bad array lengths");
2285        }
2286    }
2287
2288    /**
2289     * @deprecated
2290     * @hide
2291     */
2292    @Deprecated
2293    public final <T> T[] readTypedArray(Parcelable.Creator<T> c) {
2294        return createTypedArray(c);
2295    }
2296
2297    /**
2298     * Read and return a typed Parcelable object from a parcel.
2299     * Returns null if the previous written object was null.
2300     * The object <em>must</em> have previous been written via
2301     * {@link #writeTypedObject} with the same object type.
2302     *
2303     * @return A newly created object of the type that was previously
2304     *         written.
2305     *
2306     * @see #writeTypedObject
2307     */
2308    public final <T> T readTypedObject(Parcelable.Creator<T> c) {
2309        if (readInt() != 0) {
2310            return c.createFromParcel(this);
2311        } else {
2312            return null;
2313        }
2314    }
2315
2316    /**
2317     * Write a heterogeneous array of Parcelable objects into the Parcel.
2318     * Each object in the array is written along with its class name, so
2319     * that the correct class can later be instantiated.  As a result, this
2320     * has significantly more overhead than {@link #writeTypedArray}, but will
2321     * correctly handle an array containing more than one type of object.
2322     *
2323     * @param value The array of objects to be written.
2324     * @param parcelableFlags Contextual flags as per
2325     * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}.
2326     *
2327     * @see #writeTypedArray
2328     */
2329    public final <T extends Parcelable> void writeParcelableArray(T[] value,
2330            int parcelableFlags) {
2331        if (value != null) {
2332            int N = value.length;
2333            writeInt(N);
2334            for (int i=0; i<N; i++) {
2335                writeParcelable(value[i], parcelableFlags);
2336            }
2337        } else {
2338            writeInt(-1);
2339        }
2340    }
2341
2342    /**
2343     * Read a typed object from a parcel.  The given class loader will be
2344     * used to load any enclosed Parcelables.  If it is null, the default class
2345     * loader will be used.
2346     */
2347    public final Object readValue(ClassLoader loader) {
2348        int type = readInt();
2349
2350        switch (type) {
2351        case VAL_NULL:
2352            return null;
2353
2354        case VAL_STRING:
2355            return readString();
2356
2357        case VAL_INTEGER:
2358            return readInt();
2359
2360        case VAL_MAP:
2361            return readHashMap(loader);
2362
2363        case VAL_PARCELABLE:
2364            return readParcelable(loader);
2365
2366        case VAL_SHORT:
2367            return (short) readInt();
2368
2369        case VAL_LONG:
2370            return readLong();
2371
2372        case VAL_FLOAT:
2373            return readFloat();
2374
2375        case VAL_DOUBLE:
2376            return readDouble();
2377
2378        case VAL_BOOLEAN:
2379            return readInt() == 1;
2380
2381        case VAL_CHARSEQUENCE:
2382            return readCharSequence();
2383
2384        case VAL_LIST:
2385            return readArrayList(loader);
2386
2387        case VAL_BOOLEANARRAY:
2388            return createBooleanArray();
2389
2390        case VAL_BYTEARRAY:
2391            return createByteArray();
2392
2393        case VAL_STRINGARRAY:
2394            return readStringArray();
2395
2396        case VAL_CHARSEQUENCEARRAY:
2397            return readCharSequenceArray();
2398
2399        case VAL_IBINDER:
2400            return readStrongBinder();
2401
2402        case VAL_OBJECTARRAY:
2403            return readArray(loader);
2404
2405        case VAL_INTARRAY:
2406            return createIntArray();
2407
2408        case VAL_LONGARRAY:
2409            return createLongArray();
2410
2411        case VAL_BYTE:
2412            return readByte();
2413
2414        case VAL_SERIALIZABLE:
2415            return readSerializable(loader);
2416
2417        case VAL_PARCELABLEARRAY:
2418            return readParcelableArray(loader);
2419
2420        case VAL_SPARSEARRAY:
2421            return readSparseArray(loader);
2422
2423        case VAL_SPARSEBOOLEANARRAY:
2424            return readSparseBooleanArray();
2425
2426        case VAL_BUNDLE:
2427            return readBundle(loader); // loading will be deferred
2428
2429        case VAL_PERSISTABLEBUNDLE:
2430            return readPersistableBundle(loader);
2431
2432        case VAL_SIZE:
2433            return readSize();
2434
2435        case VAL_SIZEF:
2436            return readSizeF();
2437
2438        case VAL_DOUBLEARRAY:
2439            return createDoubleArray();
2440
2441        default:
2442            int off = dataPosition() - 4;
2443            throw new RuntimeException(
2444                "Parcel " + this + ": Unmarshalling unknown type code " + type + " at offset " + off);
2445        }
2446    }
2447
2448    /**
2449     * Read and return a new Parcelable from the parcel.  The given class loader
2450     * will be used to load any enclosed Parcelables.  If it is null, the default
2451     * class loader will be used.
2452     * @param loader A ClassLoader from which to instantiate the Parcelable
2453     * object, or null for the default class loader.
2454     * @return Returns the newly created Parcelable, or null if a null
2455     * object has been written.
2456     * @throws BadParcelableException Throws BadParcelableException if there
2457     * was an error trying to instantiate the Parcelable.
2458     */
2459    @SuppressWarnings("unchecked")
2460    public final <T extends Parcelable> T readParcelable(ClassLoader loader) {
2461        Parcelable.Creator<?> creator = readParcelableCreator(loader);
2462        if (creator == null) {
2463            return null;
2464        }
2465        if (creator instanceof Parcelable.ClassLoaderCreator<?>) {
2466          Parcelable.ClassLoaderCreator<?> classLoaderCreator =
2467              (Parcelable.ClassLoaderCreator<?>) creator;
2468          return (T) classLoaderCreator.createFromParcel(this, loader);
2469        }
2470        return (T) creator.createFromParcel(this);
2471    }
2472
2473    /** @hide */
2474    @SuppressWarnings("unchecked")
2475    public final <T extends Parcelable> T readCreator(Parcelable.Creator<?> creator,
2476            ClassLoader loader) {
2477        if (creator instanceof Parcelable.ClassLoaderCreator<?>) {
2478          Parcelable.ClassLoaderCreator<?> classLoaderCreator =
2479              (Parcelable.ClassLoaderCreator<?>) creator;
2480          return (T) classLoaderCreator.createFromParcel(this, loader);
2481        }
2482        return (T) creator.createFromParcel(this);
2483    }
2484
2485    /** @hide */
2486    public final Parcelable.Creator<?> readParcelableCreator(ClassLoader loader) {
2487        String name = readString();
2488        if (name == null) {
2489            return null;
2490        }
2491        Parcelable.Creator<?> creator;
2492        synchronized (mCreators) {
2493            HashMap<String,Parcelable.Creator<?>> map = mCreators.get(loader);
2494            if (map == null) {
2495                map = new HashMap<>();
2496                mCreators.put(loader, map);
2497            }
2498            creator = map.get(name);
2499            if (creator == null) {
2500                try {
2501                    // If loader == null, explicitly emulate Class.forName(String) "caller
2502                    // classloader" behavior.
2503                    ClassLoader parcelableClassLoader =
2504                            (loader == null ? getClass().getClassLoader() : loader);
2505                    // Avoid initializing the Parcelable class until we know it implements
2506                    // Parcelable and has the necessary CREATOR field. http://b/1171613.
2507                    Class<?> parcelableClass = Class.forName(name, false /* initialize */,
2508                            parcelableClassLoader);
2509                    if (!Parcelable.class.isAssignableFrom(parcelableClass)) {
2510                        throw new BadParcelableException("Parcelable protocol requires that the "
2511                                + "class implements Parcelable");
2512                    }
2513                    Field f = parcelableClass.getField("CREATOR");
2514                    if ((f.getModifiers() & Modifier.STATIC) == 0) {
2515                        throw new BadParcelableException("Parcelable protocol requires "
2516                                + "the CREATOR object to be static on class " + name);
2517                    }
2518                    Class<?> creatorType = f.getType();
2519                    if (!Parcelable.Creator.class.isAssignableFrom(creatorType)) {
2520                        // Fail before calling Field.get(), not after, to avoid initializing
2521                        // parcelableClass unnecessarily.
2522                        throw new BadParcelableException("Parcelable protocol requires a "
2523                                + "Parcelable.Creator object called "
2524                                + "CREATOR on class " + name);
2525                    }
2526                    creator = (Parcelable.Creator<?>) f.get(null);
2527                }
2528                catch (IllegalAccessException e) {
2529                    Log.e(TAG, "Illegal access when unmarshalling: " + name, e);
2530                    throw new BadParcelableException(
2531                            "IllegalAccessException when unmarshalling: " + name);
2532                }
2533                catch (ClassNotFoundException e) {
2534                    Log.e(TAG, "Class not found when unmarshalling: " + name, e);
2535                    throw new BadParcelableException(
2536                            "ClassNotFoundException when unmarshalling: " + name);
2537                }
2538                catch (NoSuchFieldException e) {
2539                    throw new BadParcelableException("Parcelable protocol requires a "
2540                            + "Parcelable.Creator object called "
2541                            + "CREATOR on class " + name);
2542                }
2543                if (creator == null) {
2544                    throw new BadParcelableException("Parcelable protocol requires a "
2545                            + "non-null Parcelable.Creator object called "
2546                            + "CREATOR on class " + name);
2547                }
2548
2549                map.put(name, creator);
2550            }
2551        }
2552
2553        return creator;
2554    }
2555
2556    /**
2557     * Read and return a new Parcelable array from the parcel.
2558     * The given class loader will be used to load any enclosed
2559     * Parcelables.
2560     * @return the Parcelable array, or null if the array is null
2561     */
2562    public final Parcelable[] readParcelableArray(ClassLoader loader) {
2563        int N = readInt();
2564        if (N < 0) {
2565            return null;
2566        }
2567        Parcelable[] p = new Parcelable[N];
2568        for (int i = 0; i < N; i++) {
2569            p[i] = readParcelable(loader);
2570        }
2571        return p;
2572    }
2573
2574    /**
2575     * Read and return a new Serializable object from the parcel.
2576     * @return the Serializable object, or null if the Serializable name
2577     * wasn't found in the parcel.
2578     */
2579    public final Serializable readSerializable() {
2580        return readSerializable(null);
2581    }
2582
2583    private final Serializable readSerializable(final ClassLoader loader) {
2584        String name = readString();
2585        if (name == null) {
2586            // For some reason we were unable to read the name of the Serializable (either there
2587            // is nothing left in the Parcel to read, or the next value wasn't a String), so
2588            // return null, which indicates that the name wasn't found in the parcel.
2589            return null;
2590        }
2591
2592        byte[] serializedData = createByteArray();
2593        ByteArrayInputStream bais = new ByteArrayInputStream(serializedData);
2594        try {
2595            ObjectInputStream ois = new ObjectInputStream(bais) {
2596                @Override
2597                protected Class<?> resolveClass(ObjectStreamClass osClass)
2598                        throws IOException, ClassNotFoundException {
2599                    // try the custom classloader if provided
2600                    if (loader != null) {
2601                        Class<?> c = Class.forName(osClass.getName(), false, loader);
2602                        if (c != null) {
2603                            return c;
2604                        }
2605                    }
2606                    return super.resolveClass(osClass);
2607                }
2608            };
2609            return (Serializable) ois.readObject();
2610        } catch (IOException ioe) {
2611            throw new RuntimeException("Parcelable encountered " +
2612                "IOException reading a Serializable object (name = " + name +
2613                ")", ioe);
2614        } catch (ClassNotFoundException cnfe) {
2615            throw new RuntimeException("Parcelable encountered " +
2616                "ClassNotFoundException reading a Serializable object (name = "
2617                + name + ")", cnfe);
2618        }
2619    }
2620
2621    // Cache of previously looked up CREATOR.createFromParcel() methods for
2622    // particular classes.  Keys are the names of the classes, values are
2623    // Method objects.
2624    private static final HashMap<ClassLoader,HashMap<String,Parcelable.Creator<?>>>
2625        mCreators = new HashMap<>();
2626
2627    /** @hide for internal use only. */
2628    static protected final Parcel obtain(int obj) {
2629        throw new UnsupportedOperationException();
2630    }
2631
2632    /** @hide */
2633    static protected final Parcel obtain(long obj) {
2634        final Parcel[] pool = sHolderPool;
2635        synchronized (pool) {
2636            Parcel p;
2637            for (int i=0; i<POOL_SIZE; i++) {
2638                p = pool[i];
2639                if (p != null) {
2640                    pool[i] = null;
2641                    if (DEBUG_RECYCLE) {
2642                        p.mStack = new RuntimeException();
2643                    }
2644                    p.init(obj);
2645                    return p;
2646                }
2647            }
2648        }
2649        return new Parcel(obj);
2650    }
2651
2652    private Parcel(long nativePtr) {
2653        if (DEBUG_RECYCLE) {
2654            mStack = new RuntimeException();
2655        }
2656        //Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack);
2657        init(nativePtr);
2658    }
2659
2660    private void init(long nativePtr) {
2661        if (nativePtr != 0) {
2662            mNativePtr = nativePtr;
2663            mOwnsNativeParcelObject = false;
2664        } else {
2665            mNativePtr = nativeCreate();
2666            mOwnsNativeParcelObject = true;
2667        }
2668    }
2669
2670    private void freeBuffer() {
2671        if (mOwnsNativeParcelObject) {
2672            updateNativeSize(nativeFreeBuffer(mNativePtr));
2673        }
2674    }
2675
2676    private void destroy() {
2677        if (mNativePtr != 0) {
2678            if (mOwnsNativeParcelObject) {
2679                nativeDestroy(mNativePtr);
2680                updateNativeSize(0);
2681            }
2682            mNativePtr = 0;
2683        }
2684    }
2685
2686    @Override
2687    protected void finalize() throws Throwable {
2688        if (DEBUG_RECYCLE) {
2689            if (mStack != null) {
2690                Log.w(TAG, "Client did not call Parcel.recycle()", mStack);
2691            }
2692        }
2693        destroy();
2694    }
2695
2696    /* package */ void readMapInternal(Map outVal, int N,
2697        ClassLoader loader) {
2698        while (N > 0) {
2699            Object key = readValue(loader);
2700            Object value = readValue(loader);
2701            outVal.put(key, value);
2702            N--;
2703        }
2704    }
2705
2706    /* package */ void readArrayMapInternal(ArrayMap outVal, int N,
2707        ClassLoader loader) {
2708        if (DEBUG_ARRAY_MAP) {
2709            RuntimeException here =  new RuntimeException("here");
2710            here.fillInStackTrace();
2711            Log.d(TAG, "Reading " + N + " ArrayMap entries", here);
2712        }
2713        int startPos;
2714        while (N > 0) {
2715            if (DEBUG_ARRAY_MAP) startPos = dataPosition();
2716            String key = readString();
2717            Object value = readValue(loader);
2718            if (DEBUG_ARRAY_MAP) Log.d(TAG, "  Read #" + (N-1) + " "
2719                    + (dataPosition()-startPos) + " bytes: key=0x"
2720                    + Integer.toHexString((key != null ? key.hashCode() : 0)) + " " + key);
2721            outVal.append(key, value);
2722            N--;
2723        }
2724        outVal.validate();
2725    }
2726
2727    /* package */ void readArrayMapSafelyInternal(ArrayMap outVal, int N,
2728        ClassLoader loader) {
2729        if (DEBUG_ARRAY_MAP) {
2730            RuntimeException here =  new RuntimeException("here");
2731            here.fillInStackTrace();
2732            Log.d(TAG, "Reading safely " + N + " ArrayMap entries", here);
2733        }
2734        while (N > 0) {
2735            String key = readString();
2736            if (DEBUG_ARRAY_MAP) Log.d(TAG, "  Read safe #" + (N-1) + ": key=0x"
2737                    + (key != null ? key.hashCode() : 0) + " " + key);
2738            Object value = readValue(loader);
2739            outVal.put(key, value);
2740            N--;
2741        }
2742    }
2743
2744    /**
2745     * @hide For testing only.
2746     */
2747    public void readArrayMap(ArrayMap outVal, ClassLoader loader) {
2748        final int N = readInt();
2749        if (N < 0) {
2750            return;
2751        }
2752        readArrayMapInternal(outVal, N, loader);
2753    }
2754
2755    /**
2756     * Reads an array set.
2757     *
2758     * @param loader The class loader to use.
2759     *
2760     * @hide
2761     */
2762    public @Nullable ArraySet<? extends Object> readArraySet(ClassLoader loader) {
2763        final int size = readInt();
2764        if (size < 0) {
2765            return null;
2766        }
2767        ArraySet<Object> result = new ArraySet<>(size);
2768        for (int i = 0; i < size; i++) {
2769            Object value = readValue(loader);
2770            result.append(value);
2771        }
2772        return result;
2773    }
2774
2775    private void readListInternal(List outVal, int N,
2776        ClassLoader loader) {
2777        while (N > 0) {
2778            Object value = readValue(loader);
2779            //Log.d(TAG, "Unmarshalling value=" + value);
2780            outVal.add(value);
2781            N--;
2782        }
2783    }
2784
2785    private void readArrayInternal(Object[] outVal, int N,
2786        ClassLoader loader) {
2787        for (int i = 0; i < N; i++) {
2788            Object value = readValue(loader);
2789            //Log.d(TAG, "Unmarshalling value=" + value);
2790            outVal[i] = value;
2791        }
2792    }
2793
2794    private void readSparseArrayInternal(SparseArray outVal, int N,
2795        ClassLoader loader) {
2796        while (N > 0) {
2797            int key = readInt();
2798            Object value = readValue(loader);
2799            //Log.i(TAG, "Unmarshalling key=" + key + " value=" + value);
2800            outVal.append(key, value);
2801            N--;
2802        }
2803    }
2804
2805
2806    private void readSparseBooleanArrayInternal(SparseBooleanArray outVal, int N) {
2807        while (N > 0) {
2808            int key = readInt();
2809            boolean value = this.readByte() == 1;
2810            //Log.i(TAG, "Unmarshalling key=" + key + " value=" + value);
2811            outVal.append(key, value);
2812            N--;
2813        }
2814    }
2815
2816    /**
2817     * @hide For testing
2818     */
2819    public long getBlobAshmemSize() {
2820        return nativeGetBlobAshmemSize(mNativePtr);
2821    }
2822}
2823