Parcel.java revision e2adb2cf0f2c90c77fab3f09285a92e05e70b567
1d195e5ab401432ddac659791640a2927fc668699Elliott Hughes/* 2d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * Copyright (C) 2006 The Android Open Source Project 3d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * 4d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * Licensed under the Apache License, Version 2.0 (the "License"); 5d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * you may not use this file except in compliance with the License. 6d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * You may obtain a copy of the License at 7d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * 8d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * http://www.apache.org/licenses/LICENSE-2.0 9d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * 10d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * Unless required by applicable law or agreed to in writing, software 11d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * distributed under the License is distributed on an "AS IS" BASIS, 12d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * See the License for the specific language governing permissions and 14d195e5ab401432ddac659791640a2927fc668699Elliott Hughes * limitations under the License. 15d195e5ab401432ddac659791640a2927fc668699Elliott Hughes */ 169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectpackage android.os; 189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport android.text.TextUtils; 209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport android.util.ArrayMap; 210795272aa226f4e965968a03daddc53ce30b7cdaMathias Agopianimport android.util.Log; 220bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrickimport android.util.Size; 230795272aa226f4e965968a03daddc53ce30b7cdaMathias Agopianimport android.util.SizeF; 249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport android.util.SparseArray; 259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport android.util.SparseBooleanArray; 260795272aa226f4e965968a03daddc53ce30b7cdaMathias Agopian 279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.ByteArrayInputStream; 289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.ByteArrayOutputStream; 299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.FileDescriptor; 309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.FileNotFoundException; 319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.IOException; 32fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reedimport java.io.ObjectInputStream; 339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.ObjectOutputStream; 349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.ObjectStreamClass; 359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.io.Serializable; 369f8203a159d46124a0907a0d9500e599533beed3Brian Carlstromimport java.lang.reflect.Field; 379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.lang.reflect.Modifier; 389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.util.ArrayList; 399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.util.Arrays; 409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.util.HashMap; 419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.util.List; 429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.util.Map; 439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectimport java.util.Set; 449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/** 469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Container for a message (data and object references) that can 479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * be sent through an IBinder. A Parcel can contain both flattened data 489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * that will be unflattened on the other side of the IPC (using the various 499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * methods here for writing specific types, or the general 509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link Parcelable} interface), and references to live {@link IBinder} 519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * objects that will result in the other side receiving a proxy IBinder 529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * connected with the original IBinder in the Parcel. 539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 546b849e2123be98eb2a1a25b8abf0b13a279ce952Wei-Ta Chen * <p class="note">Parcel is <strong>not</strong> a general-purpose 559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * serialization mechanism. This class (and the corresponding 56d0d7eaf129b48ea04c06902a11c2a4f74056d76cLeon Scroggins III * {@link Parcelable} API for placing arbitrary objects into a Parcel) is 579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * designed as a high-performance IPC transport. As such, it is not 589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * appropriate to place any Parcel data in to persistent storage: changes 599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * in the underlying implementation of any of the data in the Parcel can 609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * render older data unreadable.</p> 619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p>The bulk of the Parcel API revolves around reading and writing data 639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * of various types. There are six major classes of such functions available.</p> 649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <h3>Primitives</h3> 66bca2d613e0d6d2630fedd302c0d779b7610adbcfWei-Ta Chen * 679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p>The most basic data functions are for writing and reading primitive 689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * data types: {@link #writeByte}, {@link #readByte}, {@link #writeDouble}, 699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #readDouble}, {@link #writeFloat}, {@link #readFloat}, {@link #writeInt}, 706b1e838fc16d397359f82c3a4f5700f1ed7dd910Thomas Tafertshofer * {@link #readInt}, {@link #writeLong}, {@link #readLong}, 71237c2b871f66e06498ad03aaa92964f4434982c5Jesse Hall * {@link #writeString}, {@link #readString}. Most other 721c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * data operations are built on top of these. The given data is written and 731c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * read using the endianess of the host CPU.</p> 741c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * 751c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * <h3>Primitive Arrays</h3> 76560814f6b11abe83ff0c4ed18cac015c276b3181Jack Palevich * 77d877efe3b12afdd84f06c180369f9d7399858f6eJesse Hall * <p>There are a variety of methods for reading and writing raw arrays 789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * of primitive objects, which generally result in writing a 4-byte length 799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * followed by the primitive data items. The methods for reading can either 802f1a2e423e0fbb64467d6fcfa4e82c6384f31210Eino-Ville Talvala * read the data into an existing array, or create and return a new array. 819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * These available types are:</p> 82b01e8bf57b7492b77e3445db51471edcbadda75eMike Lockwood * 83e7d511e148bc901ef41ac44d7b3593e5d803f72fMike Lockwood * <ul> 84acc29cc91be634070c92a807df412ced97b9b375Mike Lockwood * <li> {@link #writeBooleanArray(boolean[])}, 85e7d511e148bc901ef41ac44d7b3593e5d803f72fMike Lockwood * {@link #readBooleanArray(boolean[])}, {@link #createBooleanArray()} 869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeByteArray(byte[])}, 879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #writeByteArray(byte[], int, int)}, {@link #readByteArray(byte[])}, 889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createByteArray()} 899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeCharArray(char[])}, {@link #readCharArray(char[])}, 909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createCharArray()} 919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeDoubleArray(double[])}, {@link #readDoubleArray(double[])}, 929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createDoubleArray()} 939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeFloatArray(float[])}, {@link #readFloatArray(float[])}, 949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createFloatArray()} 959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeIntArray(int[])}, {@link #readIntArray(int[])}, 969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createIntArray()} 979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeLongArray(long[])}, {@link #readLongArray(long[])}, 989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createLongArray()} 999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeStringArray(String[])}, {@link #readStringArray(String[])}, 1009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createStringArray()}. 1019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link #writeSparseBooleanArray(SparseBooleanArray)}, 1029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #readSparseBooleanArray()}. 1039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * </ul> 1049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <h3>Parcelables</h3> 106b2a3dd88a53cc8c6d19f6dc8ec4f3d6c4abd9b54The Android Open Source Project * 1079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p>The {@link Parcelable} protocol provides an extremely efficient (but 10852244fff29042926e21fa897ef5ab11148e35299John Reck * low-level) protocol for objects to write and read themselves from Parcels. 1099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * You can use the direct methods {@link #writeParcelable(Parcelable, int)} 1109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * and {@link #readParcelable(ClassLoader)} or 1119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #writeParcelableArray} and 1129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #readParcelableArray(ClassLoader)} to write or read. These 1139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * methods write both the class type and its data to the Parcel, allowing 1149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * that class to be reconstructed from the appropriate class loader when 1159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * later reading.</p> 1169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p>There are also some methods that provide a more efficient way to work 118fbf097732137a32930d151f7ba6816a5b870c32aJeff Brown * with Parcelables: {@link #writeTypedObject}, {@link #writeTypedArray}, 119aa0ce3396c096c97e3394c53e3912cb08b66fe20Jamie Gennis * {@link #writeTypedList}, {@link #readTypedObject}, 1209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createTypedArray} and {@link #createTypedArrayList}. These methods 1216811f4e92cbb64e72a0d13eb9b99b5894bd59c76Svetoslav * do not write the class information of the original object: instead, the 1222961769ea94f69c191a2dd785b2504666c7292d0Svetoslav * caller of the read function must know what type to expect and pass in the 1230a0a1248cfc03940174cbd9af677bafd7280a3bcJeff Brown * appropriate {@link Parcelable.Creator Parcelable.Creator} instead to 124f666ad7046c0b1b255835f75aeb7d1391067df93John Reck * properly construct the new object and read its data. (To more efficient 125e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck * write and read a single Parceable object that is not null, you can directly 1263b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy * call {@link Parcelable#writeToParcel Parcelable.writeToParcel} and 127e4d011201cea40d46cb2b2eef401db8fddc5c9c6Romain Guy * {@link Parcelable.Creator#createFromParcel Parcelable.Creator.createFromParcel} 1283083579424785e55ca8f82856a6553ee983c3ffbJohn Reck * yourself.)</p> 12904fc583c3dd3144bc6b718fcac4b3e1afdfdb067John Reck * 130cec24ae16e9a0a7c3075f1a8d9149bb7fb3813fcJohn Reck * <h3>Bundles</h3> 1319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1323866f0d581ceaa165710feeee9f37fe1b0d7067dMathias Agopian * <p>A special type-safe container, called {@link Bundle}, is available 13364a55af0ac700baecb0877235eb42caac59a3560Jeff Brown * for key/value maps of heterogeneous values. This has many optimizations 1348f0095cd33558e9cc8a440047908e53b68906f5fRomain Guy * for improved performance when reading and writing data, and its type-safe 135315c329544d7c593d1072b071cbb92d9afe74021John Reck * API avoids difficult to debug type errors when finally marshalling the 1369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * data contents into a Parcel. The methods to use are 137e5360fbf3efe85427f7e7f59afe7bbeddb4949acJeff Brown * {@link #writeBundle(Bundle)}, {@link #readBundle()}, and 138e5360fbf3efe85427f7e7f59afe7bbeddb4949acJeff Brown * {@link #readBundle(ClassLoader)}. 1399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <h3>Active Objects</h3> 1419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p>An unusual feature of Parcel is the ability to read and write active 143fa9e7c05c7be6891a6cf85a11dc635a6e6853078Christopher Tate * objects. For these objects the actual contents of the object is not 144d84e1ce0b535128f03416145554fb405f9fade3eJeff Sharkey * written, rather a special token referencing the object is written. When 145c07fca3831baf4d812dd724f506b4ed23dcc39e0Stephen Smalley * reading the object back from the Parcel, you do not get a new instance of 1469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the object, but rather a handle that operates on the exact same object that 1479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * was originally written. There are two forms of active objects available.</p> 148481c1570dc5cdf58265b53f657801709dd05d1dfJeff Brown * 1499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <p>{@link Binder} objects are a core facility of Android's general cross-process 1509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * communication system. The {@link IBinder} interface describes an abstract 1519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * protocol with a Binder object. Any such interface can be written in to 1529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * a Parcel, and upon reading you will receive either the original object 1539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * implementing that interface or a special proxy implementation 1542b4abcd0c7c4361af8ab6d5d7b073fb75ac6d219Dan Egnor * that communicates calls back to the original object. The methods to use are 1559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #writeStrongBinder(IBinder)}, 156dae8e94cce0881f3e10ef5e34b881f512bb52a75Doug Felt * {@link #writeStrongInterface(IInterface)}, {@link #readStrongBinder()}, 1579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #writeBinderArray(IBinder[])}, {@link #readBinderArray(IBinder[])}, 15898a4f7e7e12effb78b3d1035e5a670ccbbf5bca1JP Abgrall * {@link #createBinderArray()}, 159ecaa7b41ca49154ceaa9a7504eb0a86b89a96026Christopher Tate * {@link #writeBinderList(List)}, {@link #readBinderList(List)}, 1609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #createBinderArrayList()}.</p> 1619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1621cf587496fcb1d652bab9fc6792fb106b6fefaa4Joe Onorato * <p>FileDescriptor objects, representing raw Linux file descriptor identifiers, 163d2110dbce071a236b6176de344ca797b737542ebJoe Onorato * can be written and {@link ParcelFileDescriptor} objects returned to operate 16406290a4bb9b280fa14a2bbeb2d3ceb09396a78c3Joe Onorato * on the original file descriptor. The returned file descriptor is a dup 1654ababd922eac5931e0222862ff082dc29e012816Joe Onorato * of the original file descriptor: the object and fd is different, but 1664a627c71ff53a4fca1f961f4b1dcc0461df18a06Christopher Tate * operating on the same underlying file stream, with the same position, etc. 1679c1e23baf5bfbebd1aebbd6d9a18c225325567ceChet Haase * The methods to use are {@link #writeFileDescriptor(FileDescriptor)}, 16869969e48f2bca9339662dddfacff0bbf6374ed7fDianne Hackborn * {@link #readFileDescriptor()}. 169cbad976b2a36a0895ca94510d5208a86f66cf596Jeff Brown * 17046b9ac0ae2162309774a7478cd9d4e578747bfc2Jeff Brown * <h3>Untyped Containers</h3> 1719f25b7fdf216c9ef0bd2322cd223eeaf0d60f77fJeff Brown * 17232cbc3855c2a971aa5a801fd339fb6a37db91a1aJeff Brown * <p>A final class of methods are for writing and reading standard Java 173c28867a1d67121ce5963de135e3ae2b1dbd9a33dJeff Brown * containers of arbitrary types. These all revolve around the 174a44dd26a75e24cc021802288fb81f4761e47be6bMichael Wright * {@link #writeValue(Object)} and {@link #readValue(ClassLoader)} methods 1759f25b7fdf216c9ef0bd2322cd223eeaf0d60f77fJeff Brown * which define the types of objects allowed. The container methods are 17646b9ac0ae2162309774a7478cd9d4e578747bfc2Jeff Brown * {@link #writeArray(Object[])}, {@link #readArray(ClassLoader)}, 17746b9ac0ae2162309774a7478cd9d4e578747bfc2Jeff Brown * {@link #writeList(List)}, {@link #readList(List, ClassLoader)}, 1782352b978a3c94cd88f41d0d908f961333fdac1e9Jeff Brown * {@link #readArrayList(ClassLoader)}, 1792ed2462aa29c564f5231f317c27b3188da875e52Jeff Brown * {@link #writeMap(Map)}, {@link #readMap(Map, ClassLoader)}, 18002c8730c1bf19daf48bec8c6995df676a00a73b1Kenny Root * {@link #writeSparseArray(SparseArray)}, 18108d5b8fad8d46ccb64db2fdcb4d66972ec87bf48Dianne Hackborn * {@link #readSparseArray(ClassLoader)}. 1826e0ecb4eed5cd2e1f15766d7028467129974a12dChet Haase */ 18366269ea6f68f2f25888ce1080c94ac782742fafcKenny Rootpublic final class Parcel { 1849a2c2a6da90abbcc9a064c20e93ed885651f4ae1Jeff Sharkey private static final boolean DEBUG_RECYCLE = false; 185973b4663b0b5ee62006522bf4742af076096e548Narayan Kamath private static final boolean DEBUG_ARRAY_MAP = false; 1869fa4071c4768c63902c6a74a4b480b51a8b95d43John Reck private static final String TAG = "Parcel"; 1879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project @SuppressWarnings({"UnusedDeclaration"}) 1899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private long mNativePtr; // used by native code 1909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flag indicating if {@link #mNativePtr} was allocated by this object, 1939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * indicating that we're responsible for its lifecycle. 1949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private boolean mOwnsNativeParcelObject; 1969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private RuntimeException mStack; 1989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19916f5f5cc9d4c480fac3dc7f176f3f1edfbd256f4Jeff Brown private static final int POOL_SIZE = 6; 2009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final Parcel[] sOwnedPool = new Parcel[POOL_SIZE]; 2019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final Parcel[] sHolderPool = new Parcel[POOL_SIZE]; 2029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_NULL = -1; 20416f5f5cc9d4c480fac3dc7f176f3f1edfbd256f4Jeff Brown private static final int VAL_STRING = 0; 2059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_INTEGER = 1; 2069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_MAP = 2; 2079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_BUNDLE = 3; 2089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_PARCELABLE = 4; 2094280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_SHORT = 5; 2104280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_LONG = 6; 2114280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_FLOAT = 7; 2124280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_DOUBLE = 8; 2134280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_BOOLEAN = 9; 2144280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_CHARSEQUENCE = 10; 2159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_LIST = 11; 2169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_SPARSEARRAY = 12; 2179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_BYTEARRAY = 13; 2189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_STRINGARRAY = 14; 21916f5f5cc9d4c480fac3dc7f176f3f1edfbd256f4Jeff Brown private static final int VAL_IBINDER = 15; 22016f5f5cc9d4c480fac3dc7f176f3f1edfbd256f4Jeff Brown private static final int VAL_PARCELABLEARRAY = 16; 22116f5f5cc9d4c480fac3dc7f176f3f1edfbd256f4Jeff Brown private static final int VAL_OBJECTARRAY = 17; 22216f5f5cc9d4c480fac3dc7f176f3f1edfbd256f4Jeff Brown private static final int VAL_INTARRAY = 18; 2234280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_LONGARRAY = 19; 2244280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown private static final int VAL_BYTE = 20; 2259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_SERIALIZABLE = 21; 2269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_SPARSEBOOLEANARRAY = 22; 2279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_BOOLEANARRAY = 23; 2289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_CHARSEQUENCEARRAY = 24; 2299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_PERSISTABLEBUNDLE = 25; 2309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_SIZE = 26; 2319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int VAL_SIZEF = 27; 2329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // The initial int32 in a Binder call's reply Parcel header: 2349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int EX_SECURITY = -1; 2359ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static final int EX_BAD_PARCELABLE = -2; 2369ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static final int EX_ILLEGAL_ARGUMENT = -3; 237a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static final int EX_NULL_POINTER = -4; 238a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static final int EX_ILLEGAL_STATE = -5; 239a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static final int EX_NETWORK_MAIN_THREAD = -6; 240a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static final int EX_UNSUPPORTED_OPERATION = -7; 2419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static final int EX_HAS_REPLY_HEADER = -128; // special; see below 242c39a6e0c51e182338deb8b63d07933b585134929The Android Open Source Project 2439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native int nativeDataSize(long nativePtr); 2449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native int nativeDataAvail(long nativePtr); 2459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native int nativeDataPosition(long nativePtr); 246fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed private static native int nativeDataCapacity(long nativePtr); 247fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed private static native void nativeSetDataSize(long nativePtr, int size); 248fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed private static native void nativeSetDataPosition(long nativePtr, int pos); 249fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed private static native void nativeSetDataCapacity(long nativePtr, int size); 250fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed 251fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed private static native boolean nativePushAllowFds(long nativePtr, boolean allowFds); 252fc8db53eee11568b286e8d9c17e211bd6781fab6Mike Reed private static native void nativeRestoreAllowFds(long nativePtr, boolean lastValue); 2539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteByteArray(long nativePtr, byte[] b, int offset, int len); 2559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteBlob(long nativePtr, byte[] b, int offset, int len); 2569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteInt(long nativePtr, int val); 2579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteLong(long nativePtr, long val); 2589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteFloat(long nativePtr, float val); 2599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteDouble(long nativePtr, double val); 2609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteString(long nativePtr, String val); 2619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteStrongBinder(long nativePtr, IBinder val); 2629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteFileDescriptor(long nativePtr, FileDescriptor val); 2639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native byte[] nativeCreateByteArray(long nativePtr); 2659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native byte[] nativeReadBlob(long nativePtr); 2669ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native int nativeReadInt(long nativePtr); 2679ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native long nativeReadLong(long nativePtr); 2689ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native float nativeReadFloat(long nativePtr); 2699ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native double nativeReadDouble(long nativePtr); 2709ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native String nativeReadString(long nativePtr); 2719ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native IBinder nativeReadStrongBinder(long nativePtr); 2729ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native FileDescriptor nativeReadFileDescriptor(long nativePtr); 2739ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber 2749ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber private static native long nativeCreate(); 275a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static native void nativeFreeBuffer(long nativePtr); 276a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static native void nativeDestroy(long nativePtr); 277a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath 278a23fcd7be8e40078a913b1a99222cdd89229e67bNarayan Kamath private static native byte[] nativeMarshall(long nativePtr); 27922ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath private static native void nativeUnmarshall( 28022ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath long nativePtr, byte[] data, int offset, int length); 2819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeAppendFrom( 2829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project long thisNativePtr, long otherNativePtr, int offset, int length); 2839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native boolean nativeHasFileDescriptors(long nativePtr); 2849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native void nativeWriteInterfaceToken(long nativePtr, String interfaceName); 28522ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath private static native void nativeEnforceInterface(long nativePtr, String interfaceName); 28608e60f2a165d23b53f41993374aa074165bb5863Dianne Hackborn 2879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project private static native long nativeGetBlobAshmemSize(long nativePtr); 288d195e5ab401432ddac659791640a2927fc668699Elliott Hughes 2899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final static Parcelable.Creator<String> STRING_CREATOR 2909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project = new Parcelable.Creator<String>() { 2919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public String createFromParcel(Parcel source) { 2929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return source.readString(); 2939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 29422ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath public String[] newArray(int size) { 2959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return new String[size]; 2969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 2979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project }; 2989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Retrieve a new Parcel object from the pool. 3019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 3029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static Parcel obtain() { 3039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project final Parcel[] pool = sOwnedPool; 3049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project synchronized (pool) { 30522ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath Parcel p; 3069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<POOL_SIZE; i++) { 30722ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath p = pool[i]; 3089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (p != null) { 30922ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath pool[i] = null; 31022ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath if (DEBUG_RECYCLE) { 3119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project p.mStack = new RuntimeException(); 3129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return p; 3149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return new Parcel(0); 3189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Put a Parcel object back into the pool. You must not touch 3229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the object after this call. 3234280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown */ 3249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void recycle() { 3259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (DEBUG_RECYCLE) mStack = null; 3269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project freeBuffer(); 3279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project final Parcel[] pool; 3299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (mOwnsNativeParcelObject) { 3309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project pool = sOwnedPool; 3319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 3329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mNativePtr = 0; 3339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project pool = sHolderPool; 3349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3360bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick synchronized (pool) { 3370bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick for (int i=0; i<POOL_SIZE; i++) { 3380bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick if (pool[i] == null) { 3390bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick pool[i] = this; 3400bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick return; 3410bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick } 3420bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick } 3430bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick } 3440bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick } 3450bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick 3460bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick /** @hide */ 3470bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick public static native long getGlobalAllocSize(); 3480bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick 3490bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick /** @hide */ 3509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static native long getGlobalAllocCount(); 3519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the total amount of data contained in the parcel. 3549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 3559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final int dataSize() { 3569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return nativeDataSize(mNativePtr); 3579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 359d195e5ab401432ddac659791640a2927fc668699Elliott Hughes /** 3609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the amount of data remaining to be read from the 3619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * parcel. That is, {@link #dataSize}-{@link #dataPosition}. 3629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 3639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final int dataAvail() { 3649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return nativeDataAvail(mNativePtr); 3659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the current position in the parcel data. Never 3699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * more than {@link #dataSize}. 3709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 3719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final int dataPosition() { 3729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return nativeDataPosition(mNativePtr); 3739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the total amount of space in the parcel. This is always 3779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * >= {@link #dataSize}. The difference between it and dataSize() is the 3789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * amount of room left until the parcel needs to re-allocate its 3799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * data buffer. 3809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 3819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final int dataCapacity() { 3829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return nativeDataCapacity(mNativePtr); 3839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Change the amount of data in the parcel. Can be either smaller or 3879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * larger than the current size. If larger than the current capacity, 3889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * more memory will be allocated. 3899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 3909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param size The new number of bytes in the Parcel. 3919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 392171ea89fb99385146e159ef75849a87c49ffee76Brian Carlstrom public final void setDataSize(int size) { 3939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeSetDataSize(mNativePtr, size); 3949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 3959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 3969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Move the current read/write position in the parcel. 3989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param pos New offset in the parcel; must be between 0 and 3999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #dataSize}. 4009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 4019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void setDataPosition(int pos) { 4025baa3a62a97544669fba6d65a11c07f252e654ddSteve Block nativeSetDataPosition(mNativePtr, pos); 4039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 4049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 405f70188aa4716625781d9952c6b883180528d4644Andy McFadden /** 406e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * Change the capacity (current available space) of the parcel. 407e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * 408e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * @param size The new capacity of the parcel, in bytes. Can not be 409e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * less than {@link #dataSize} -- that is, you can not drop existing data 410e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * with this method. 4113beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom */ 4123beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom public final void setDataCapacity(int size) { 413e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden nativeSetDataCapacity(mNativePtr, size); 414e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden } 4153beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom 416e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden /** @hide */ 417e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden public final boolean pushAllowFds(boolean allowFds) { 418e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden return nativePushAllowFds(mNativePtr, allowFds); 4193beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom } 4203beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom 421e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden /** @hide */ 422e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden public final void restoreAllowFds(boolean lastValue) { 423e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden nativeRestoreAllowFds(mNativePtr, lastValue); 424e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden } 425e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden 426e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden /** 427e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * Returns the raw bytes of the parcel. 428e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * 429e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * <p class="note">The data you retrieve here <strong>must not</strong> 430e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * be placed in any kind of persistent storage (on local disk, across 431e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * a network, etc). For that, you should use standard serialization 432e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * or another kind of general serialization mechanism. The Parcel 433e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * marshalled representation is highly optimized for local IPC, and as 4343beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom * such does not attempt to maintain compatibility with data created 4353beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom * in different versions of the platform. 4363beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom */ 4373beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom public final byte[] marshall() { 4383beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom return nativeMarshall(mNativePtr); 439e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden } 440e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden 441e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden /** 442e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden * Set the bytes in data to be the raw bytes of this Parcel. 443e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden */ 444e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden public final void unmarshall(byte[] data, int offset, int length) { 445f70188aa4716625781d9952c6b883180528d4644Andy McFadden nativeUnmarshall(mNativePtr, data, offset, length); 446f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 447f70188aa4716625781d9952c6b883180528d4644Andy McFadden 448f70188aa4716625781d9952c6b883180528d4644Andy McFadden public final void appendFrom(Parcel parcel, int offset, int length) { 449f70188aa4716625781d9952c6b883180528d4644Andy McFadden nativeAppendFrom(mNativePtr, parcel.mNativePtr, offset, length); 45007a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 45107a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison 45207a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison /** 45307a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison * Report whether the parcel contains any marshalled file descriptors. 45407a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison */ 45507a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison public final boolean hasFileDescriptors() { 45607a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison return nativeHasFileDescriptors(mNativePtr); 45707a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 458f70188aa4716625781d9952c6b883180528d4644Andy McFadden 459f70188aa4716625781d9952c6b883180528d4644Andy McFadden /** 460f70188aa4716625781d9952c6b883180528d4644Andy McFadden * Store or read an IBinder interface token in the parcel at the current 4619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #dataPosition}. This is used to validate that the marshalled 462f70188aa4716625781d9952c6b883180528d4644Andy McFadden * transaction is intended for the target interface. 4639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 4649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeInterfaceToken(String interfaceName) { 4659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeWriteInterfaceToken(mNativePtr, interfaceName); 4669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 4679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void enforceInterface(String interfaceName) { 4699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeEnforceInterface(mNativePtr, interfaceName); 47038cfa8ca8bc67f4342431cea7e35643ddf9254ccCarl Shapiro } 471bdcef70e15e86e592d725355c96c7fab0b85ac83Dianne Hackborn 4728cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro /** 4735325010486a13553a8597aab92f90abc141a25e8Ian Rogers * Write a byte array into the parcel at the current {@link #dataPosition}, 4745325010486a13553a8597aab92f90abc141a25e8Ian Rogers * growing {@link #dataCapacity} if needed. 4757e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier * @param b Bytes to place into the parcel. 4765325010486a13553a8597aab92f90abc141a25e8Ian Rogers */ 477b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee public final void writeByteArray(byte[] b) { 4783beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom writeByteArray(b, 0, (b != null) ? b.length : 0); 4793beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom } 4803beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom 481e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden /** 4829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Write a byte array into the parcel at the current {@link #dataPosition}, 4839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing {@link #dataCapacity} if needed. 484e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden * @param b Bytes to place into the parcel. 4859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param offset Index of first byte to be written. 48652b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng * @param len Number of bytes to write. 48752b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng */ 48852b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng public final void writeByteArray(byte[] b, int offset, int len) { 48952b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng if (b == null) { 49052b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng writeInt(-1); 49152b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng return; 49207a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 49307a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison Arrays.checkOffsetAndCount(b.length, offset, len); 49407a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison nativeWriteByteArray(mNativePtr, b, offset, len); 49507a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 49607a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison 49707a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison /** 49807a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison * Write a blob of data into the parcel at the current {@link #dataPosition}, 49907a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison * growing {@link #dataCapacity} if needed. 50007a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison * @param b Bytes to place into the parcel. 5019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@hide} 5029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@SystemApi} 5039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeBlob(byte[] b) { 5059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeBlob(b, 0, (b != null) ? b.length : 0); 5069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Write a blob of data into the parcel at the current {@link #dataPosition}, 5109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing {@link #dataCapacity} if needed. 5119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param b Bytes to place into the parcel. 5129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param offset Index of first byte to be written. 5139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param len Number of bytes to write. 5149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@hide} 5159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@SystemApi} 5169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeBlob(byte[] b, int offset, int len) { 51852b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng if (b == null) { 51952b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng writeInt(-1); 5209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 5219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Arrays.checkOffsetAndCount(b.length, offset, len); 5239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeWriteBlob(mNativePtr, b, offset, len); 524e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden } 525e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden 526e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden /** 527e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden * Write an integer value into the parcel at the current dataPosition(), 528e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden * growing dataCapacity() if needed. 5299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeInt(int val) { 5319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeWriteInt(mNativePtr, val); 5329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Write a long integer value into the parcel at the current dataPosition(), 5369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. 5379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeLong(long val) { 5399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeWriteLong(mNativePtr, val); 5409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Write a floating point value into the parcel at the current 5449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * dataPosition(), growing dataCapacity() if needed. 5459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeFloat(float val) { 5479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeWriteFloat(mNativePtr, val); 5489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5500bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick /** 5510bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick * Write a double precision floating point value into the parcel at the 5520bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick * current dataPosition(), growing dataCapacity() if needed. 5530bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick */ 5540bd5243b751c9cad317758158f79b3347e7948afBrad Fitzpatrick public final void writeDouble(double val) { 5559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeWriteDouble(mNativePtr, val); 5569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Write a string value into the parcel at the current dataPosition(), 5609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. 5619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeString(String val) { 5639e4c884e7a7acd6b75399b180dc339295cda5a43Carl Shapiro nativeWriteString(mNativePtr, val); 5649e4c884e7a7acd6b75399b180dc339295cda5a43Carl Shapiro } 5659e4c884e7a7acd6b75399b180dc339295cda5a43Carl Shapiro 5669e4c884e7a7acd6b75399b180dc339295cda5a43Carl Shapiro /** 56738cfa8ca8bc67f4342431cea7e35643ddf9254ccCarl Shapiro * Write a CharSequence value into the parcel at the current dataPosition(), 5689e4c884e7a7acd6b75399b180dc339295cda5a43Carl Shapiro * growing dataCapacity() if needed. 56938cfa8ca8bc67f4342431cea7e35643ddf9254ccCarl Shapiro * @hide 57038cfa8ca8bc67f4342431cea7e35643ddf9254ccCarl Shapiro */ 571bdcef70e15e86e592d725355c96c7fab0b85ac83Dianne Hackborn public final void writeCharSequence(CharSequence val) { 572bdcef70e15e86e592d725355c96c7fab0b85ac83Dianne Hackborn TextUtils.writeToParcel(val, this, 0); 573bdcef70e15e86e592d725355c96c7fab0b85ac83Dianne Hackborn } 5749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5763f177d7c9a5c8ac727b0c6c3a5131e1e00ea52e8Elliott Hughes * Write an object into the parcel at the current dataPosition(), 5773f177d7c9a5c8ac727b0c6c3a5131e1e00ea52e8Elliott Hughes * growing dataCapacity() if needed. 5783f177d7c9a5c8ac727b0c6c3a5131e1e00ea52e8Elliott Hughes */ 5793f177d7c9a5c8ac727b0c6c3a5131e1e00ea52e8Elliott Hughes public final void writeStrongBinder(IBinder val) { 580b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee nativeWriteStrongBinder(mNativePtr, val); 581b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee } 582b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee 583b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee /** 584b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee * Write an object into the parcel at the current dataPosition(), 585b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee * growing dataCapacity() if needed. 586b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee */ 587b63de6de026b8ebe0b7d7b7f188afc30fff42411buzbee public final void writeStrongInterface(IInterface val) { 5888cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro writeStrongBinder(val == null ? null : val.asBinder()); 5898cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro } 5908cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro 5918cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro /** 5928cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro * Write a FileDescriptor into the parcel at the current dataPosition(), 5938cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro * growing dataCapacity() if needed. 5948cdf27c36a5b697396144925b3f61e4802dd3558Carl Shapiro * 5955325010486a13553a8597aab92f90abc141a25e8Ian Rogers * <p class="caution">The file descriptor will not be closed, which may 5965325010486a13553a8597aab92f90abc141a25e8Ian Rogers * result in file descriptor leaks when objects are returned from Binder 5975325010486a13553a8597aab92f90abc141a25e8Ian Rogers * calls. Use {@link ParcelFileDescriptor#writeToParcel} instead, which 5985325010486a13553a8597aab92f90abc141a25e8Ian Rogers * accepts contextual flags and will close the original file descriptor 5995325010486a13553a8597aab92f90abc141a25e8Ian Rogers * if {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE} is set.</p> 6005325010486a13553a8597aab92f90abc141a25e8Ian Rogers */ 6015325010486a13553a8597aab92f90abc141a25e8Ian Rogers public final void writeFileDescriptor(FileDescriptor val) { 6025325010486a13553a8597aab92f90abc141a25e8Ian Rogers nativeWriteFileDescriptor(mNativePtr, val); 6035325010486a13553a8597aab92f90abc141a25e8Ian Rogers } 6045325010486a13553a8597aab92f90abc141a25e8Ian Rogers 6055325010486a13553a8597aab92f90abc141a25e8Ian Rogers /** 6065325010486a13553a8597aab92f90abc141a25e8Ian Rogers * Write a byte value into the parcel at the current dataPosition(), 6075325010486a13553a8597aab92f90abc141a25e8Ian Rogers * growing dataCapacity() if needed. 6085325010486a13553a8597aab92f90abc141a25e8Ian Rogers */ 6095325010486a13553a8597aab92f90abc141a25e8Ian Rogers public final void writeByte(byte val) { 6105325010486a13553a8597aab92f90abc141a25e8Ian Rogers writeInt(val); 6117fef2b8a3782a94e1ad6bfef98807167db300aabIan Rogers } 6125325010486a13553a8597aab92f90abc141a25e8Ian Rogers 6135325010486a13553a8597aab92f90abc141a25e8Ian Rogers /** 6145325010486a13553a8597aab92f90abc141a25e8Ian Rogers * Please use {@link #writeBundle} instead. Flattens a Map into the parcel 6155325010486a13553a8597aab92f90abc141a25e8Ian Rogers * at the current dataPosition(), 616e6c2241f7a1e6bca3fd8d5d0c49abbbd348366b7Mathieu Chartier * growing dataCapacity() if needed. The Map keys must be String objects. 617e6c2241f7a1e6bca3fd8d5d0c49abbbd348366b7Mathieu Chartier * The Map values are written using {@link #writeValue} and must follow 618e6c2241f7a1e6bca3fd8d5d0c49abbbd348366b7Mathieu Chartier * the specification there. 619e6c2241f7a1e6bca3fd8d5d0c49abbbd348366b7Mathieu Chartier * 620e6c2241f7a1e6bca3fd8d5d0c49abbbd348366b7Mathieu Chartier * <p>It is strongly recommended to use {@link #writeBundle} instead of 621e6c2241f7a1e6bca3fd8d5d0c49abbbd348366b7Mathieu Chartier * this method, since the Bundle class provides a type-safe API that 6227e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier * allows you to avoid mysterious type errors at the point of marshalling. 6237e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier */ 6247e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier public final void writeMap(Map val) { 6257e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier writeMapInternal((Map<String, Object>) val); 6267e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier } 6277e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier 6287e4fdec6f0ac6385c5f8aeaf0f2e12e162138ac3Mathieu Chartier /** 6299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a Map into the parcel at the current dataPosition(), 6309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. The Map keys must be String objects. 6319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /* package */ void writeMapInternal(Map<String,Object> val) { 6339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 6349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 6359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 6369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Set<Map.Entry<String,Object>> entries = val.entrySet(); 6389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(entries.size()); 6399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (Map.Entry<String,Object> e : entries) { 6409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeValue(e.getKey()); 6419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeValue(e.getValue()); 6429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten an ArrayMap into the parcel at the current dataPosition(), 6479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. The Map keys must be String objects. 6489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /* package */ void writeArrayMapInternal(ArrayMap<String, Object> val) { 6509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 6519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 6529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 6539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project final int N = val.size(); 6559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 6569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (DEBUG_ARRAY_MAP) { 6579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project RuntimeException here = new RuntimeException("here"); 6589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project here.fillInStackTrace(); 65908065b9f09ead8895d97b2971622af8c179e1768Brian Carlstrom Log.d(TAG, "Writing " + N + " ArrayMap entries", here); 6609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int startPos; 6629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 6639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (DEBUG_ARRAY_MAP) startPos = dataPosition(); 6649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeString(val.keyAt(i)); 6659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeValue(val.valueAt(i)); 6669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (DEBUG_ARRAY_MAP) Log.d(TAG, " Write #" + i + " " 6679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + (dataPosition()-startPos) + " bytes: key=0x" 6689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + Integer.toHexString(val.keyAt(i) != null ? val.keyAt(i).hashCode() : 0) 6699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project + " " + val.keyAt(i)); 6709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6737b0b1ed979aa665175bf3952c8902ce13c763ab8The Android Open Source Project /** 6747b0b1ed979aa665175bf3952c8902ce13c763ab8The Android Open Source Project * @hide For testing only. 6757b0b1ed979aa665175bf3952c8902ce13c763ab8The Android Open Source Project */ 6767b0b1ed979aa665175bf3952c8902ce13c763ab8The Android Open Source Project public void writeArrayMap(ArrayMap<String, Object> val) { 6779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeArrayMapInternal(val); 6789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a Bundle into the parcel at the current dataPosition(), 6829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. 6839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeBundle(Bundle val) { 6859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 6865baa3a62a97544669fba6d65a11c07f252e654ddSteve Block writeInt(-1); 6879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 6889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val.writeToParcel(this, 0); 6919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a PersistableBundle into the parcel at the current dataPosition(), 6959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. 6969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writePersistableBundle(PersistableBundle val) { 6989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 6999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 70052b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng return; 701d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro } 702d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro 703d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro val.writeToParcel(this, 0); 704d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro } 705d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro 706d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro /** 707d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro * Flatten a Size into the parcel at the current dataPosition(), 708d8f3ec6e8308400e9446b254fcca457f6e53ea13Carl Shapiro * growing dataCapacity() if needed. 70952b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng */ 71052b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng public final void writeSize(Size val) { 71152b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng writeInt(val.getWidth()); 71252b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng writeInt(val.getHeight()); 71352b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng } 71452b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng 71552b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng /** 71652b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng * Flatten a SizeF into the parcel at the current dataPosition(), 71752b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng * growing dataCapacity() if needed. 71852b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng */ 71952b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng public final void writeSizeF(SizeF val) { 72052b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng writeFloat(val.getWidth()); 72152b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng writeFloat(val.getHeight()); 72252b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng } 72352b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng 72452b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng /** 72552b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng * Flatten a List into the parcel at the current dataPosition(), growing 72652b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng * dataCapacity() if needed. The List values are written using 7279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #writeValue} and must follow the specification there. 7289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 7299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeList(List val) { 7309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 7319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 7329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 73352b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng } 73452b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng int N = val.size(); 73552b0e73443ff8da195fbf0df851a028e07a691b2Ben Cheng int i=0; 7369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 737e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden while (i < N) { 738e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden writeValue(val.get(i)); 739e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden i++; 740e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden } 741e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden } 742e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden 743e2b23e11a5475e5c35eb07ba883cb05eca18796fAndy McFadden /** 7449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten an Object array into the parcel at the current dataPosition(), 7459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * growing dataCapacity() if needed. The array values are written using 7469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #writeValue} and must follow the specification there. 7479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 7489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeArray(Object[] val) { 7499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 7509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 7519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 7529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 7546215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block int i=0; 7559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 7569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project while (i < N) { 7579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeValue(val[i]); 75871f2cf116aab893e224056c38ab146bd1538dd3eSteve Block i++; 7599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7626215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block /** 7639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a generic SparseArray into the parcel at the current 7649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * dataPosition(), growing dataCapacity() if needed. The SparseArray 7659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * values are written using {@link #writeValue} and must follow the 7669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * specification there. 7679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 7689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeSparseArray(SparseArray<Object> val) { 7699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 7709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 7719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 7729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.size(); 7749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 7759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int i=0; 7769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project while (i < N) { 777e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden writeInt(val.keyAt(i)); 77898ba7bd5d1942edd7c2881cc6fd0e777ae8baa2eBrian Carlstrom writeValue(val.valueAt(i)); 7793beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom i++; 78098ba7bd5d1942edd7c2881cc6fd0e777ae8baa2eBrian Carlstrom } 7813beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom } 78298ba7bd5d1942edd7c2881cc6fd0e777ae8baa2eBrian Carlstrom 7833beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom public final void writeSparseBooleanArray(SparseBooleanArray val) { 7843beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom if (val == null) { 7853beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom writeInt(-1); 7863beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom return; 7873beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom } 7883beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom int N = val.size(); 7893beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom writeInt(N); 7903beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom int i=0; 7913beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom while (i < N) { 792e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden writeInt(val.keyAt(i)); 793e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden writeByte((byte)(val.valueAt(i) ? 1 : 0)); 7943beff1e023193b485c67a3003a7f363f105d96d4Brian Carlstrom i++; 795e4d81f25bd4dc1a5c909b56ab56a56406290da30Andy McFadden } 7969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeBooleanArray(boolean[] val) { 7999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 8009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 8019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 8029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 8039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(val[i] ? 1 : 0); 8049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 8069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 8079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8080efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison } 8090efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison 8100efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison public final boolean[] createBooleanArray() { 81198ba7bd5d1942edd7c2881cc6fd0e777ae8baa2eBrian Carlstrom int N = readInt(); 8120efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison // >>2 as a fast divide-by-4 works in the create*Array() functions 81307a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison // because dataAvail() will never return a negative number. 4 is 81407a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison // the size of a stored boolean in the stream. 81507a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison if (N >= 0 && N <= (dataAvail() >> 2)) { 8160efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison boolean[] val = new boolean[N]; 8170efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison for (int i=0; i<N; i++) { 8180efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison val[i] = readInt() != 0; 81907a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 82007a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison return val; 82107a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } else { 8220efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison return null; 8230efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison } 8240efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison } 8250efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison 82607a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison public final void readBooleanArray(boolean[] val) { 82707a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison int N = readInt(); 82807a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison if (N == val.length) { 8290efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison for (int i=0; i<N; i++) { 8300efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison val[i] = readInt() != 0; 8310efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison } 8320efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison } else { 83307a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison throw new RuntimeException("bad array lengths"); 83407a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 83507a1e2323b1e6765f220a045bd05783dd99b2914Dave Allison } 8360efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison 8370efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison public final void writeCharArray(char[] val) { 8380efbd9a463c848118c7685f4bfc8765a82caa761Dave Allison if (val != null) { 8399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 8409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 8419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 8429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt((int)val[i]); 8439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 8459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 8469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final char[] createCharArray() { 8509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 851f70188aa4716625781d9952c6b883180528d4644Andy McFadden if (N >= 0 && N <= (dataAvail() >> 2)) { 8523762c311729fe9f3af085c14c5c1fb471d994c03Steve Block char[] val = new char[N]; 8539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 8549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = (char)readInt(); 8559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 856f70188aa4716625781d9952c6b883180528d4644Andy McFadden return val; 857f70188aa4716625781d9952c6b883180528d4644Andy McFadden } else { 858f70188aa4716625781d9952c6b883180528d4644Andy McFadden return null; 859f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 860f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 861f70188aa4716625781d9952c6b883180528d4644Andy McFadden 862f70188aa4716625781d9952c6b883180528d4644Andy McFadden public final void readCharArray(char[] val) { 863d195e5ab401432ddac659791640a2927fc668699Elliott Hughes int N = readInt(); 864d195e5ab401432ddac659791640a2927fc668699Elliott Hughes if (N == val.length) { 865d195e5ab401432ddac659791640a2927fc668699Elliott Hughes for (int i=0; i<N; i++) { 866d195e5ab401432ddac659791640a2927fc668699Elliott Hughes val[i] = (char)readInt(); 867d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 868d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } else { 869d195e5ab401432ddac659791640a2927fc668699Elliott Hughes throw new RuntimeException("bad array lengths"); 870d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 871d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 872d195e5ab401432ddac659791640a2927fc668699Elliott Hughes 873d195e5ab401432ddac659791640a2927fc668699Elliott Hughes public final void writeIntArray(int[] val) { 874f70188aa4716625781d9952c6b883180528d4644Andy McFadden if (val != null) { 875f70188aa4716625781d9952c6b883180528d4644Andy McFadden int N = val.length; 876f70188aa4716625781d9952c6b883180528d4644Andy McFadden writeInt(N); 877f70188aa4716625781d9952c6b883180528d4644Andy McFadden for (int i=0; i<N; i++) { 878ebed7d6e35f7f960e6e6add2b8ab7c7a31a511c3Jeff Brown writeInt(val[i]); 879ebed7d6e35f7f960e6e6add2b8ab7c7a31a511c3Jeff Brown } 880ebed7d6e35f7f960e6e6add2b8ab7c7a31a511c3Jeff Brown } else { 881f70188aa4716625781d9952c6b883180528d4644Andy McFadden writeInt(-1); 88222ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath } 883f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 8845baa3a62a97544669fba6d65a11c07f252e654ddSteve Block 88508e60f2a165d23b53f41993374aa074165bb5863Dianne Hackborn public final int[] createIntArray() { 886f70188aa4716625781d9952c6b883180528d4644Andy McFadden int N = readInt(); 88722ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath if (N >= 0 && N <= (dataAvail() >> 2)) { 88822ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath int[] val = new int[N]; 889d195e5ab401432ddac659791640a2927fc668699Elliott Hughes for (int i=0; i<N; i++) { 890d195e5ab401432ddac659791640a2927fc668699Elliott Hughes val[i] = readInt(); 891f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 892f70188aa4716625781d9952c6b883180528d4644Andy McFadden return val; 89322ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath } else { 89422ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath return null; 89522ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath } 89622ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath } 89722ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath 89822ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath public final void readIntArray(int[] val) { 899f70188aa4716625781d9952c6b883180528d4644Andy McFadden int N = readInt(); 900f70188aa4716625781d9952c6b883180528d4644Andy McFadden if (N == val.length) { 901f70188aa4716625781d9952c6b883180528d4644Andy McFadden for (int i=0; i<N; i++) { 902f70188aa4716625781d9952c6b883180528d4644Andy McFadden val[i] = readInt(); 903f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 904f70188aa4716625781d9952c6b883180528d4644Andy McFadden } else { 905f70188aa4716625781d9952c6b883180528d4644Andy McFadden throw new RuntimeException("bad array lengths"); 906d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 907f70188aa4716625781d9952c6b883180528d4644Andy McFadden } 908f70188aa4716625781d9952c6b883180528d4644Andy McFadden 909f70188aa4716625781d9952c6b883180528d4644Andy McFadden public final void writeLongArray(long[] val) { 910f70188aa4716625781d9952c6b883180528d4644Andy McFadden if (val != null) { 911f70188aa4716625781d9952c6b883180528d4644Andy McFadden int N = val.length; 9125baa3a62a97544669fba6d65a11c07f252e654ddSteve Block writeInt(N); 913f70188aa4716625781d9952c6b883180528d4644Andy McFadden for (int i=0; i<N; i++) { 914f70188aa4716625781d9952c6b883180528d4644Andy McFadden writeLong(val[i]); 9159f8203a159d46124a0907a0d9500e599533beed3Brian Carlstrom } 9169f8203a159d46124a0907a0d9500e599533beed3Brian Carlstrom } else { 917d195e5ab401432ddac659791640a2927fc668699Elliott Hughes writeInt(-1); 918d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 919d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 920d195e5ab401432ddac659791640a2927fc668699Elliott Hughes 921d195e5ab401432ddac659791640a2927fc668699Elliott Hughes public final long[] createLongArray() { 922f70188aa4716625781d9952c6b883180528d4644Andy McFadden int N = readInt(); 9239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // >>3 because stored longs are 64 bits 9249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N >= 0 && N <= (dataAvail() >> 3)) { 9259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project long[] val = new long[N]; 9269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 9273762c311729fe9f3af085c14c5c1fb471d994c03Steve Block val[i] = readLong(); 928d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 9299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return val; 9309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 9319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return null; 9329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 933ebed7d6e35f7f960e6e6add2b8ab7c7a31a511c3Jeff Brown } 934ebed7d6e35f7f960e6e6add2b8ab7c7a31a511c3Jeff Brown 9359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void readLongArray(long[] val) { 9369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 9379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N == val.length) { 9389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 9399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = readLong(); 9409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 94222ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath throw new RuntimeException("bad array lengths"); 9439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeFloatArray(float[] val) { 94722ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath if (val != null) { 94822ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath int N = val.length; 94922ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath writeInt(N); 95022ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath for (int i=0; i<N; i++) { 95122ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath writeFloat(val[i]); 95222ec1eefa4dc8e12f7da8e8750d4770144941526Narayan Kamath } 9539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 9549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 9559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 958d195e5ab401432ddac659791640a2927fc668699Elliott Hughes public final float[] createFloatArray() { 959d195e5ab401432ddac659791640a2927fc668699Elliott Hughes int N = readInt(); 9609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // >>2 because stored floats are 4 bytes 9613762c311729fe9f3af085c14c5c1fb471d994c03Steve Block if (N >= 0 && N <= (dataAvail() >> 2)) { 9629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project float[] val = new float[N]; 9639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 964d195e5ab401432ddac659791640a2927fc668699Elliott Hughes val[i] = readFloat(); 9659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return val; 9673762c311729fe9f3af085c14c5c1fb471d994c03Steve Block } else { 9689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return null; 9699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void readFloatArray(float[] val) { 9739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 9749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N == val.length) { 9759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 9769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = readFloat(); 9779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 978d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } else { 9799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project throw new RuntimeException("bad array lengths"); 9805baa3a62a97544669fba6d65a11c07f252e654ddSteve Block } 9819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9828564c8da817a845353d213acd8636b76f567b234Steve Block 9839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeDoubleArray(double[] val) { 9848564c8da817a845353d213acd8636b76f567b234Steve Block if (val != null) { 9859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 9869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 9874280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown for (int i=0; i<N; i++) { 9889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeDouble(val[i]); 9894280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown } 9904280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown } else { 9914280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown writeInt(-1); 9924280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown } 9934280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown } 9944280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown 9954280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown public final double[] createDoubleArray() { 9964280c4a93ea17f2e9d3f651e49d8c13dc3fb92aaJeff Brown int N = readInt(); 9979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // >>3 because stored doubles are 8 bytes 9989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N >= 0 && N <= (dataAvail() >> 3)) { 999d195e5ab401432ddac659791640a2927fc668699Elliott Hughes double[] val = new double[N]; 1000d195e5ab401432ddac659791640a2927fc668699Elliott Hughes for (int i=0; i<N; i++) { 1001d195e5ab401432ddac659791640a2927fc668699Elliott Hughes val[i] = readDouble(); 1002d195e5ab401432ddac659791640a2927fc668699Elliott Hughes } 1003d195e5ab401432ddac659791640a2927fc668699Elliott Hughes return val; 10049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10059ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber return null; 10069ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber } 10079ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber } 10089ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber 10099ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber public final void readDoubleArray(double[] val) { 10109ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber int N = readInt(); 10119ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber if (N == val.length) { 10129ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber for (int i=0; i<N; i++) { 10139ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber val[i] = readDouble(); 10149ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber } 10159ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber } else { 10169ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber throw new RuntimeException("bad array lengths"); 10179ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber } 10189ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber } 10199ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber 10209ae000ca8c05ad6f700ad7bf119bbc92fb964b57Andreas Huber public final void writeStringArray(String[] val) { 10219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 10229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 10239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 10249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 10259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeString(val[i]); 10269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 10299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final String[] createStringArray() { 10339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 10349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N >= 0) { 10359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project String[] val = new String[N]; 10369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 10379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = readString(); 10389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return val; 10409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10416215d3ff4b5dfa52a5d8b9a42e343051f31066a5Steve Block return null; 10429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void readStringArray(String[] val) { 10469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 10479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N == val.length) { 10489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 10499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = readString(); 10509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project throw new RuntimeException("bad array lengths"); 10539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeBinderArray(IBinder[] val) { 10579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 10589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 10593762c311729fe9f3af085c14c5c1fb471d994c03Steve Block writeInt(N); 10609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 10619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeStrongBinder(val[i]); 10629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 10659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @hide 10709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 10719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeCharSequenceArray(CharSequence[] val) { 10729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 10739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.length; 10749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 10759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 10769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeCharSequence(val[i]); 10779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 10809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @hide 10859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 10869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeCharSequenceList(ArrayList<CharSequence> val) { 10879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 10889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.size(); 10899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 10909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 10919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeCharSequence(val.get(i)); 10929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 10949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 10959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1098d195e5ab401432ddac659791640a2927fc668699Elliott Hughes public final IBinder[] createBinderArray() { 10999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 11009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N >= 0) { 11019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project IBinder[] val = new IBinder[N]; 11029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 11039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = readStrongBinder(); 11049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return val; 11069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 11079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return null; 110832f2e6267481bd4b81b71061c539748143342fefMike Lockwood } 110932f2e6267481bd4b81b71061c539748143342fefMike Lockwood } 11109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void readBinderArray(IBinder[] val) { 11129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = readInt(); 11139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (N == val.length) { 11149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project for (int i=0; i<N; i++) { 11159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project val[i] = readStrongBinder(); 11169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 11189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project throw new RuntimeException("bad array lengths"); 11199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a List containing a particular object type into the parcel, at 11249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the current dataPosition() and growing dataCapacity() if needed. The 1125f602d362ba4bb3adbf1eb4e38a794fb14274293aMike Lockwood * type of the objects in the list must be one that implements Parcelable. 11269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Unlike the generic writeList() method, however, only the raw data of the 11279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * objects is written and not their type, so you must use the corresponding 1128f602d362ba4bb3adbf1eb4e38a794fb14274293aMike Lockwood * readTypedList() to unmarshall them. 11299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1130f602d362ba4bb3adbf1eb4e38a794fb14274293aMike Lockwood * @param val The list of objects to be written. 1131f602d362ba4bb3adbf1eb4e38a794fb14274293aMike Lockwood * 11329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see #createTypedArrayList 11339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see #readTypedList 11349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see Parcelable 11359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 11369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final <T extends Parcelable> void writeTypedList(List<T> val) { 11379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 11389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 11399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 11409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.size(); 11429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int i=0; 11439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 11449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project while (i < N) { 11459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project T item = val.get(i); 11469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (item != null) { 11479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(1); 11489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project item.writeToParcel(this, 0); 11499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 11509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(0); 11519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project i++; 11539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a List containing String objects into the parcel, at 11589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the current dataPosition() and growing dataCapacity() if needed. They 11599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * can later be retrieved with {@link #createStringArrayList} or 11609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #readStringList}. 11619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param val The list of strings to be written. 11635baa3a62a97544669fba6d65a11c07f252e654ddSteve Block * 11649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see #createStringArrayList 11659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see #readStringList 11669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 11679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void writeStringList(List<String> val) { 11689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 11699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 11709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 11719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.size(); 11739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int i=0; 11749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 11759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project while (i < N) { 11769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeString(val.get(i)); 11779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project i++; 11789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a List containing IBinder objects into the parcel, at 11839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the current dataPosition() and growing dataCapacity() if needed. They 11849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * can later be retrieved with {@link #createBinderArrayList} or 11859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #readBinderList}. 11869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param val The list of strings to be written. 1188b2a3dd88a53cc8c6d19f6dc8ec4f3d6c4abd9b54The Android Open Source Project * 11899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see #createBinderArrayList 1190dae8e94cce0881f3e10ef5e34b881f512bb52a75Doug Felt * @see #readBinderList 11919f25b7fdf216c9ef0bd2322cd223eeaf0d60f77fJeff Brown */ 11929f25b7fdf216c9ef0bd2322cd223eeaf0d60f77fJeff Brown public final void writeBinderList(List<IBinder> val) { 11939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val == null) { 1194a8079bfb9a738a7f24f103cd640e5317c4fd2510Andreas Huber writeInt(-1); 11959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return; 1196d84e1ce0b535128f03416145554fb405f9fade3eJeff Sharkey } 11979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int N = val.size(); 11989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project int i=0; 11995438979e498750b6a28ada7974d4e9fe17fd8394Chris Craik writeInt(N); 1200f666ad7046c0b1b255835f75aeb7d1391067df93John Reck while (i < N) { 1201e45b1fd03b524d2b57cc6c222d89076a31a08beaJohn Reck writeStrongBinder(val.get(i)); 12023b748a44c6bd2ea05fe16839caf73dbe50bd7ae9Romain Guy i++; 1203e4d011201cea40d46cb2b2eef401db8fddc5c9c6Romain Guy } 12043083579424785e55ca8f82856a6553ee983c3ffbJohn Reck } 120504fc583c3dd3144bc6b718fcac4b3e1afdfdb067John Reck 1206cec24ae16e9a0a7c3075f1a8d9149bb7fb3813fcJohn Reck /** 12079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten a heterogeneous array containing a particular object type into 12083866f0d581ceaa165710feeee9f37fe1b0d7067dMathias Agopian * the parcel, at 120964a55af0ac700baecb0877235eb42caac59a3560Jeff Brown * the current dataPosition() and growing dataCapacity() if needed. The 12108f0095cd33558e9cc8a440047908e53b68906f5fRomain Guy * type of the objects in the array must be one that implements Parcelable. 1211315c329544d7c593d1072b071cbb92d9afe74021John Reck * Unlike the {@link #writeParcelableArray} method, however, only the 12129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * raw data of the objects is written and not their type, so you must use 12139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link #readTypedArray} with the correct corresponding 12146b1e838fc16d397359f82c3a4f5700f1ed7dd910Thomas Tafertshofer * {@link Parcelable.Creator} implementation to unmarshall them. 1215237c2b871f66e06498ad03aaa92964f4434982c5Jesse Hall * 12161c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * @param val The array of objects to be written. 12171c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * @param parcelableFlags Contextual flags as per 12181c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}. 12191c4907ee77392afb768c2f088e0dedbe4239f6fbJack Palevich * 1220560814f6b11abe83ff0c4ed18cac015c276b3181Jack Palevich * @see #readTypedArray 1221d877efe3b12afdd84f06c180369f9d7399858f6eJesse Hall * @see #writeParcelableArray 12229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @see Parcelable.Creator 12239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 12249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final <T extends Parcelable> void writeTypedArray(T[] val, 12256b849e2123be98eb2a1a25b8abf0b13a279ce952Wei-Ta Chen int parcelableFlags) { 12269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 1227d0d7eaf129b48ea04c06902a11c2a4f74056d76cLeon Scroggins III int N = val.length; 12289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(N); 122952244fff29042926e21fa897ef5ab11148e35299John Reck for (int i=0; i<N; i++) { 12309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project T item = val[i]; 12319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (item != null) { 12329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(1); 12339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project item.writeToParcel(this, parcelableFlags); 12349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 12359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(0); 12369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else { 12399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(-1); 12409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 12449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Flatten the Parcelable object into the parcel. 12459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 12469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param val The Parcelable object to be written. 1247aa0ce3396c096c97e3394c53e3912cb08b66fe20Jamie Gennis * @param parcelableFlags Contextual flags as per 12489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}. 12499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1250bca2d613e0d6d2630fedd302c0d779b7610adbcfWei-Ta Chen * @see #readTypedObject 12516811f4e92cbb64e72a0d13eb9b99b5894bd59c76Svetoslav */ 12522961769ea94f69c191a2dd785b2504666c7292d0Svetoslav public final <T extends Parcelable> void writeTypedObject(T val, int parcelableFlags) { 12539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (val != null) { 12549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(1); 1255e5360fbf3efe85427f7e7f59afe7bbeddb4949acJeff Brown val.writeToParcel(this, parcelableFlags); 1256e5360fbf3efe85427f7e7f59afe7bbeddb4949acJeff Brown } else { 12579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(0); 12589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1260fa9e7c05c7be6891a6cf85a11dc635a6e6853078Christopher Tate 1261c07fca3831baf4d812dd724f506b4ed23dcc39e0Stephen Smalley /** 1262481c1570dc5cdf58265b53f657801709dd05d1dfJeff Brown * Flatten a generic object in to a parcel. The given Object value may 12639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * currently be one of the following types: 12649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 12659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <ul> 12662b4abcd0c7c4361af8ab6d5d7b073fb75ac6d219Dan Egnor * <li> null 12679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> String 12689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> Byte 1269973b4663b0b5ee62006522bf4742af076096e548Narayan Kamath * <li> Short 12709fa4071c4768c63902c6a74a4b480b51a8b95d43John Reck * <li> Integer 12719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> Long 12722f1a2e423e0fbb64467d6fcfa4e82c6384f31210Eino-Ville Talvala * <li> Float 12739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> Double 1274b01e8bf57b7492b77e3445db51471edcbadda75eMike Lockwood * <li> Boolean 1275e7d511e148bc901ef41ac44d7b3593e5d803f72fMike Lockwood * <li> String[] 1276acc29cc91be634070c92a807df412ced97b9b375Mike Lockwood * <li> boolean[] 1277e7d511e148bc901ef41ac44d7b3593e5d803f72fMike Lockwood * <li> byte[] 12789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> int[] 12799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> long[] 12809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> Object[] (supporting objects of the same type defined here). 12819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link Bundle} 1282cbad976b2a36a0895ca94510d5208a86f66cf596Jeff Brown * <li> Map (as supported by {@link #writeMap}). 12839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> Any object that implements the {@link Parcelable} protocol. 12849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> Parcelable[] 12859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> CharSequence (as supported by {@link TextUtils#writeToParcel}). 128698a4f7e7e12effb78b3d1035e5a670ccbbf5bca1JP Abgrall * <li> List (as supported by {@link #writeList}). 1287ecaa7b41ca49154ceaa9a7504eb0a86b89a96026Christopher Tate * <li> {@link SparseArray} (as supported by {@link #writeSparseArray(SparseArray)}). 12889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * <li> {@link IBinder} 12891cf587496fcb1d652bab9fc6792fb106b6fefaa4Joe Onorato * <li> Any object that implements Serializable (but see 1290d2110dbce071a236b6176de344ca797b737542ebJoe Onorato * {@link #writeSerializable} for caveats). Note that all of the 129106290a4bb9b280fa14a2bbeb2d3ceb09396a78c3Joe Onorato * previous types have relatively efficient implementations for 12924ababd922eac5931e0222862ff082dc29e012816Joe Onorato * writing to a Parcel; having to rely on the generic serialization 12934a627c71ff53a4fca1f961f4b1dcc0461df18a06Christopher Tate * approach is much less efficient and should be avoided whenever 12949c1e23baf5bfbebd1aebbd6d9a18c225325567ceChet Haase * possible. 129569969e48f2bca9339662dddfacff0bbf6374ed7fDianne Hackborn * </ul> 129646b9ac0ae2162309774a7478cd9d4e578747bfc2Jeff Brown * 129732cbc3855c2a971aa5a801fd339fb6a37db91a1aJeff Brown * <p class="caution">{@link Parcelable} objects are written with 1298c28867a1d67121ce5963de135e3ae2b1dbd9a33dJeff Brown * {@link Parcelable#writeToParcel} using contextual flags of 0. When 1299a44dd26a75e24cc021802288fb81f4761e47be6bMichael Wright * serializing objects containing {@link ParcelFileDescriptor}s, 130046b9ac0ae2162309774a7478cd9d4e578747bfc2Jeff Brown * this may result in file descriptor leaks when they are returned from 130146b9ac0ae2162309774a7478cd9d4e578747bfc2Jeff Brown * Binder calls (where {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE} 13022352b978a3c94cd88f41d0d908f961333fdac1e9Jeff Brown * should be used).</p> 13032ed2462aa29c564f5231f317c27b3188da875e52Jeff Brown */ 130402c8730c1bf19daf48bec8c6995df676a00a73b1Kenny Root public final void writeValue(Object v) { 130502c8730c1bf19daf48bec8c6995df676a00a73b1Kenny Root if (v == null) { 130608d5b8fad8d46ccb64db2fdcb4d66972ec87bf48Dianne Hackborn writeInt(VAL_NULL); 13076e0ecb4eed5cd2e1f15766d7028467129974a12dChet Haase } else if (v instanceof String) { 13086e0ecb4eed5cd2e1f15766d7028467129974a12dChet Haase writeInt(VAL_STRING); 130966269ea6f68f2f25888ce1080c94ac782742fafcKenny Root writeString((String) v); 13109a2c2a6da90abbcc9a064c20e93ed885651f4ae1Jeff Sharkey } else if (v instanceof Integer) { 13119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_INTEGER); 13129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt((Integer) v); 13139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Map) { 13149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_MAP); 13159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeMap((Map) v); 13169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Bundle) { 13179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Must be before Parcelable 13189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_BUNDLE); 13199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeBundle((Bundle) v); 13209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Parcelable) { 13219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_PARCELABLE); 13229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeParcelable((Parcelable) v, 0); 13239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Short) { 13249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_SHORT); 132571f2cf116aab893e224056c38ab146bd1538dd3eSteve Block writeInt(((Short) v).intValue()); 13269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Long) { 13279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_LONG); 13289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeLong((Long) v); 13299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Float) { 13309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_FLOAT); 13319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeFloat((Float) v); 13329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Double) { 13339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_DOUBLE); 13349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeDouble((Double) v); 13359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Boolean) { 13369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_BOOLEAN); 13379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt((Boolean) v ? 1 : 0); 13389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof CharSequence) { 13399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Must be after String 13409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_CHARSEQUENCE); 13419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeCharSequence((CharSequence) v); 13429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof List) { 13439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_LIST); 13449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeList((List) v); 13459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof SparseArray) { 13469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_SPARSEARRAY); 13479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeSparseArray((SparseArray) v); 13489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof boolean[]) { 13499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_BOOLEANARRAY); 13509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeBooleanArray((boolean[]) v); 13519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof byte[]) { 13529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_BYTEARRAY); 13539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeByteArray((byte[]) v); 13549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof String[]) { 13559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_STRINGARRAY); 13569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeStringArray((String[]) v); 13579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof CharSequence[]) { 13589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // Must be after String[] and before Object[] 13599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_CHARSEQUENCEARRAY); 13609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeCharSequenceArray((CharSequence[]) v); 13619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof IBinder) { 13629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_IBINDER); 13639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeStrongBinder((IBinder) v); 13649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof Parcelable[]) { 13659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_PARCELABLEARRAY); 13669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeParcelableArray((Parcelable[]) v, 0); 13679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } else if (v instanceof int[]) { 13689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project writeInt(VAL_INTARRAY); 1369 writeIntArray((int[]) v); 1370 } else if (v instanceof long[]) { 1371 writeInt(VAL_LONGARRAY); 1372 writeLongArray((long[]) v); 1373 } else if (v instanceof Byte) { 1374 writeInt(VAL_BYTE); 1375 writeInt((Byte) v); 1376 } else if (v instanceof PersistableBundle) { 1377 writeInt(VAL_PERSISTABLEBUNDLE); 1378 writePersistableBundle((PersistableBundle) v); 1379 } else if (v instanceof Size) { 1380 writeInt(VAL_SIZE); 1381 writeSize((Size) v); 1382 } else if (v instanceof SizeF) { 1383 writeInt(VAL_SIZEF); 1384 writeSizeF((SizeF) v); 1385 } else { 1386 Class<?> clazz = v.getClass(); 1387 if (clazz.isArray() && clazz.getComponentType() == Object.class) { 1388 // Only pure Object[] are written here, Other arrays of non-primitive types are 1389 // handled by serialization as this does not record the component type. 1390 writeInt(VAL_OBJECTARRAY); 1391 writeArray((Object[]) v); 1392 } else if (v instanceof Serializable) { 1393 // Must be last 1394 writeInt(VAL_SERIALIZABLE); 1395 writeSerializable((Serializable) v); 1396 } else { 1397 throw new RuntimeException("Parcel: unable to marshal value " + v); 1398 } 1399 } 1400 } 1401 1402 /** 1403 * Flatten the name of the class of the Parcelable and its contents 1404 * into the parcel. 1405 * 1406 * @param p The Parcelable object to be written. 1407 * @param parcelableFlags Contextual flags as per 1408 * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}. 1409 */ 1410 public final void writeParcelable(Parcelable p, int parcelableFlags) { 1411 if (p == null) { 1412 writeString(null); 1413 return; 1414 } 1415 writeParcelableCreator(p); 1416 p.writeToParcel(this, parcelableFlags); 1417 } 1418 1419 /** @hide */ 1420 public final void writeParcelableCreator(Parcelable p) { 1421 String name = p.getClass().getName(); 1422 writeString(name); 1423 } 1424 1425 /** 1426 * Write a generic serializable object in to a Parcel. It is strongly 1427 * recommended that this method be avoided, since the serialization 1428 * overhead is extremely large, and this approach will be much slower than 1429 * using the other approaches to writing data in to a Parcel. 1430 */ 1431 public final void writeSerializable(Serializable s) { 1432 if (s == null) { 1433 writeString(null); 1434 return; 1435 } 1436 String name = s.getClass().getName(); 1437 writeString(name); 1438 1439 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 1440 try { 1441 ObjectOutputStream oos = new ObjectOutputStream(baos); 1442 oos.writeObject(s); 1443 oos.close(); 1444 1445 writeByteArray(baos.toByteArray()); 1446 } catch (IOException ioe) { 1447 throw new RuntimeException("Parcelable encountered " + 1448 "IOException writing serializable object (name = " + name + 1449 ")", ioe); 1450 } 1451 } 1452 1453 /** 1454 * Special function for writing an exception result at the header of 1455 * a parcel, to be used when returning an exception from a transaction. 1456 * Note that this currently only supports a few exception types; any other 1457 * exception will be re-thrown by this function as a RuntimeException 1458 * (to be caught by the system's last-resort exception handling when 1459 * dispatching a transaction). 1460 * 1461 * <p>The supported exception types are: 1462 * <ul> 1463 * <li>{@link BadParcelableException} 1464 * <li>{@link IllegalArgumentException} 1465 * <li>{@link IllegalStateException} 1466 * <li>{@link NullPointerException} 1467 * <li>{@link SecurityException} 1468 * <li>{@link NetworkOnMainThreadException} 1469 * </ul> 1470 * 1471 * @param e The Exception to be written. 1472 * 1473 * @see #writeNoException 1474 * @see #readException 1475 */ 1476 public final void writeException(Exception e) { 1477 int code = 0; 1478 if (e instanceof SecurityException) { 1479 code = EX_SECURITY; 1480 } else if (e instanceof BadParcelableException) { 1481 code = EX_BAD_PARCELABLE; 1482 } else if (e instanceof IllegalArgumentException) { 1483 code = EX_ILLEGAL_ARGUMENT; 1484 } else if (e instanceof NullPointerException) { 1485 code = EX_NULL_POINTER; 1486 } else if (e instanceof IllegalStateException) { 1487 code = EX_ILLEGAL_STATE; 1488 } else if (e instanceof NetworkOnMainThreadException) { 1489 code = EX_NETWORK_MAIN_THREAD; 1490 } else if (e instanceof UnsupportedOperationException) { 1491 code = EX_UNSUPPORTED_OPERATION; 1492 } 1493 writeInt(code); 1494 StrictMode.clearGatheredViolations(); 1495 if (code == 0) { 1496 if (e instanceof RuntimeException) { 1497 throw (RuntimeException) e; 1498 } 1499 throw new RuntimeException(e); 1500 } 1501 writeString(e.getMessage()); 1502 } 1503 1504 /** 1505 * Special function for writing information at the front of the Parcel 1506 * indicating that no exception occurred. 1507 * 1508 * @see #writeException 1509 * @see #readException 1510 */ 1511 public final void writeNoException() { 1512 // Despite the name of this function ("write no exception"), 1513 // it should instead be thought of as "write the RPC response 1514 // header", but because this function name is written out by 1515 // the AIDL compiler, we're not going to rename it. 1516 // 1517 // The response header, in the non-exception case (see also 1518 // writeException above, also called by the AIDL compiler), is 1519 // either a 0 (the default case), or EX_HAS_REPLY_HEADER if 1520 // StrictMode has gathered up violations that have occurred 1521 // during a Binder call, in which case we write out the number 1522 // of violations and their details, serialized, before the 1523 // actual RPC respons data. The receiving end of this is 1524 // readException(), below. 1525 if (StrictMode.hasGatheredViolations()) { 1526 writeInt(EX_HAS_REPLY_HEADER); 1527 final int sizePosition = dataPosition(); 1528 writeInt(0); // total size of fat header, to be filled in later 1529 StrictMode.writeGatheredViolationsToParcel(this); 1530 final int payloadPosition = dataPosition(); 1531 setDataPosition(sizePosition); 1532 writeInt(payloadPosition - sizePosition); // header size 1533 setDataPosition(payloadPosition); 1534 } else { 1535 writeInt(0); 1536 } 1537 } 1538 1539 /** 1540 * Special function for reading an exception result from the header of 1541 * a parcel, to be used after receiving the result of a transaction. This 1542 * will throw the exception for you if it had been written to the Parcel, 1543 * otherwise return and let you read the normal result data from the Parcel. 1544 * 1545 * @see #writeException 1546 * @see #writeNoException 1547 */ 1548 public final void readException() { 1549 int code = readExceptionCode(); 1550 if (code != 0) { 1551 String msg = readString(); 1552 readException(code, msg); 1553 } 1554 } 1555 1556 /** 1557 * Parses the header of a Binder call's response Parcel and 1558 * returns the exception code. Deals with lite or fat headers. 1559 * In the common successful case, this header is generally zero. 1560 * In less common cases, it's a small negative number and will be 1561 * followed by an error string. 1562 * 1563 * This exists purely for android.database.DatabaseUtils and 1564 * insulating it from having to handle fat headers as returned by 1565 * e.g. StrictMode-induced RPC responses. 1566 * 1567 * @hide 1568 */ 1569 public final int readExceptionCode() { 1570 int code = readInt(); 1571 if (code == EX_HAS_REPLY_HEADER) { 1572 int headerSize = readInt(); 1573 if (headerSize == 0) { 1574 Log.e(TAG, "Unexpected zero-sized Parcel reply header."); 1575 } else { 1576 // Currently the only thing in the header is StrictMode stacks, 1577 // but discussions around event/RPC tracing suggest we might 1578 // put that here too. If so, switch on sub-header tags here. 1579 // But for now, just parse out the StrictMode stuff. 1580 StrictMode.readAndHandleBinderCallViolations(this); 1581 } 1582 // And fat response headers are currently only used when 1583 // there are no exceptions, so return no error: 1584 return 0; 1585 } 1586 return code; 1587 } 1588 1589 /** 1590 * Throw an exception with the given message. Not intended for use 1591 * outside the Parcel class. 1592 * 1593 * @param code Used to determine which exception class to throw. 1594 * @param msg The exception message. 1595 */ 1596 public final void readException(int code, String msg) { 1597 switch (code) { 1598 case EX_SECURITY: 1599 throw new SecurityException(msg); 1600 case EX_BAD_PARCELABLE: 1601 throw new BadParcelableException(msg); 1602 case EX_ILLEGAL_ARGUMENT: 1603 throw new IllegalArgumentException(msg); 1604 case EX_NULL_POINTER: 1605 throw new NullPointerException(msg); 1606 case EX_ILLEGAL_STATE: 1607 throw new IllegalStateException(msg); 1608 case EX_NETWORK_MAIN_THREAD: 1609 throw new NetworkOnMainThreadException(); 1610 case EX_UNSUPPORTED_OPERATION: 1611 throw new UnsupportedOperationException(msg); 1612 } 1613 throw new RuntimeException("Unknown exception code: " + code 1614 + " msg " + msg); 1615 } 1616 1617 /** 1618 * Read an integer value from the parcel at the current dataPosition(). 1619 */ 1620 public final int readInt() { 1621 return nativeReadInt(mNativePtr); 1622 } 1623 1624 /** 1625 * Read a long integer value from the parcel at the current dataPosition(). 1626 */ 1627 public final long readLong() { 1628 return nativeReadLong(mNativePtr); 1629 } 1630 1631 /** 1632 * Read a floating point value from the parcel at the current 1633 * dataPosition(). 1634 */ 1635 public final float readFloat() { 1636 return nativeReadFloat(mNativePtr); 1637 } 1638 1639 /** 1640 * Read a double precision floating point value from the parcel at the 1641 * current dataPosition(). 1642 */ 1643 public final double readDouble() { 1644 return nativeReadDouble(mNativePtr); 1645 } 1646 1647 /** 1648 * Read a string value from the parcel at the current dataPosition(). 1649 */ 1650 public final String readString() { 1651 return nativeReadString(mNativePtr); 1652 } 1653 1654 /** 1655 * Read a CharSequence value from the parcel at the current dataPosition(). 1656 * @hide 1657 */ 1658 public final CharSequence readCharSequence() { 1659 return TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(this); 1660 } 1661 1662 /** 1663 * Read an object from the parcel at the current dataPosition(). 1664 */ 1665 public final IBinder readStrongBinder() { 1666 return nativeReadStrongBinder(mNativePtr); 1667 } 1668 1669 /** 1670 * Read a FileDescriptor from the parcel at the current dataPosition(). 1671 */ 1672 public final ParcelFileDescriptor readFileDescriptor() { 1673 FileDescriptor fd = nativeReadFileDescriptor(mNativePtr); 1674 return fd != null ? new ParcelFileDescriptor(fd) : null; 1675 } 1676 1677 /** {@hide} */ 1678 public final FileDescriptor readRawFileDescriptor() { 1679 return nativeReadFileDescriptor(mNativePtr); 1680 } 1681 1682 /*package*/ static native FileDescriptor openFileDescriptor(String file, 1683 int mode) throws FileNotFoundException; 1684 /*package*/ static native FileDescriptor dupFileDescriptor(FileDescriptor orig) 1685 throws IOException; 1686 /*package*/ static native void closeFileDescriptor(FileDescriptor desc) 1687 throws IOException; 1688 /*package*/ static native void clearFileDescriptor(FileDescriptor desc); 1689 1690 /** 1691 * Read a byte value from the parcel at the current dataPosition(). 1692 */ 1693 public final byte readByte() { 1694 return (byte)(readInt() & 0xff); 1695 } 1696 1697 /** 1698 * Please use {@link #readBundle(ClassLoader)} instead (whose data must have 1699 * been written with {@link #writeBundle}. Read into an existing Map object 1700 * from the parcel at the current dataPosition(). 1701 */ 1702 public final void readMap(Map outVal, ClassLoader loader) { 1703 int N = readInt(); 1704 readMapInternal(outVal, N, loader); 1705 } 1706 1707 /** 1708 * Read into an existing List object from the parcel at the current 1709 * dataPosition(), using the given class loader to load any enclosed 1710 * Parcelables. If it is null, the default class loader is used. 1711 */ 1712 public final void readList(List outVal, ClassLoader loader) { 1713 int N = readInt(); 1714 readListInternal(outVal, N, loader); 1715 } 1716 1717 /** 1718 * Please use {@link #readBundle(ClassLoader)} instead (whose data must have 1719 * been written with {@link #writeBundle}. Read and return a new HashMap 1720 * object from the parcel at the current dataPosition(), using the given 1721 * class loader to load any enclosed Parcelables. Returns null if 1722 * the previously written map object was null. 1723 */ 1724 public final HashMap readHashMap(ClassLoader loader) 1725 { 1726 int N = readInt(); 1727 if (N < 0) { 1728 return null; 1729 } 1730 HashMap m = new HashMap(N); 1731 readMapInternal(m, N, loader); 1732 return m; 1733 } 1734 1735 /** 1736 * Read and return a new Bundle object from the parcel at the current 1737 * dataPosition(). Returns null if the previously written Bundle object was 1738 * null. 1739 */ 1740 public final Bundle readBundle() { 1741 return readBundle(null); 1742 } 1743 1744 /** 1745 * Read and return a new Bundle object from the parcel at the current 1746 * dataPosition(), using the given class loader to initialize the class 1747 * loader of the Bundle for later retrieval of Parcelable objects. 1748 * Returns null if the previously written Bundle object was null. 1749 */ 1750 public final Bundle readBundle(ClassLoader loader) { 1751 int length = readInt(); 1752 if (length < 0) { 1753 if (Bundle.DEBUG) Log.d(TAG, "null bundle: length=" + length); 1754 return null; 1755 } 1756 1757 final Bundle bundle = new Bundle(this, length); 1758 if (loader != null) { 1759 bundle.setClassLoader(loader); 1760 } 1761 return bundle; 1762 } 1763 1764 /** 1765 * Read and return a new Bundle object from the parcel at the current 1766 * dataPosition(). Returns null if the previously written Bundle object was 1767 * null. 1768 */ 1769 public final PersistableBundle readPersistableBundle() { 1770 return readPersistableBundle(null); 1771 } 1772 1773 /** 1774 * Read and return a new Bundle object from the parcel at the current 1775 * dataPosition(), using the given class loader to initialize the class 1776 * loader of the Bundle for later retrieval of Parcelable objects. 1777 * Returns null if the previously written Bundle object was null. 1778 */ 1779 public final PersistableBundle readPersistableBundle(ClassLoader loader) { 1780 int length = readInt(); 1781 if (length < 0) { 1782 if (Bundle.DEBUG) Log.d(TAG, "null bundle: length=" + length); 1783 return null; 1784 } 1785 1786 final PersistableBundle bundle = new PersistableBundle(this, length); 1787 if (loader != null) { 1788 bundle.setClassLoader(loader); 1789 } 1790 return bundle; 1791 } 1792 1793 /** 1794 * Read a Size from the parcel at the current dataPosition(). 1795 */ 1796 public final Size readSize() { 1797 final int width = readInt(); 1798 final int height = readInt(); 1799 return new Size(width, height); 1800 } 1801 1802 /** 1803 * Read a SizeF from the parcel at the current dataPosition(). 1804 */ 1805 public final SizeF readSizeF() { 1806 final float width = readFloat(); 1807 final float height = readFloat(); 1808 return new SizeF(width, height); 1809 } 1810 1811 /** 1812 * Read and return a byte[] object from the parcel. 1813 */ 1814 public final byte[] createByteArray() { 1815 return nativeCreateByteArray(mNativePtr); 1816 } 1817 1818 /** 1819 * Read a byte[] object from the parcel and copy it into the 1820 * given byte array. 1821 */ 1822 public final void readByteArray(byte[] val) { 1823 // TODO: make this a native method to avoid the extra copy. 1824 byte[] ba = createByteArray(); 1825 if (ba.length == val.length) { 1826 System.arraycopy(ba, 0, val, 0, ba.length); 1827 } else { 1828 throw new RuntimeException("bad array lengths"); 1829 } 1830 } 1831 1832 /** 1833 * Read a blob of data from the parcel and return it as a byte array. 1834 * {@hide} 1835 * {@SystemApi} 1836 */ 1837 public final byte[] readBlob() { 1838 return nativeReadBlob(mNativePtr); 1839 } 1840 1841 /** 1842 * Read and return a String[] object from the parcel. 1843 * {@hide} 1844 */ 1845 public final String[] readStringArray() { 1846 String[] array = null; 1847 1848 int length = readInt(); 1849 if (length >= 0) 1850 { 1851 array = new String[length]; 1852 1853 for (int i = 0 ; i < length ; i++) 1854 { 1855 array[i] = readString(); 1856 } 1857 } 1858 1859 return array; 1860 } 1861 1862 /** 1863 * Read and return a CharSequence[] object from the parcel. 1864 * {@hide} 1865 */ 1866 public final CharSequence[] readCharSequenceArray() { 1867 CharSequence[] array = null; 1868 1869 int length = readInt(); 1870 if (length >= 0) 1871 { 1872 array = new CharSequence[length]; 1873 1874 for (int i = 0 ; i < length ; i++) 1875 { 1876 array[i] = readCharSequence(); 1877 } 1878 } 1879 1880 return array; 1881 } 1882 1883 /** 1884 * Read and return an ArrayList<CharSequence> object from the parcel. 1885 * {@hide} 1886 */ 1887 public final ArrayList<CharSequence> readCharSequenceList() { 1888 ArrayList<CharSequence> array = null; 1889 1890 int length = readInt(); 1891 if (length >= 0) { 1892 array = new ArrayList<CharSequence>(length); 1893 1894 for (int i = 0 ; i < length ; i++) { 1895 array.add(readCharSequence()); 1896 } 1897 } 1898 1899 return array; 1900 } 1901 1902 /** 1903 * Read and return a new ArrayList object from the parcel at the current 1904 * dataPosition(). Returns null if the previously written list object was 1905 * null. The given class loader will be used to load any enclosed 1906 * Parcelables. 1907 */ 1908 public final ArrayList readArrayList(ClassLoader loader) { 1909 int N = readInt(); 1910 if (N < 0) { 1911 return null; 1912 } 1913 ArrayList l = new ArrayList(N); 1914 readListInternal(l, N, loader); 1915 return l; 1916 } 1917 1918 /** 1919 * Read and return a new Object array from the parcel at the current 1920 * dataPosition(). Returns null if the previously written array was 1921 * null. The given class loader will be used to load any enclosed 1922 * Parcelables. 1923 */ 1924 public final Object[] readArray(ClassLoader loader) { 1925 int N = readInt(); 1926 if (N < 0) { 1927 return null; 1928 } 1929 Object[] l = new Object[N]; 1930 readArrayInternal(l, N, loader); 1931 return l; 1932 } 1933 1934 /** 1935 * Read and return a new SparseArray object from the parcel at the current 1936 * dataPosition(). Returns null if the previously written list object was 1937 * null. The given class loader will be used to load any enclosed 1938 * Parcelables. 1939 */ 1940 public final SparseArray readSparseArray(ClassLoader loader) { 1941 int N = readInt(); 1942 if (N < 0) { 1943 return null; 1944 } 1945 SparseArray sa = new SparseArray(N); 1946 readSparseArrayInternal(sa, N, loader); 1947 return sa; 1948 } 1949 1950 /** 1951 * Read and return a new SparseBooleanArray object from the parcel at the current 1952 * dataPosition(). Returns null if the previously written list object was 1953 * null. 1954 */ 1955 public final SparseBooleanArray readSparseBooleanArray() { 1956 int N = readInt(); 1957 if (N < 0) { 1958 return null; 1959 } 1960 SparseBooleanArray sa = new SparseBooleanArray(N); 1961 readSparseBooleanArrayInternal(sa, N); 1962 return sa; 1963 } 1964 1965 /** 1966 * Read and return a new ArrayList containing a particular object type from 1967 * the parcel that was written with {@link #writeTypedList} at the 1968 * current dataPosition(). Returns null if the 1969 * previously written list object was null. The list <em>must</em> have 1970 * previously been written via {@link #writeTypedList} with the same object 1971 * type. 1972 * 1973 * @return A newly created ArrayList containing objects with the same data 1974 * as those that were previously written. 1975 * 1976 * @see #writeTypedList 1977 */ 1978 public final <T> ArrayList<T> createTypedArrayList(Parcelable.Creator<T> c) { 1979 int N = readInt(); 1980 if (N < 0) { 1981 return null; 1982 } 1983 ArrayList<T> l = new ArrayList<T>(N); 1984 while (N > 0) { 1985 if (readInt() != 0) { 1986 l.add(c.createFromParcel(this)); 1987 } else { 1988 l.add(null); 1989 } 1990 N--; 1991 } 1992 return l; 1993 } 1994 1995 /** 1996 * Read into the given List items containing a particular object type 1997 * that were written with {@link #writeTypedList} at the 1998 * current dataPosition(). The list <em>must</em> have 1999 * previously been written via {@link #writeTypedList} with the same object 2000 * type. 2001 * 2002 * @return A newly created ArrayList containing objects with the same data 2003 * as those that were previously written. 2004 * 2005 * @see #writeTypedList 2006 */ 2007 public final <T> void readTypedList(List<T> list, Parcelable.Creator<T> c) { 2008 int M = list.size(); 2009 int N = readInt(); 2010 int i = 0; 2011 for (; i < M && i < N; i++) { 2012 if (readInt() != 0) { 2013 list.set(i, c.createFromParcel(this)); 2014 } else { 2015 list.set(i, null); 2016 } 2017 } 2018 for (; i<N; i++) { 2019 if (readInt() != 0) { 2020 list.add(c.createFromParcel(this)); 2021 } else { 2022 list.add(null); 2023 } 2024 } 2025 for (; i<M; i++) { 2026 list.remove(N); 2027 } 2028 } 2029 2030 /** 2031 * Read and return a new ArrayList containing String objects from 2032 * the parcel that was written with {@link #writeStringList} at the 2033 * current dataPosition(). Returns null if the 2034 * previously written list object was null. 2035 * 2036 * @return A newly created ArrayList containing strings with the same data 2037 * as those that were previously written. 2038 * 2039 * @see #writeStringList 2040 */ 2041 public final ArrayList<String> createStringArrayList() { 2042 int N = readInt(); 2043 if (N < 0) { 2044 return null; 2045 } 2046 ArrayList<String> l = new ArrayList<String>(N); 2047 while (N > 0) { 2048 l.add(readString()); 2049 N--; 2050 } 2051 return l; 2052 } 2053 2054 /** 2055 * Read and return a new ArrayList containing IBinder objects from 2056 * the parcel that was written with {@link #writeBinderList} at the 2057 * current dataPosition(). Returns null if the 2058 * previously written list object was null. 2059 * 2060 * @return A newly created ArrayList containing strings with the same data 2061 * as those that were previously written. 2062 * 2063 * @see #writeBinderList 2064 */ 2065 public final ArrayList<IBinder> createBinderArrayList() { 2066 int N = readInt(); 2067 if (N < 0) { 2068 return null; 2069 } 2070 ArrayList<IBinder> l = new ArrayList<IBinder>(N); 2071 while (N > 0) { 2072 l.add(readStrongBinder()); 2073 N--; 2074 } 2075 return l; 2076 } 2077 2078 /** 2079 * Read into the given List items String objects that were written with 2080 * {@link #writeStringList} at the current dataPosition(). 2081 * 2082 * @return A newly created ArrayList containing strings with the same data 2083 * as those that were previously written. 2084 * 2085 * @see #writeStringList 2086 */ 2087 public final void readStringList(List<String> list) { 2088 int M = list.size(); 2089 int N = readInt(); 2090 int i = 0; 2091 for (; i < M && i < N; i++) { 2092 list.set(i, readString()); 2093 } 2094 for (; i<N; i++) { 2095 list.add(readString()); 2096 } 2097 for (; i<M; i++) { 2098 list.remove(N); 2099 } 2100 } 2101 2102 /** 2103 * Read into the given List items IBinder objects that were written with 2104 * {@link #writeBinderList} at the current dataPosition(). 2105 * 2106 * @return A newly created ArrayList containing strings with the same data 2107 * as those that were previously written. 2108 * 2109 * @see #writeBinderList 2110 */ 2111 public final void readBinderList(List<IBinder> list) { 2112 int M = list.size(); 2113 int N = readInt(); 2114 int i = 0; 2115 for (; i < M && i < N; i++) { 2116 list.set(i, readStrongBinder()); 2117 } 2118 for (; i<N; i++) { 2119 list.add(readStrongBinder()); 2120 } 2121 for (; i<M; i++) { 2122 list.remove(N); 2123 } 2124 } 2125 2126 /** 2127 * Read and return a new array containing a particular object type from 2128 * the parcel at the current dataPosition(). Returns null if the 2129 * previously written array was null. The array <em>must</em> have 2130 * previously been written via {@link #writeTypedArray} with the same 2131 * object type. 2132 * 2133 * @return A newly created array containing objects with the same data 2134 * as those that were previously written. 2135 * 2136 * @see #writeTypedArray 2137 */ 2138 public final <T> T[] createTypedArray(Parcelable.Creator<T> c) { 2139 int N = readInt(); 2140 if (N < 0) { 2141 return null; 2142 } 2143 T[] l = c.newArray(N); 2144 for (int i=0; i<N; i++) { 2145 if (readInt() != 0) { 2146 l[i] = c.createFromParcel(this); 2147 } 2148 } 2149 return l; 2150 } 2151 2152 public final <T> void readTypedArray(T[] val, Parcelable.Creator<T> c) { 2153 int N = readInt(); 2154 if (N == val.length) { 2155 for (int i=0; i<N; i++) { 2156 if (readInt() != 0) { 2157 val[i] = c.createFromParcel(this); 2158 } else { 2159 val[i] = null; 2160 } 2161 } 2162 } else { 2163 throw new RuntimeException("bad array lengths"); 2164 } 2165 } 2166 2167 /** 2168 * @deprecated 2169 * @hide 2170 */ 2171 @Deprecated 2172 public final <T> T[] readTypedArray(Parcelable.Creator<T> c) { 2173 return createTypedArray(c); 2174 } 2175 2176 /** 2177 * Read and return a typed Parcelable object from a parcel. 2178 * Returns null if the previous written object was null. 2179 * The object <em>must</em> have previous been written via 2180 * {@link #writeTypedObject} with the same object type. 2181 * 2182 * @return A newly created object of the type that was previously 2183 * written. 2184 * 2185 * @see #writeTypedObject 2186 */ 2187 public final <T> T readTypedObject(Parcelable.Creator<T> c) { 2188 if (readInt() != 0) { 2189 return c.createFromParcel(this); 2190 } else { 2191 return null; 2192 } 2193 } 2194 2195 /** 2196 * Write a heterogeneous array of Parcelable objects into the Parcel. 2197 * Each object in the array is written along with its class name, so 2198 * that the correct class can later be instantiated. As a result, this 2199 * has significantly more overhead than {@link #writeTypedArray}, but will 2200 * correctly handle an array containing more than one type of object. 2201 * 2202 * @param value The array of objects to be written. 2203 * @param parcelableFlags Contextual flags as per 2204 * {@link Parcelable#writeToParcel(Parcel, int) Parcelable.writeToParcel()}. 2205 * 2206 * @see #writeTypedArray 2207 */ 2208 public final <T extends Parcelable> void writeParcelableArray(T[] value, 2209 int parcelableFlags) { 2210 if (value != null) { 2211 int N = value.length; 2212 writeInt(N); 2213 for (int i=0; i<N; i++) { 2214 writeParcelable(value[i], parcelableFlags); 2215 } 2216 } else { 2217 writeInt(-1); 2218 } 2219 } 2220 2221 /** 2222 * Read a typed object from a parcel. The given class loader will be 2223 * used to load any enclosed Parcelables. If it is null, the default class 2224 * loader will be used. 2225 */ 2226 public final Object readValue(ClassLoader loader) { 2227 int type = readInt(); 2228 2229 switch (type) { 2230 case VAL_NULL: 2231 return null; 2232 2233 case VAL_STRING: 2234 return readString(); 2235 2236 case VAL_INTEGER: 2237 return readInt(); 2238 2239 case VAL_MAP: 2240 return readHashMap(loader); 2241 2242 case VAL_PARCELABLE: 2243 return readParcelable(loader); 2244 2245 case VAL_SHORT: 2246 return (short) readInt(); 2247 2248 case VAL_LONG: 2249 return readLong(); 2250 2251 case VAL_FLOAT: 2252 return readFloat(); 2253 2254 case VAL_DOUBLE: 2255 return readDouble(); 2256 2257 case VAL_BOOLEAN: 2258 return readInt() == 1; 2259 2260 case VAL_CHARSEQUENCE: 2261 return readCharSequence(); 2262 2263 case VAL_LIST: 2264 return readArrayList(loader); 2265 2266 case VAL_BOOLEANARRAY: 2267 return createBooleanArray(); 2268 2269 case VAL_BYTEARRAY: 2270 return createByteArray(); 2271 2272 case VAL_STRINGARRAY: 2273 return readStringArray(); 2274 2275 case VAL_CHARSEQUENCEARRAY: 2276 return readCharSequenceArray(); 2277 2278 case VAL_IBINDER: 2279 return readStrongBinder(); 2280 2281 case VAL_OBJECTARRAY: 2282 return readArray(loader); 2283 2284 case VAL_INTARRAY: 2285 return createIntArray(); 2286 2287 case VAL_LONGARRAY: 2288 return createLongArray(); 2289 2290 case VAL_BYTE: 2291 return readByte(); 2292 2293 case VAL_SERIALIZABLE: 2294 return readSerializable(loader); 2295 2296 case VAL_PARCELABLEARRAY: 2297 return readParcelableArray(loader); 2298 2299 case VAL_SPARSEARRAY: 2300 return readSparseArray(loader); 2301 2302 case VAL_SPARSEBOOLEANARRAY: 2303 return readSparseBooleanArray(); 2304 2305 case VAL_BUNDLE: 2306 return readBundle(loader); // loading will be deferred 2307 2308 case VAL_PERSISTABLEBUNDLE: 2309 return readPersistableBundle(loader); 2310 2311 case VAL_SIZE: 2312 return readSize(); 2313 2314 case VAL_SIZEF: 2315 return readSizeF(); 2316 2317 default: 2318 int off = dataPosition() - 4; 2319 throw new RuntimeException( 2320 "Parcel " + this + ": Unmarshalling unknown type code " + type + " at offset " + off); 2321 } 2322 } 2323 2324 /** 2325 * Read and return a new Parcelable from the parcel. The given class loader 2326 * will be used to load any enclosed Parcelables. If it is null, the default 2327 * class loader will be used. 2328 * @param loader A ClassLoader from which to instantiate the Parcelable 2329 * object, or null for the default class loader. 2330 * @return Returns the newly created Parcelable, or null if a null 2331 * object has been written. 2332 * @throws BadParcelableException Throws BadParcelableException if there 2333 * was an error trying to instantiate the Parcelable. 2334 */ 2335 @SuppressWarnings("unchecked") 2336 public final <T extends Parcelable> T readParcelable(ClassLoader loader) { 2337 Parcelable.Creator<?> creator = readParcelableCreator(loader); 2338 if (creator == null) { 2339 return null; 2340 } 2341 if (creator instanceof Parcelable.ClassLoaderCreator<?>) { 2342 Parcelable.ClassLoaderCreator<?> classLoaderCreator = 2343 (Parcelable.ClassLoaderCreator<?>) creator; 2344 return (T) classLoaderCreator.createFromParcel(this, loader); 2345 } 2346 return (T) creator.createFromParcel(this); 2347 } 2348 2349 /** @hide */ 2350 @SuppressWarnings("unchecked") 2351 public final <T extends Parcelable> T readCreator(Parcelable.Creator<?> creator, 2352 ClassLoader loader) { 2353 if (creator instanceof Parcelable.ClassLoaderCreator<?>) { 2354 Parcelable.ClassLoaderCreator<?> classLoaderCreator = 2355 (Parcelable.ClassLoaderCreator<?>) creator; 2356 return (T) classLoaderCreator.createFromParcel(this, loader); 2357 } 2358 return (T) creator.createFromParcel(this); 2359 } 2360 2361 /** @hide */ 2362 public final Parcelable.Creator<?> readParcelableCreator(ClassLoader loader) { 2363 String name = readString(); 2364 if (name == null) { 2365 return null; 2366 } 2367 Parcelable.Creator<?> creator; 2368 synchronized (mCreators) { 2369 HashMap<String,Parcelable.Creator<?>> map = mCreators.get(loader); 2370 if (map == null) { 2371 map = new HashMap<>(); 2372 mCreators.put(loader, map); 2373 } 2374 creator = map.get(name); 2375 if (creator == null) { 2376 try { 2377 // If loader == null, explicitly emulate Class.forName(String) "caller 2378 // classloader" behavior. 2379 ClassLoader parcelableClassLoader = 2380 (loader == null ? getClass().getClassLoader() : loader); 2381 // Avoid initializing the Parcelable class until we know it implements 2382 // Parcelable and has the necessary CREATOR field. http://b/1171613. 2383 Class<?> parcelableClass = Class.forName(name, false /* initialize */, 2384 parcelableClassLoader); 2385 if (!Parcelable.class.isAssignableFrom(parcelableClass)) { 2386 throw new BadParcelableException("Parcelable protocol requires that the " 2387 + "class implements Parcelable"); 2388 } 2389 Field f = parcelableClass.getField("CREATOR"); 2390 if ((f.getModifiers() & Modifier.STATIC) == 0) { 2391 throw new BadParcelableException("Parcelable protocol requires " 2392 + "the CREATOR object to be static on class " + name); 2393 } 2394 Class<?> creatorType = f.getType(); 2395 if (!Parcelable.Creator.class.isAssignableFrom(creatorType)) { 2396 // Fail before calling Field.get(), not after, to avoid initializing 2397 // parcelableClass unnecessarily. 2398 throw new BadParcelableException("Parcelable protocol requires a " 2399 + "Parcelable.Creator object called " 2400 + "CREATOR on class " + name); 2401 } 2402 creator = (Parcelable.Creator<?>) f.get(null); 2403 } 2404 catch (IllegalAccessException e) { 2405 Log.e(TAG, "Illegal access when unmarshalling: " + name, e); 2406 throw new BadParcelableException( 2407 "IllegalAccessException when unmarshalling: " + name); 2408 } 2409 catch (ClassNotFoundException e) { 2410 Log.e(TAG, "Class not found when unmarshalling: " + name, e); 2411 throw new BadParcelableException( 2412 "ClassNotFoundException when unmarshalling: " + name); 2413 } 2414 catch (NoSuchFieldException e) { 2415 throw new BadParcelableException("Parcelable protocol requires a " 2416 + "Parcelable.Creator object called " 2417 + "CREATOR on class " + name); 2418 } 2419 if (creator == null) { 2420 throw new BadParcelableException("Parcelable protocol requires a " 2421 + "non-null Parcelable.Creator object called " 2422 + "CREATOR on class " + name); 2423 } 2424 2425 map.put(name, creator); 2426 } 2427 } 2428 2429 return creator; 2430 } 2431 2432 /** 2433 * Read and return a new Parcelable array from the parcel. 2434 * The given class loader will be used to load any enclosed 2435 * Parcelables. 2436 * @return the Parcelable array, or null if the array is null 2437 */ 2438 public final Parcelable[] readParcelableArray(ClassLoader loader) { 2439 int N = readInt(); 2440 if (N < 0) { 2441 return null; 2442 } 2443 Parcelable[] p = new Parcelable[N]; 2444 for (int i = 0; i < N; i++) { 2445 p[i] = readParcelable(loader); 2446 } 2447 return p; 2448 } 2449 2450 /** 2451 * Read and return a new Serializable object from the parcel. 2452 * @return the Serializable object, or null if the Serializable name 2453 * wasn't found in the parcel. 2454 */ 2455 public final Serializable readSerializable() { 2456 return readSerializable(null); 2457 } 2458 2459 private final Serializable readSerializable(final ClassLoader loader) { 2460 String name = readString(); 2461 if (name == null) { 2462 // For some reason we were unable to read the name of the Serializable (either there 2463 // is nothing left in the Parcel to read, or the next value wasn't a String), so 2464 // return null, which indicates that the name wasn't found in the parcel. 2465 return null; 2466 } 2467 2468 byte[] serializedData = createByteArray(); 2469 ByteArrayInputStream bais = new ByteArrayInputStream(serializedData); 2470 try { 2471 ObjectInputStream ois = new ObjectInputStream(bais) { 2472 @Override 2473 protected Class<?> resolveClass(ObjectStreamClass osClass) 2474 throws IOException, ClassNotFoundException { 2475 // try the custom classloader if provided 2476 if (loader != null) { 2477 Class<?> c = Class.forName(osClass.getName(), false, loader); 2478 if (c != null) { 2479 return c; 2480 } 2481 } 2482 return super.resolveClass(osClass); 2483 } 2484 }; 2485 return (Serializable) ois.readObject(); 2486 } catch (IOException ioe) { 2487 throw new RuntimeException("Parcelable encountered " + 2488 "IOException reading a Serializable object (name = " + name + 2489 ")", ioe); 2490 } catch (ClassNotFoundException cnfe) { 2491 throw new RuntimeException("Parcelable encountered " + 2492 "ClassNotFoundException reading a Serializable object (name = " 2493 + name + ")", cnfe); 2494 } 2495 } 2496 2497 // Cache of previously looked up CREATOR.createFromParcel() methods for 2498 // particular classes. Keys are the names of the classes, values are 2499 // Method objects. 2500 private static final HashMap<ClassLoader,HashMap<String,Parcelable.Creator<?>>> 2501 mCreators = new HashMap<>(); 2502 2503 /** @hide for internal use only. */ 2504 static protected final Parcel obtain(int obj) { 2505 throw new UnsupportedOperationException(); 2506 } 2507 2508 /** @hide */ 2509 static protected final Parcel obtain(long obj) { 2510 final Parcel[] pool = sHolderPool; 2511 synchronized (pool) { 2512 Parcel p; 2513 for (int i=0; i<POOL_SIZE; i++) { 2514 p = pool[i]; 2515 if (p != null) { 2516 pool[i] = null; 2517 if (DEBUG_RECYCLE) { 2518 p.mStack = new RuntimeException(); 2519 } 2520 p.init(obj); 2521 return p; 2522 } 2523 } 2524 } 2525 return new Parcel(obj); 2526 } 2527 2528 private Parcel(long nativePtr) { 2529 if (DEBUG_RECYCLE) { 2530 mStack = new RuntimeException(); 2531 } 2532 //Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack); 2533 init(nativePtr); 2534 } 2535 2536 private void init(long nativePtr) { 2537 if (nativePtr != 0) { 2538 mNativePtr = nativePtr; 2539 mOwnsNativeParcelObject = false; 2540 } else { 2541 mNativePtr = nativeCreate(); 2542 mOwnsNativeParcelObject = true; 2543 } 2544 } 2545 2546 private void freeBuffer() { 2547 if (mOwnsNativeParcelObject) { 2548 nativeFreeBuffer(mNativePtr); 2549 } 2550 } 2551 2552 private void destroy() { 2553 if (mNativePtr != 0) { 2554 if (mOwnsNativeParcelObject) { 2555 nativeDestroy(mNativePtr); 2556 } 2557 mNativePtr = 0; 2558 } 2559 } 2560 2561 @Override 2562 protected void finalize() throws Throwable { 2563 if (DEBUG_RECYCLE) { 2564 if (mStack != null) { 2565 Log.w(TAG, "Client did not call Parcel.recycle()", mStack); 2566 } 2567 } 2568 destroy(); 2569 } 2570 2571 /* package */ void readMapInternal(Map outVal, int N, 2572 ClassLoader loader) { 2573 while (N > 0) { 2574 Object key = readValue(loader); 2575 Object value = readValue(loader); 2576 outVal.put(key, value); 2577 N--; 2578 } 2579 } 2580 2581 /* package */ void readArrayMapInternal(ArrayMap outVal, int N, 2582 ClassLoader loader) { 2583 if (DEBUG_ARRAY_MAP) { 2584 RuntimeException here = new RuntimeException("here"); 2585 here.fillInStackTrace(); 2586 Log.d(TAG, "Reading " + N + " ArrayMap entries", here); 2587 } 2588 int startPos; 2589 while (N > 0) { 2590 if (DEBUG_ARRAY_MAP) startPos = dataPosition(); 2591 String key = readString(); 2592 Object value = readValue(loader); 2593 if (DEBUG_ARRAY_MAP) Log.d(TAG, " Read #" + (N-1) + " " 2594 + (dataPosition()-startPos) + " bytes: key=0x" 2595 + Integer.toHexString((key != null ? key.hashCode() : 0)) + " " + key); 2596 outVal.append(key, value); 2597 N--; 2598 } 2599 outVal.validate(); 2600 } 2601 2602 /* package */ void readArrayMapSafelyInternal(ArrayMap outVal, int N, 2603 ClassLoader loader) { 2604 if (DEBUG_ARRAY_MAP) { 2605 RuntimeException here = new RuntimeException("here"); 2606 here.fillInStackTrace(); 2607 Log.d(TAG, "Reading safely " + N + " ArrayMap entries", here); 2608 } 2609 while (N > 0) { 2610 String key = readString(); 2611 if (DEBUG_ARRAY_MAP) Log.d(TAG, " Read safe #" + (N-1) + ": key=0x" 2612 + (key != null ? key.hashCode() : 0) + " " + key); 2613 Object value = readValue(loader); 2614 outVal.put(key, value); 2615 N--; 2616 } 2617 } 2618 2619 /** 2620 * @hide For testing only. 2621 */ 2622 public void readArrayMap(ArrayMap outVal, ClassLoader loader) { 2623 final int N = readInt(); 2624 if (N < 0) { 2625 return; 2626 } 2627 readArrayMapInternal(outVal, N, loader); 2628 } 2629 2630 private void readListInternal(List outVal, int N, 2631 ClassLoader loader) { 2632 while (N > 0) { 2633 Object value = readValue(loader); 2634 //Log.d(TAG, "Unmarshalling value=" + value); 2635 outVal.add(value); 2636 N--; 2637 } 2638 } 2639 2640 private void readArrayInternal(Object[] outVal, int N, 2641 ClassLoader loader) { 2642 for (int i = 0; i < N; i++) { 2643 Object value = readValue(loader); 2644 //Log.d(TAG, "Unmarshalling value=" + value); 2645 outVal[i] = value; 2646 } 2647 } 2648 2649 private void readSparseArrayInternal(SparseArray outVal, int N, 2650 ClassLoader loader) { 2651 while (N > 0) { 2652 int key = readInt(); 2653 Object value = readValue(loader); 2654 //Log.i(TAG, "Unmarshalling key=" + key + " value=" + value); 2655 outVal.append(key, value); 2656 N--; 2657 } 2658 } 2659 2660 2661 private void readSparseBooleanArrayInternal(SparseBooleanArray outVal, int N) { 2662 while (N > 0) { 2663 int key = readInt(); 2664 boolean value = this.readByte() == 1; 2665 //Log.i(TAG, "Unmarshalling key=" + key + " value=" + value); 2666 outVal.append(key, value); 2667 N--; 2668 } 2669 } 2670 2671 /** 2672 * @hide For testing 2673 */ 2674 public long getBlobAshmemSize() { 2675 return nativeGetBlobAshmemSize(mNativePtr); 2676 } 2677} 2678