mirror of
https://github.com/github/codeql.git
synced 2025-12-17 17:23:36 +01:00
671 lines
20 KiB
Java
671 lines
20 KiB
Java
/*
|
|
* Copyright (C) 2006 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package android.os;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.FileDescriptor;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.ObjectStreamClass;
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
public final class Parcel {
|
|
|
|
/**
|
|
* Retrieve a new Parcel object from the pool.
|
|
*/
|
|
public static Parcel obtain() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Write a byte array into the parcel at the current {@link #dataPosition},
|
|
* growing {@link #dataCapacity} if needed.
|
|
*
|
|
* @param b Bytes to place into the parcel.
|
|
*/
|
|
public final void writeByteArray(byte[] b) {
|
|
}
|
|
|
|
/**
|
|
* Write a byte array into the parcel at the current {@link #dataPosition},
|
|
* growing {@link #dataCapacity} if needed.
|
|
*
|
|
* @param b Bytes to place into the parcel.
|
|
* @param offset Index of first byte to be written.
|
|
* @param len Number of bytes to write.
|
|
*/
|
|
public final void writeByteArray(byte[] b, int offset, int len) {
|
|
}
|
|
|
|
/**
|
|
* Write a blob of data into the parcel at the current {@link #dataPosition},
|
|
* growing {@link #dataCapacity} if needed.
|
|
*
|
|
* @param b Bytes to place into the parcel. {@hide} {@SystemApi}
|
|
*/
|
|
public final void writeBlob(byte[] b) {
|
|
}
|
|
|
|
/**
|
|
* Write a blob of data into the parcel at the current {@link #dataPosition},
|
|
* growing {@link #dataCapacity} if needed.
|
|
*
|
|
* @param b Bytes to place into the parcel.
|
|
* @param offset Index of first byte to be written.
|
|
* @param len Number of bytes to write. {@hide} {@SystemApi}
|
|
*/
|
|
public final void writeBlob(byte[] b, int offset, int len) {
|
|
}
|
|
|
|
/**
|
|
* Write an integer value into the parcel at the current dataPosition(), growing
|
|
* dataCapacity() if needed.
|
|
*/
|
|
public final void writeInt(int val) {
|
|
}
|
|
|
|
/**
|
|
* Write a long integer value into the parcel at the current dataPosition(),
|
|
* growing dataCapacity() if needed.
|
|
*/
|
|
public final void writeLong(long val) {
|
|
}
|
|
|
|
/**
|
|
* Write a floating point value into the parcel at the current dataPosition(),
|
|
* growing dataCapacity() if needed.
|
|
*/
|
|
public final void writeFloat(float val) {
|
|
}
|
|
|
|
/**
|
|
* Write a double precision floating point value into the parcel at the current
|
|
* dataPosition(), growing dataCapacity() if needed.
|
|
*/
|
|
public final void writeDouble(double val) {
|
|
}
|
|
|
|
/**
|
|
* Write a string value into the parcel at the current dataPosition(), growing
|
|
* dataCapacity() if needed.
|
|
*/
|
|
public final void writeString(String val) {
|
|
}
|
|
|
|
/**
|
|
* Write a string without going though a {@link ReadWriteHelper}. Subclasses of
|
|
* {@link ReadWriteHelper} must use this method instead of {@link #writeString}
|
|
* to avoid infinity recursive calls.
|
|
*
|
|
* @hide
|
|
*/
|
|
public void writeStringNoHelper(String val) {
|
|
}
|
|
|
|
/** @hide */
|
|
public final void writeBoolean(boolean val) {
|
|
}
|
|
|
|
/**
|
|
* Write a CharSequence value into the parcel at the current dataPosition(),
|
|
* growing dataCapacity() if needed.
|
|
*
|
|
* @hide
|
|
*/
|
|
public final void writeCharSequence(CharSequence val) {
|
|
}
|
|
|
|
/**
|
|
* Write a byte value into the parcel at the current dataPosition(), growing
|
|
* dataCapacity() if needed.
|
|
*/
|
|
public final void writeByte(byte val) {
|
|
}
|
|
|
|
/**
|
|
* Please use {@link #writeBundle} instead. Flattens a Map into the parcel at
|
|
* the current dataPosition(), growing dataCapacity() if needed. The Map keys
|
|
* must be String objects. The Map values are written using {@link #writeValue}
|
|
* and must follow the specification there.
|
|
*
|
|
* <p>
|
|
* It is strongly recommended to use {@link #writeBundle} instead of this
|
|
* method, since the Bundle class provides a type-safe API that allows you to
|
|
* avoid mysterious type errors at the point of marshalling.
|
|
*/
|
|
public final void writeMap(Map val) {
|
|
}
|
|
|
|
/**
|
|
* Flatten a Bundle into the parcel at the current dataPosition(), growing
|
|
* dataCapacity() if needed.
|
|
*/
|
|
public final void writeBundle(Bundle val) {
|
|
}
|
|
|
|
/**
|
|
* Flatten a List into the parcel at the current dataPosition(), growing
|
|
* dataCapacity() if needed. The List values are written using
|
|
* {@link #writeValue} and must follow the specification there.
|
|
*/
|
|
public final void writeList(List val) {
|
|
}
|
|
|
|
/**
|
|
* Flatten an Object array into the parcel at the current dataPosition(),
|
|
* growing dataCapacity() if needed. The array values are written using
|
|
* {@link #writeValue} and must follow the specification there.
|
|
*/
|
|
public final void writeArray(Object[] val) {
|
|
}
|
|
|
|
public final void writeBooleanArray(boolean[] val) {
|
|
}
|
|
|
|
public final boolean[] createBooleanArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readBooleanArray(boolean[] val) {
|
|
}
|
|
|
|
public final void writeCharArray(char[] val) {
|
|
}
|
|
|
|
public final char[] createCharArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readCharArray(char[] val) {
|
|
}
|
|
|
|
public final void writeIntArray(int[] val) {
|
|
}
|
|
|
|
public final int[] createIntArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readIntArray(int[] val) {
|
|
}
|
|
|
|
public final void writeLongArray(long[] val) {
|
|
}
|
|
|
|
public final long[] createLongArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readLongArray(long[] val) {
|
|
}
|
|
|
|
public final void writeFloatArray(float[] val) {
|
|
}
|
|
|
|
public final float[] createFloatArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readFloatArray(float[] val) {
|
|
}
|
|
|
|
public final void writeDoubleArray(double[] val) {
|
|
}
|
|
|
|
public final double[] createDoubleArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readDoubleArray(double[] val) {
|
|
}
|
|
|
|
public final void writeStringArray(String[] val) {
|
|
}
|
|
|
|
public final String[] createStringArray() {
|
|
return null;
|
|
}
|
|
|
|
public final void readStringArray(String[] val) {
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public final void writeCharSequenceArray(CharSequence[] val) {
|
|
}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public final void writeCharSequenceList(ArrayList<CharSequence> val) {
|
|
}
|
|
|
|
/**
|
|
* Flatten a List containing String objects into the parcel, at the current
|
|
* dataPosition() and growing dataCapacity() if needed. They can later be
|
|
* retrieved with {@link #createStringArrayList} or {@link #readStringList}.
|
|
*
|
|
* @param val The list of strings to be written.
|
|
*
|
|
* @see #createStringArrayList
|
|
* @see #readStringList
|
|
*/
|
|
public final void writeStringList(List<String> val) {
|
|
}
|
|
|
|
/**
|
|
* Flatten a generic object in to a parcel. The given Object value may currently
|
|
* be one of the following types:
|
|
*
|
|
* <ul>
|
|
* <li>null
|
|
* <li>String
|
|
* <li>Byte
|
|
* <li>Short
|
|
* <li>Integer
|
|
* <li>Long
|
|
* <li>Float
|
|
* <li>Double
|
|
* <li>Boolean
|
|
* <li>String[]
|
|
* <li>boolean[]
|
|
* <li>byte[]
|
|
* <li>int[]
|
|
* <li>long[]
|
|
* <li>Object[] (supporting objects of the same type defined here).
|
|
* <li>{@link Bundle}
|
|
* <li>Map (as supported by {@link #writeMap}).
|
|
* <li>Any object that implements the {@link Parcelable} protocol.
|
|
* <li>Parcelable[]
|
|
* <li>CharSequence (as supported by {@link TextUtils#writeToParcel}).
|
|
* <li>List (as supported by {@link #writeList}).
|
|
* <li>{@link SparseArray} (as supported by
|
|
* {@link #writeSparseArray(SparseArray)}).
|
|
* <li>{@link IBinder}
|
|
* <li>Any object that implements Serializable (but see
|
|
* {@link #writeSerializable} for caveats). Note that all of the previous types
|
|
* have relatively efficient implementations for writing to a Parcel; having to
|
|
* rely on the generic serialization approach is much less efficient and should
|
|
* be avoided whenever possible.
|
|
* </ul>
|
|
*
|
|
* <p class="caution">
|
|
* {@link Parcelable} objects are written with {@link Parcelable#writeToParcel}
|
|
* using contextual flags of 0. When serializing objects containing
|
|
* {@link ParcelFileDescriptor}s, this may result in file descriptor leaks when
|
|
* they are returned from Binder calls (where
|
|
* {@link Parcelable#PARCELABLE_WRITE_RETURN_VALUE} should be used).
|
|
* </p>
|
|
*/
|
|
public final void writeValue(Object v) {
|
|
}
|
|
|
|
/**
|
|
* Flatten the name of the class of the Parcelable and its contents into the
|
|
* parcel.
|
|
*
|
|
* @param p The Parcelable object to be written.
|
|
* @param parcelableFlags Contextual flags as per
|
|
* {@link Parcelable#writeToParcel(Parcel, int)
|
|
* Parcelable.writeToParcel()}.
|
|
*/
|
|
public final void writeParcelable(Parcelable p, int parcelableFlags) {
|
|
}
|
|
|
|
/** @hide */
|
|
public final void writeParcelableCreator(Parcelable p) {
|
|
}
|
|
|
|
/**
|
|
* Write a generic serializable object in to a Parcel. It is strongly
|
|
* recommended that this method be avoided, since the serialization overhead is
|
|
* extremely large, and this approach will be much slower than using the other
|
|
* approaches to writing data in to a Parcel.
|
|
*/
|
|
public final void writeSerializable(Serializable s) {
|
|
}
|
|
|
|
/**
|
|
* Special function for writing an exception result at the header of a parcel,
|
|
* to be used when returning an exception from a transaction. Note that this
|
|
* currently only supports a few exception types; any other exception will be
|
|
* re-thrown by this function as a RuntimeException (to be caught by the
|
|
* system's last-resort exception handling when dispatching a transaction).
|
|
*
|
|
* <p>
|
|
* The supported exception types are:
|
|
* <ul>
|
|
* <li>{@link BadParcelableException}
|
|
* <li>{@link IllegalArgumentException}
|
|
* <li>{@link IllegalStateException}
|
|
* <li>{@link NullPointerException}
|
|
* <li>{@link SecurityException}
|
|
* <li>{@link UnsupportedOperationException}
|
|
* <li>{@link NetworkOnMainThreadException}
|
|
* </ul>
|
|
*
|
|
* @param e The Exception to be written.
|
|
*
|
|
* @see #writeNoException
|
|
* @see #readException
|
|
*/
|
|
public final void writeException(Exception e) {
|
|
}
|
|
|
|
/**
|
|
* Special function for writing information at the front of the Parcel
|
|
* indicating that no exception occurred.
|
|
*
|
|
* @see #writeException
|
|
* @see #readException
|
|
*/
|
|
public final void writeNoException() {
|
|
}
|
|
|
|
/**
|
|
* Special function for reading an exception result from the header of a parcel,
|
|
* to be used after receiving the result of a transaction. This will throw the
|
|
* exception for you if it had been written to the Parcel, otherwise return and
|
|
* let you read the normal result data from the Parcel.
|
|
*
|
|
* @see #writeException
|
|
* @see #writeNoException
|
|
*/
|
|
public final void readException() {
|
|
}
|
|
|
|
/**
|
|
* Parses the header of a Binder call's response Parcel and returns the
|
|
* exception code. Deals with lite or fat headers. In the common successful
|
|
* case, this header is generally zero. In less common cases, it's a small
|
|
* negative number and will be followed by an error string.
|
|
*
|
|
* This exists purely for android.database.DatabaseUtils and insulating it from
|
|
* having to handle fat headers as returned by e.g. StrictMode-induced RPC
|
|
* responses.
|
|
*
|
|
* @hide
|
|
*/
|
|
public final int readExceptionCode() {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Throw an exception with the given message. Not intended for use outside the
|
|
* Parcel class.
|
|
*
|
|
* @param code Used to determine which exception class to throw.
|
|
* @param msg The exception message.
|
|
*/
|
|
public final void readException(int code, String msg) {
|
|
}
|
|
|
|
/**
|
|
* Read an integer value from the parcel at the current dataPosition().
|
|
*/
|
|
public final int readInt() {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Read a long integer value from the parcel at the current dataPosition().
|
|
*/
|
|
public final long readLong() {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Read a floating point value from the parcel at the current dataPosition().
|
|
*/
|
|
public final float readFloat() {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Read a double precision floating point value from the parcel at the current
|
|
* dataPosition().
|
|
*/
|
|
public final double readDouble() {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Read a string value from the parcel at the current dataPosition().
|
|
*/
|
|
public final String readString() {
|
|
return null;
|
|
}
|
|
|
|
/** @hide */
|
|
public final boolean readBoolean() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Read a CharSequence value from the parcel at the current dataPosition().
|
|
*
|
|
* @hide
|
|
*/
|
|
public final CharSequence readCharSequence() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read a byte value from the parcel at the current dataPosition().
|
|
*/
|
|
public final byte readByte() {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Please use {@link #readBundle(ClassLoader)} instead (whose data must have
|
|
* been written with {@link #writeBundle}. Read into an existing Map object from
|
|
* the parcel at the current dataPosition().
|
|
*/
|
|
public final void readMap(Map outVal, ClassLoader loader) {
|
|
}
|
|
|
|
/**
|
|
* Read into an existing List object from the parcel at the current
|
|
* dataPosition(), using the given class loader to load any enclosed
|
|
* Parcelables. If it is null, the default class loader is used.
|
|
*/
|
|
public final void readList(List outVal, ClassLoader loader) {
|
|
}
|
|
|
|
/**
|
|
* Please use {@link #readBundle(ClassLoader)} instead (whose data must have
|
|
* been written with {@link #writeBundle}. Read and return a new HashMap object
|
|
* from the parcel at the current dataPosition(), using the given class loader
|
|
* to load any enclosed Parcelables. Returns null if the previously written map
|
|
* object was null.
|
|
*/
|
|
public final HashMap readHashMap(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new Bundle object from the parcel at the current
|
|
* dataPosition(). Returns null if the previously written Bundle object was
|
|
* null.
|
|
*/
|
|
public final Bundle readBundle() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new Bundle object from the parcel at the current
|
|
* dataPosition(), using the given class loader to initialize the class loader
|
|
* of the Bundle for later retrieval of Parcelable objects. Returns null if the
|
|
* previously written Bundle object was null.
|
|
*/
|
|
public final Bundle readBundle(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a byte[] object from the parcel.
|
|
*/
|
|
public final byte[] createByteArray() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read a byte[] object from the parcel and copy it into the given byte array.
|
|
*/
|
|
public final void readByteArray(byte[] val) {
|
|
}
|
|
|
|
/**
|
|
* Read a blob of data from the parcel and return it as a byte array.
|
|
* {@hide} {@SystemApi}
|
|
*/
|
|
public final byte[] readBlob() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a String[] object from the parcel. {@hide}
|
|
*/
|
|
public final String[] readStringArray() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a CharSequence[] object from the parcel. {@hide}
|
|
*/
|
|
public final CharSequence[] readCharSequenceArray() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return an ArrayList<CharSequence> object from the parcel.
|
|
* {@hide}
|
|
*/
|
|
public final ArrayList<CharSequence> readCharSequenceList() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new ArrayList object from the parcel at the current
|
|
* dataPosition(). Returns null if the previously written list object was null.
|
|
* The given class loader will be used to load any enclosed Parcelables.
|
|
*/
|
|
public final ArrayList readArrayList(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new Object array from the parcel at the current
|
|
* dataPosition(). Returns null if the previously written array was null. The
|
|
* given class loader will be used to load any enclosed Parcelables.
|
|
*/
|
|
public final Object[] readArray(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new ArrayList containing String objects from the parcel
|
|
* that was written with {@link #writeStringList} at the current dataPosition().
|
|
* Returns null if the previously written list object was null.
|
|
*
|
|
* @return A newly created ArrayList containing strings with the same data as
|
|
* those that were previously written.
|
|
*
|
|
* @see #writeStringList
|
|
*/
|
|
public final ArrayList<String> createStringArrayList() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read into the given List items String objects that were written with
|
|
* {@link #writeStringList} at the current dataPosition().
|
|
*
|
|
* @see #writeStringList
|
|
*/
|
|
public final void readStringList(List<String> list) {
|
|
}
|
|
|
|
/**
|
|
* Read a typed object from a parcel. The given class loader will be used to
|
|
* load any enclosed Parcelables. If it is null, the default class loader will
|
|
* be used.
|
|
*/
|
|
public final Object readValue(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new Parcelable from the parcel. The given class loader will
|
|
* be used to load any enclosed Parcelables. If it is null, the default class
|
|
* loader will be used.
|
|
*
|
|
* @param loader A ClassLoader from which to instantiate the Parcelable object,
|
|
* or null for the default class loader.
|
|
* @return Returns the newly created Parcelable, or null if a null object has
|
|
* been written.
|
|
* @throws BadParcelableException Throws BadParcelableException if there was an
|
|
* error trying to instantiate the Parcelable.
|
|
*/
|
|
public final <T extends Parcelable> T readParcelable(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new Parcelable array from the parcel. The given class
|
|
* loader will be used to load any enclosed Parcelables.
|
|
*
|
|
* @return the Parcelable array, or null if the array is null
|
|
*/
|
|
public final Parcelable[] readParcelableArray(ClassLoader loader) {
|
|
return null;
|
|
}
|
|
|
|
/** @hide */
|
|
public final <T extends Parcelable> T[] readParcelableArray(ClassLoader loader, Class<T> clazz) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Read and return a new Serializable object from the parcel.
|
|
*
|
|
* @return the Serializable object, or null if the Serializable name wasn't
|
|
* found in the parcel.
|
|
*/
|
|
public final Serializable readSerializable() {
|
|
return null;
|
|
}
|
|
|
|
private final Serializable readSerializable(final ClassLoader loader) {
|
|
return null;
|
|
}
|
|
}
|