Child class should inherit this to use this or use {@link LargeParcelable} class. * *
Parcelized data will have following elements *
If the caller sends this class through binder, the caller must close this class after writing * to parcel, unless this class is used as the return value for a binder call. If this is used as * return value, the stored shared memory will be lost unless caller make a copy of the shared * memory file descriptor. * *
If the caller receives this class through binder, the caller must close this after reading the
* data.
*/
public abstract class LargeParcelableBase implements Parcelable, Closeable {
/**
* This is a similar method to Parcel.marshall except that this accepts a byte buffer
* mapped from a file as argument. We can avoid an additional memory copy using this method.
*/
private static native void nativeMarshallParcelToBuffer(
long parcelNativePtr, ByteBuffer buffer, int size);
/**
* This is a similar method to Parcel.unmarshall except that this accepts a byte buffer
* mapped from a file as argument. We can avoid an additional memory copy using this method.
*/
private static native void nativeUnmarshallBufferToParcel(
ByteBuffer buffer, int size, long parcelNativePtr);
/** Payload size bigger than this value will be passed over shared memory. */
public static final int MAX_DIRECT_PAYLOAD_SIZE = 4096;
private static final String TAG = LargeParcelable.class.getSimpleName();
private static final boolean DBG_PAYLOAD = Log.isLoggable(TAG, Log.DEBUG);
private static final int DBG_DUMP_LENGTH = 16;
private static final int NULL_PAYLOAD = 0;
private static final int NONNULL_PAYLOAD = 1;
private static final int FD_HEADER = 0;
private static final Cleaner CLEANER = SystemCleaner.cleaner();
private AtomicReference Close the underlying shared memory for this. This can be called multiple times safely.
* When this is not called explicitly, it will be closed when this instance is GCed.
* Calling this can be useful when many instances are created frequently.
*
* If underlying payload is changed, the client should call this before sending it over
* binder as sending it over binder can keep shared memory generated from the previous binder
* call.
*/
@Override
public void close() {
mClosedRef.set(true);
mCleanable.clean();
}
protected static SharedMemory serializeParcelToSharedMemory(Parcel p) {
SharedMemory memory = null;
ByteBuffer buffer = null;
int size = p.dataSize();
try {
memory = SharedMemory.create(LargeParcelableBase.class.getSimpleName(), size);
buffer = memory.mapReadWrite();
if (largeparcelableUseNativeParcel()) {
nativeMarshallParcelToBuffer(getParcelNativePtr(p), buffer, size);
} else {
byte[] data = p.marshall();
buffer.put(data, 0, size);
}
if (DBG_PAYLOAD) {
int dumpSize = Math.min(DBG_DUMP_LENGTH, size);
StringBuilder bd = new StringBuilder();
bd.append("marshalled:");
for (int i = 0; i < dumpSize; i++) {
bd.append(buffer.get(i));
if (i != dumpSize - 1) {
bd.append(',');
}
}
Slog.d(TAG, bd.toString());
}
if (!memory.setProtect(PROT_READ)) {
memory.close();
throw new SecurityException("Failed to set read-only protection on shared memory");
}
} catch (ErrnoException e) {
memory.close();
throw new IllegalArgumentException("Failed to use shared memory", e);
} catch (Exception e) {
memory.close();
throw new IllegalArgumentException("failed to serialize", e);
} finally {
if (buffer != null) {
SharedMemory.unmap(buffer);
}
}
return memory;
}
protected static Parcel copyFromSharedMemory(SharedMemory memory) {
ByteBuffer buffer = null;
Parcel in = Parcel.obtain();
try {
buffer = memory.mapReadOnly();
if (largeparcelableUseNativeParcel()) {
nativeUnmarshallBufferToParcel(buffer, buffer.limit(), getParcelNativePtr(in));
} else {
byte[] payload = new byte[buffer.limit()];
buffer.get(payload);
in.unmarshall(payload, 0, payload.length);
}
in.setDataPosition(0);
if (DBG_PAYLOAD) {
int dumpSize = Math.min(DBG_DUMP_LENGTH, buffer.limit());
StringBuilder bd = new StringBuilder();
bd.append("unmarshalled:");
int parcelStartPosition = in.dataPosition();
byte[] fromParcel = in.marshall();
for (int i = 0; i < dumpSize; i++) {
bd.append(fromParcel[i]);
if (i != dumpSize - 1) bd.append(',');
}
bd.append("=startPosition:");
bd.append(parcelStartPosition);
bd.append("=memory:");
for (int i = 0; i < dumpSize; i++) {
bd.append(buffer.get(i));
if (i != dumpSize - 1) bd.append(',');
}
Slog.d(TAG, bd.toString());
in.setDataPosition(parcelStartPosition);
}
} catch (ErrnoException e) {
throw new IllegalArgumentException("cannot create Parcelable from SharedMemory", e);
} catch (Exception e) {
throw new IllegalArgumentException("failed to deserialize", e);
} finally {
if (buffer != null) {
SharedMemory.unmap(buffer);
}
}
return in;
}
private static long getParcelNativePtr(Parcel p) {
long parcelNativePtr;
try {
parcelNativePtr = (long) sParcelNativePtrField.get(p);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Cannot access Parcel.mNativePtr field", e);
}
if (parcelNativePtr == 0) {
throw new IllegalStateException("Parcel.mNativePtr is null, must not happen");
}
return parcelNativePtr;
}
private void deserializeSharedMemory(SharedMemory memory) {
// The shared memory file contains a serialized largeParcelable.
// size + payload + 0 (no shared memory).
Parcel in = null;
try {
in = copyFromSharedMemory(memory);
// Even if we don't need the file size, we have to read it from the parcel to advance
// the data position.
int fileSize = in.readInt();
if (DBG_PAYLOAD) {
Slog.d(TAG, "file size in shared memory file: " + fileSize);
}
deserialize(in);
// There is an additional 0 in the parcel, but we ignore that.
} finally {
if (in != null) {
in.recycle();
}
}
}
// If sharedMemory is not null, serialize null payload and shared memory to parcel.
// Otherwise, serialize the actual payload to parcel.
private int serializeMemoryFdOrPayloadToParcel(
Parcel dest, int flags, @Nullable SharedMemory sharedMemory) {
int startPosition = dest.dataPosition();
dest.writeInt(0); // payload size
if (sharedMemory != null) {
serializeNullPayload(dest);
writeSharedMemoryCompatibleToParcel(dest, sharedMemory, flags);
} else {
serialize(dest, flags);
writeSharedMemoryCompatibleToParcel(dest, null, flags);
}
return updatePayloadSize(dest, startPosition);
}
}