117 lines
4.0 KiB
Java
117 lines
4.0 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;
|
|
|
|
/**
|
|
* Interface for classes whose instances can be written to
|
|
* and restored from a {@link Parcel}. Classes implementing the Parcelable
|
|
* interface must also have a static field called <code>CREATOR</code>, which
|
|
* is an object implementing the {@link Parcelable.Creator Parcelable.Creator}
|
|
* interface.
|
|
*
|
|
* <p>A typical implementation of Parcelable is:</p>
|
|
*
|
|
* <pre>
|
|
* public class MyParcelable implements Parcelable {
|
|
* private int mData;
|
|
*
|
|
* public int describeContents() {
|
|
* return 0;
|
|
* }
|
|
*
|
|
* public void writeToParcel(Parcel out, int flags) {
|
|
* out.writeInt(mData);
|
|
* }
|
|
*
|
|
* public static final Parcelable.Creator<MyParcelable> CREATOR
|
|
* = new Parcelable.Creator<MyParcelable>() {
|
|
* public MyParcelable createFromParcel(Parcel in) {
|
|
* return new MyParcelable(in);
|
|
* }
|
|
*
|
|
* public MyParcelable[] newArray(int size) {
|
|
* return new MyParcelable[size];
|
|
* }
|
|
* };
|
|
*
|
|
* private MyParcelable(Parcel in) {
|
|
* mData = in.readInt();
|
|
* }
|
|
* }</pre>
|
|
*/
|
|
public interface Parcelable {
|
|
/**
|
|
* Flag for use with {@link #writeToParcel}: the object being written
|
|
* is a return value, that is the result of a function such as
|
|
* "<code>Parcelable someFunction()</code>",
|
|
* "<code>void someFunction(out Parcelable)</code>", or
|
|
* "<code>void someFunction(inout Parcelable)</code>". Some implementations
|
|
* may want to release resources at this point.
|
|
*/
|
|
public static final int PARCELABLE_WRITE_RETURN_VALUE = 0x0001;
|
|
|
|
/**
|
|
* Bit masks for use with {@link #describeContents}: each bit represents a
|
|
* kind of object considered to have potential special significance when
|
|
* marshalled.
|
|
*/
|
|
public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001;
|
|
|
|
/**
|
|
* Describe the kinds of special objects contained in this Parcelable's
|
|
* marshalled representation.
|
|
*
|
|
* @return a bitmask indicating the set of special object types marshalled
|
|
* by the Parcelable.
|
|
*/
|
|
public int describeContents();
|
|
|
|
/**
|
|
* Flatten this object in to a Parcel.
|
|
*
|
|
* @param dest The Parcel in which the object should be written.
|
|
* @param flags Additional flags about how the object should be written.
|
|
* May be 0 or {@link #PARCELABLE_WRITE_RETURN_VALUE}.
|
|
*/
|
|
public void writeToParcel(Parcel dest, int flags);
|
|
|
|
/**
|
|
* Interface that must be implemented and provided as a public CREATOR
|
|
* field that generates instances of your Parcelable class from a Parcel.
|
|
*/
|
|
public interface Creator<T> {
|
|
/**
|
|
* Create a new instance of the Parcelable class, instantiating it
|
|
* from the given Parcel whose data had previously been written by
|
|
* {@link Parcelable#writeToParcel Parcelable.writeToParcel()}.
|
|
*
|
|
* @param source The Parcel to read the object's data from.
|
|
* @return Returns a new instance of the Parcelable class.
|
|
*/
|
|
public T createFromParcel(Parcel source);
|
|
|
|
/**
|
|
* Create a new array of the Parcelable class.
|
|
*
|
|
* @param size Size of the array.
|
|
* @return Returns an array of the Parcelable class, with every entry
|
|
* initialized to null.
|
|
*/
|
|
public T[] newArray(int size);
|
|
}
|
|
}
|