From a98415b043e505d631126cbb8f163d21eea4461d Mon Sep 17 00:00:00 2001 From: Jeongik Cha Date: Fri, 27 Mar 2020 17:09:35 +0900 Subject: [PATCH] Add ParcelableHolder type To give a way to extend a stable parcelable object, a wraper for a parcelable is necessary. The reason why it needs to be wrapped is allowing to trasfer an extended parcelable even though some of modules using the parcelable don't know the type of an extension. Whenever setParcelable() is called, it checks stability level Bug: 146611855 Test: atest aidl_integration_test aidl_unittests Change-Id: I6895976658fd7450b2ee47076a03079995777143 --- core/java/android/os/ParcelableHolder.java | 177 +++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 core/java/android/os/ParcelableHolder.java diff --git a/core/java/android/os/ParcelableHolder.java b/core/java/android/os/ParcelableHolder.java new file mode 100644 index 0000000000000..c37a2ff1112cc --- /dev/null +++ b/core/java/android/os/ParcelableHolder.java @@ -0,0 +1,177 @@ +/* + * Copyright (C) 2020 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 android.annotation.NonNull; +import android.annotation.Nullable; +import android.util.MathUtils; + +/** + * Parcelable containing the other Parcelable object. + * @hide + */ +public final class ParcelableHolder implements Parcelable { + /** + * This is set by {@link #setParcelable}. + * {@link #mParcelable} and {@link #mParcel} are mutually exclusive + * if {@link ParcelableHolder} contains value, otherwise, both are null. + */ + private Parcelable mParcelable; + /** + * This is set by {@link #readFromParcel}. + * {@link #mParcelable} and {@link #mParcel} are mutually exclusive + * if {@link ParcelableHolder} contains value, otherwise, both are null. + */ + private Parcel mParcel; + private boolean mIsStable = false; + + public ParcelableHolder(boolean isStable) { + mIsStable = isStable; + } + + private ParcelableHolder() { + + } + + /** + * {@link ParcelableHolder}'s stability is determined by the parcelable + * which contains this ParcelableHolder. + * For more detail refer to {@link Parcelable#isStable}. + */ + @Override + public boolean isStable() { + return mIsStable; + } + + @NonNull + public static final Parcelable.Creator CREATOR = + new Parcelable.Creator() { + @NonNull + @Override + public ParcelableHolder createFromParcel(@NonNull Parcel parcel) { + ParcelableHolder parcelable = new ParcelableHolder(); + parcelable.readFromParcel(parcel); + return parcelable; + } + + @NonNull + @Override + public ParcelableHolder[] newArray(int size) { + return new ParcelableHolder[size]; + } + }; + + + /** + * Write a parcelable into ParcelableHolder, the previous parcelable will be removed. + * @return {@code false} if the parcelable's stability is more unstable ParcelableHolder. + */ + public synchronized boolean setParcelable(@Nullable Parcelable p) { + if (p != null && this.isStable() && !p.isStable()) { + return false; + } + mParcelable = p; + if (mParcel != null) { + mParcel.recycle(); + mParcel = null; + } + return true; + } + + /** + * @return the parcelable that was written by {@link #setParcelable} or {@link #readFromParcel}, + * or {@code null} if the parcelable has not been written, or T is different from + * the type written by (@link #setParcelable}. + */ + @Nullable + public synchronized T getParcelable(@NonNull Class clazz) { + if (mParcel == null) { + if (!clazz.isInstance(mParcelable)) { + return null; + } + return (T) mParcelable; + } + + mParcel.setDataPosition(0); + + T parcelable = mParcel.readParcelable(clazz.getClassLoader()); + if (!clazz.isInstance(parcelable)) { + return null; + } + mParcelable = parcelable; + + mParcel.recycle(); + mParcel = null; + return parcelable; + } + + /** + * Read ParcelableHolder from a parcel. + */ + public synchronized void readFromParcel(@NonNull Parcel parcel) { + this.mIsStable = parcel.readBoolean(); + + mParcelable = null; + + if (mParcel == null) { + mParcel = Parcel.obtain(); + } + mParcel.setDataPosition(0); + mParcel.setDataSize(0); + + int dataSize = parcel.readInt(); + if (dataSize < 0) { + throw new IllegalArgumentException("dataSize from parcel is negative"); + } + int dataStartPos = parcel.dataPosition(); + + mParcel.appendFrom(parcel, dataStartPos, dataSize); + parcel.setDataPosition(MathUtils.addOrThrow(dataStartPos, dataSize)); + } + + @Override + public synchronized void writeToParcel(@NonNull Parcel parcel, int flags) { + parcel.writeBoolean(this.mIsStable); + + if (mParcel != null) { + parcel.writeInt(mParcel.dataSize()); + parcel.appendFrom(mParcel, 0, mParcel.dataSize()); + return; + } + + int sizePos = parcel.dataPosition(); + parcel.writeInt(0); + int dataStartPos = parcel.dataPosition(); + parcel.writeParcelable(mParcelable, 0); + int dataSize = parcel.dataPosition() - dataStartPos; + + parcel.setDataPosition(sizePos); + parcel.writeInt(dataSize); + parcel.setDataPosition(MathUtils.addOrThrow(parcel.dataPosition(), dataSize)); + } + + @Override + public synchronized int describeContents() { + if (mParcel != null) { + return mParcel.hasFileDescriptors() ? Parcelable.CONTENTS_FILE_DESCRIPTOR : 0; + } + if (mParcelable != null) { + return mParcelable.describeContents(); + } + return 0; + } +}