CrackMe.apk
Download file
package androidx.versionedparcelable;
import android.os.BadParcelableException;
import android.os.Bundle;
import android.os.IBinder;
import android.os.IInterface;
import android.os.NetworkOnMainThreadException;
import android.os.Parcelable;
import android.util.Size;
import android.util.SizeF;
import android.util.SparseBooleanArray;
import androidx.collection.ArrayMap;
import androidx.collection.ArraySet;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
public abstract class VersionedParcel {
private static final int EX_BAD_PARCELABLE = -2;
private static final int EX_ILLEGAL_ARGUMENT = -3;
private static final int EX_ILLEGAL_STATE = -5;
private static final int EX_NETWORK_MAIN_THREAD = -6;
private static final int EX_NULL_POINTER = -4;
private static final int EX_PARCELABLE = -9;
private static final int EX_SECURITY = -1;
private static final int EX_UNSUPPORTED_OPERATION = -7;
private static final String TAG = "VersionedParcel";
private static final int TYPE_BINDER = 5;
private static final int TYPE_FLOAT = 8;
private static final int TYPE_INTEGER = 7;
private static final int TYPE_PARCELABLE = 2;
private static final int TYPE_SERIALIZABLE = 3;
private static final int TYPE_STRING = 4;
private static final int TYPE_VERSIONED_PARCELABLE = 1;
protected final ArrayMap<String, Class> mParcelizerCache;
protected final ArrayMap<String, Method> mReadCache;
protected final ArrayMap<String, Method> mWriteCache;
/* access modifiers changed from: protected */
public abstract void closeField();
/* access modifiers changed from: protected */
public abstract VersionedParcel createSubParcel();
public boolean isStream() {
return false;
}
/* access modifiers changed from: protected */
public abstract boolean readBoolean();
/* access modifiers changed from: protected */
public abstract Bundle readBundle();
/* access modifiers changed from: protected */
public abstract byte[] readByteArray();
/* access modifiers changed from: protected */
public abstract CharSequence readCharSequence();
/* access modifiers changed from: protected */
public abstract double readDouble();
/* access modifiers changed from: protected */
public abstract boolean readField(int i);
/* access modifiers changed from: protected */
public abstract float readFloat();
/* access modifiers changed from: protected */
public abstract int readInt();
/* access modifiers changed from: protected */
public abstract long readLong();
/* access modifiers changed from: protected */
public abstract <T extends Parcelable> T readParcelable();
/* access modifiers changed from: protected */
public abstract String readString();
/* access modifiers changed from: protected */
public abstract IBinder readStrongBinder();
/* access modifiers changed from: protected */
public abstract void setOutputField(int i);
public void setSerializationFlags(boolean z, boolean z2) {
}
/* access modifiers changed from: protected */
public abstract void writeBoolean(boolean z);
/* access modifiers changed from: protected */
public abstract void writeBundle(Bundle bundle);
/* access modifiers changed from: protected */
public abstract void writeByteArray(byte[] bArr);
/* access modifiers changed from: protected */
public abstract void writeByteArray(byte[] bArr, int i, int i2);
/* access modifiers changed from: protected */
public abstract void writeCharSequence(CharSequence charSequence);
/* access modifiers changed from: protected */
public abstract void writeDouble(double d);
/* access modifiers changed from: protected */
public abstract void writeFloat(float f);
/* access modifiers changed from: protected */
public abstract void writeInt(int i);
/* access modifiers changed from: protected */
public abstract void writeLong(long j);
/* access modifiers changed from: protected */
public abstract void writeParcelable(Parcelable parcelable);
/* access modifiers changed from: protected */
public abstract void writeString(String str);
/* access modifiers changed from: protected */
public abstract void writeStrongBinder(IBinder iBinder);
/* access modifiers changed from: protected */
public abstract void writeStrongInterface(IInterface iInterface);
public VersionedParcel(ArrayMap<String, Method> arrayMap, ArrayMap<String, Method> arrayMap2, ArrayMap<String, Class> arrayMap3) {
this.mReadCache = arrayMap;
this.mWriteCache = arrayMap2;
this.mParcelizerCache = arrayMap3;
}
public void writeStrongInterface(IInterface iInterface, int i) {
setOutputField(i);
writeStrongInterface(iInterface);
}
public void writeBundle(Bundle bundle, int i) {
setOutputField(i);
writeBundle(bundle);
}
public void writeBoolean(boolean z, int i) {
setOutputField(i);
writeBoolean(z);
}
public void writeByteArray(byte[] bArr, int i) {
setOutputField(i);
writeByteArray(bArr);
}
public void writeByteArray(byte[] bArr, int i, int i2, int i3) {
setOutputField(i3);
writeByteArray(bArr, i, i2);
}
public void writeCharSequence(CharSequence charSequence, int i) {
setOutputField(i);
writeCharSequence(charSequence);
}
public void writeInt(int i, int i2) {
setOutputField(i2);
writeInt(i);
}
public void writeLong(long j, int i) {
setOutputField(i);
writeLong(j);
}
public void writeFloat(float f, int i) {
setOutputField(i);
writeFloat(f);
}
public void writeDouble(double d, int i) {
setOutputField(i);
writeDouble(d);
}
public void writeString(String str, int i) {
setOutputField(i);
writeString(str);
}
public void writeStrongBinder(IBinder iBinder, int i) {
setOutputField(i);
writeStrongBinder(iBinder);
}
public void writeParcelable(Parcelable parcelable, int i) {
setOutputField(i);
writeParcelable(parcelable);
}
public boolean readBoolean(boolean z, int i) {
if (!readField(i)) {
return z;
}
return readBoolean();
}
public int readInt(int i, int i2) {
if (!readField(i2)) {
return i;
}
return readInt();
}
public long readLong(long j, int i) {
if (!readField(i)) {
return j;
}
return readLong();
}
public float readFloat(float f, int i) {
if (!readField(i)) {
return f;
}
return readFloat();
}
public double readDouble(double d, int i) {
if (!readField(i)) {
return d;
}
return readDouble();
}
public String readString(String str, int i) {
if (!readField(i)) {
return str;
}
return readString();
}
public IBinder readStrongBinder(IBinder iBinder, int i) {
if (!readField(i)) {
return iBinder;
}
return readStrongBinder();
}
public byte[] readByteArray(byte[] bArr, int i) {
if (!readField(i)) {
return bArr;
}
return readByteArray();
}
public <T extends Parcelable> T readParcelable(T t, int i) {
if (!readField(i)) {
return t;
}
return readParcelable();
}
public Bundle readBundle(Bundle bundle, int i) {
if (!readField(i)) {
return bundle;
}
return readBundle();
}
public void writeByte(byte b, int i) {
setOutputField(i);
writeInt(b);
}
public void writeSize(Size size, int i) {
setOutputField(i);
writeBoolean(size != null);
if (size != null) {
writeInt(size.getWidth());
writeInt(size.getHeight());
}
}
public void writeSizeF(SizeF sizeF, int i) {
setOutputField(i);
writeBoolean(sizeF != null);
if (sizeF != null) {
writeFloat(sizeF.getWidth());
writeFloat(sizeF.getHeight());
}
}
public void writeSparseBooleanArray(SparseBooleanArray sparseBooleanArray, int i) {
setOutputField(i);
if (sparseBooleanArray == null) {
writeInt(-1);
return;
}
int size = sparseBooleanArray.size();
writeInt(size);
for (int i2 = 0; i2 < size; i2++) {
writeInt(sparseBooleanArray.keyAt(i2));
writeBoolean(sparseBooleanArray.valueAt(i2));
}
}
public void writeBooleanArray(boolean[] zArr, int i) {
setOutputField(i);
writeBooleanArray(zArr);
}
/* access modifiers changed from: protected */
public void writeBooleanArray(boolean[] zArr) {
if (zArr != null) {
writeInt(r0);
for (boolean z : zArr) {
writeInt(z ? 1 : 0);
}
return;
}
writeInt(-1);
}
public boolean[] readBooleanArray(boolean[] zArr, int i) {
if (!readField(i)) {
return zArr;
}
return readBooleanArray();
}
/* access modifiers changed from: protected */
public boolean[] readBooleanArray() {
int readInt = readInt();
if (readInt < 0) {
return null;
}
boolean[] zArr = new boolean[readInt];
for (int i = 0; i < readInt; i++) {
zArr[i] = readInt() != 0;
}
return zArr;
}
public void writeCharArray(char[] cArr, int i) {
setOutputField(i);
if (cArr != null) {
writeInt(r4);
for (char writeInt : cArr) {
writeInt(writeInt);
}
return;
}
writeInt(-1);
}
public CharSequence readCharSequence(CharSequence charSequence, int i) {
if (!readField(i)) {
return charSequence;
}
return readCharSequence();
}
public char[] readCharArray(char[] cArr, int i) {
if (!readField(i)) {
return cArr;
}
int readInt = readInt();
if (readInt < 0) {
return null;
}
char[] cArr2 = new char[readInt];
for (int i2 = 0; i2 < readInt; i2++) {
cArr2[i2] = (char) readInt();
}
return cArr2;
}
public void writeIntArray(int[] iArr, int i) {
setOutputField(i);
writeIntArray(iArr);
}
/* access modifiers changed from: protected */
public void writeIntArray(int[] iArr) {
if (iArr != null) {
writeInt(r0);
for (int writeInt : iArr) {
writeInt(writeInt);
}
return;
}
writeInt(-1);
}
public int[] readIntArray(int[] iArr, int i) {
if (!readField(i)) {
return iArr;
}
return readIntArray();
}
/* access modifiers changed from: protected */
public int[] readIntArray() {
int readInt = readInt();
if (readInt < 0) {
return null;
}
int[] iArr = new int[readInt];
for (int i = 0; i < readInt; i++) {
iArr[i] = readInt();
}
return iArr;
}
public void writeLongArray(long[] jArr, int i) {
setOutputField(i);
writeLongArray(jArr);
}
/* access modifiers changed from: protected */
public void writeLongArray(long[] jArr) {
if (jArr != null) {
writeInt(r0);
for (long writeLong : jArr) {
writeLong(writeLong);
}
return;
}
writeInt(-1);
}
public long[] readLongArray(long[] jArr, int i) {
if (!readField(i)) {
return jArr;
}
return readLongArray();
}
/* access modifiers changed from: protected */
public long[] readLongArray() {
int readInt = readInt();
if (readInt < 0) {
return null;
}
long[] jArr = new long[readInt];
for (int i = 0; i < readInt; i++) {
jArr[i] = readLong();
}
return jArr;
}
public void writeFloatArray(float[] fArr, int i) {
setOutputField(i);
writeFloatArray(fArr);
}
/* access modifiers changed from: protected */
public void writeFloatArray(float[] fArr) {
if (fArr != null) {
writeInt(r0);
for (float writeFloat : fArr) {
writeFloat(writeFloat);
}
return;
}
writeInt(-1);
}
public float[] readFloatArray(float[] fArr, int i) {
if (!readField(i)) {
return fArr;
}
return readFloatArray();
}
/* access modifiers changed from: protected */
public float[] readFloatArray() {
int readInt = readInt();
if (readInt < 0) {
return null;
}
float[] fArr = new float[readInt];
for (int i = 0; i < readInt; i++) {
fArr[i] = readFloat();
}
return fArr;
}
public void writeDoubleArray(double[] dArr, int i) {
setOutputField(i);
writeDoubleArray(dArr);
}
/* access modifiers changed from: protected */
public void writeDoubleArray(double[] dArr) {
if (dArr != null) {
writeInt(r0);
for (double writeDouble : dArr) {
writeDouble(writeDouble);
}
return;
}
writeInt(-1);
}
public double[] readDoubleArray(double[] dArr, int i) {
if (!readField(i)) {
return dArr;
}
return readDoubleArray();
}
/* access modifiers changed from: protected */
public double[] readDoubleArray() {
int readInt = readInt();
if (readInt < 0) {
return null;
}
double[] dArr = new double[readInt];
for (int i = 0; i < readInt; i++) {
dArr[i] = readDouble();
}
return dArr;
}
public <T> void writeSet(Set<T> set, int i) {
writeCollection(set, i);
}
public <T> void writeList(List<T> list, int i) {
writeCollection(list, i);
}
public <K, V> void writeMap(Map<K, V> map, int i) {
setOutputField(i);
if (map == null) {
writeInt(-1);
return;
}
int size = map.size();
writeInt(size);
if (size != 0) {
ArrayList arrayList = new ArrayList();
ArrayList arrayList2 = new ArrayList();
for (Map.Entry next : map.entrySet()) {
arrayList.add(next.getKey());
arrayList2.add(next.getValue());
}
writeCollection(arrayList);
writeCollection(arrayList2);
}
}
private <T> void writeCollection(Collection<T> collection, int i) {
setOutputField(i);
writeCollection(collection);
}
private <T> void writeCollection(Collection<T> collection) {
if (collection == null) {
writeInt(-1);
return;
}
int size = collection.size();
writeInt(size);
if (size > 0) {
int type = getType(collection.iterator().next());
writeInt(type);
switch (type) {
case 1:
for (T writeVersionedParcelable : collection) {
writeVersionedParcelable(writeVersionedParcelable);
}
return;
case 2:
for (T writeParcelable : collection) {
writeParcelable(writeParcelable);
}
return;
case 3:
for (T writeSerializable : collection) {
writeSerializable(writeSerializable);
}
return;
case 4:
for (T writeString : collection) {
writeString(writeString);
}
return;
case 5:
for (T writeStrongBinder : collection) {
writeStrongBinder(writeStrongBinder);
}
return;
case 7:
for (T intValue : collection) {
writeInt(intValue.intValue());
}
return;
case 8:
for (T floatValue : collection) {
writeFloat(floatValue.floatValue());
}
return;
default:
return;
}
}
}
public <T> void writeArray(T[] tArr, int i) {
setOutputField(i);
writeArray(tArr);
}
/* access modifiers changed from: protected */
public <T> void writeArray(T[] tArr) {
if (tArr == null) {
writeInt(-1);
return;
}
int length = tArr.length;
writeInt(length);
if (length > 0) {
int i = 0;
int type = getType(tArr[0]);
writeInt(type);
if (type == 1) {
while (i < length) {
writeVersionedParcelable((VersionedParcelable) tArr[i]);
i++;
}
} else if (type == 2) {
while (i < length) {
writeParcelable((Parcelable) tArr[i]);
i++;
}
} else if (type == 3) {
while (i < length) {
writeSerializable((Serializable) tArr[i]);
i++;
}
} else if (type == 4) {
while (i < length) {
writeString((String) tArr[i]);
i++;
}
} else if (type == 5) {
while (i < length) {
writeStrongBinder((IBinder) tArr[i]);
i++;
}
}
}
}
private <T> int getType(T t) {
if (t instanceof String) {
return 4;
}
if (t instanceof Parcelable) {
return 2;
}
if (t instanceof VersionedParcelable) {
return 1;
}
if (t instanceof Serializable) {
return 3;
}
if (t instanceof IBinder) {
return 5;
}
if (t instanceof Integer) {
return 7;
}
if (t instanceof Float) {
return 8;
}
throw new IllegalArgumentException(t.getClass().getName() + " cannot be VersionedParcelled");
}
public void writeVersionedParcelable(VersionedParcelable versionedParcelable, int i) {
setOutputField(i);
writeVersionedParcelable(versionedParcelable);
}
/* access modifiers changed from: protected */
public void writeVersionedParcelable(VersionedParcelable versionedParcelable) {
if (versionedParcelable == null) {
writeString((String) null);
return;
}
writeVersionedParcelableCreator(versionedParcelable);
VersionedParcel createSubParcel = createSubParcel();
writeToParcel(versionedParcelable, createSubParcel);
createSubParcel.closeField();
}
private void writeVersionedParcelableCreator(VersionedParcelable versionedParcelable) {
try {
writeString(findParcelClass(versionedParcelable.getClass()).getName());
} catch (ClassNotFoundException e) {
throw new RuntimeException(versionedParcelable.getClass().getSimpleName() + " does not have a Parcelizer", e);
}
}
public void writeSerializable(Serializable serializable, int i) {
setOutputField(i);
writeSerializable(serializable);
}
private void writeSerializable(Serializable serializable) {
if (serializable == null) {
writeString((String) null);
return;
}
String name = serializable.getClass().getName();
writeString(name);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
try {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(serializable);
objectOutputStream.close();
writeByteArray(byteArrayOutputStream.toByteArray());
} catch (IOException e) {
throw new RuntimeException("VersionedParcelable encountered IOException writing serializable object (name = " + name + ")", e);
}
}
public void writeException(Exception exc, int i) {
setOutputField(i);
if (exc == null) {
writeNoException();
return;
}
int i2 = 0;
if ((exc instanceof Parcelable) && exc.getClass().getClassLoader() == Parcelable.class.getClassLoader()) {
i2 = EX_PARCELABLE;
} else if (exc instanceof SecurityException) {
i2 = -1;
} else if (exc instanceof BadParcelableException) {
i2 = -2;
} else if (exc instanceof IllegalArgumentException) {
i2 = -3;
} else if (exc instanceof NullPointerException) {
i2 = -4;
} else if (exc instanceof IllegalStateException) {
i2 = -5;
} else if (exc instanceof NetworkOnMainThreadException) {
i2 = EX_NETWORK_MAIN_THREAD;
} else if (exc instanceof UnsupportedOperationException) {
i2 = EX_UNSUPPORTED_OPERATION;
}
writeInt(i2);
if (i2 != 0) {
writeString(exc.getMessage());
if (i2 == EX_PARCELABLE) {
writeParcelable((Parcelable) exc);
}
} else if (exc instanceof RuntimeException) {
throw ((RuntimeException) exc);
} else {
throw new RuntimeException(exc);
}
}
/* access modifiers changed from: protected */
public void writeNoException() {
writeInt(0);
}
/* JADX WARNING: Code restructure failed: missing block: B:3:0x0007, code lost:
r2 = readExceptionCode();
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
public java.lang.Exception readException(java.lang.Exception r1, int r2) {
/*
r0 = this;
boolean r2 = r0.readField(r2)
if (r2 != 0) goto L_0x0007
return r1
L_0x0007:
int r2 = r0.readExceptionCode()
if (r2 == 0) goto L_0x0015
java.lang.String r1 = r0.readString()
java.lang.Exception r1 = r0.readException((int) r2, (java.lang.String) r1)
L_0x0015:
return r1
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.versionedparcelable.VersionedParcel.readException(java.lang.Exception, int):java.lang.Exception");
}
private int readExceptionCode() {
return readInt();
}
private Exception readException(int i, String str) {
return createException(i, str);
}
protected static Throwable getRootCause(Throwable th) {
while (th.getCause() != null) {
th = th.getCause();
}
return th;
}
private Exception createException(int i, String str) {
switch (i) {
case EX_PARCELABLE /*-9*/:
return (Exception) readParcelable();
case EX_UNSUPPORTED_OPERATION /*-7*/:
return new UnsupportedOperationException(str);
case EX_NETWORK_MAIN_THREAD /*-6*/:
return new NetworkOnMainThreadException();
case -5:
return new IllegalStateException(str);
case -4:
return new NullPointerException(str);
case -3:
return new IllegalArgumentException(str);
case -2:
return new BadParcelableException(str);
case -1:
return new SecurityException(str);
default:
return new RuntimeException("Unknown exception code: " + i + " msg " + str);
}
}
public byte readByte(byte b, int i) {
if (!readField(i)) {
return b;
}
return (byte) (readInt() & 255);
}
public Size readSize(Size size, int i) {
if (!readField(i)) {
return size;
}
if (readBoolean()) {
return new Size(readInt(), readInt());
}
return null;
}
public SizeF readSizeF(SizeF sizeF, int i) {
if (!readField(i)) {
return sizeF;
}
if (readBoolean()) {
return new SizeF(readFloat(), readFloat());
}
return null;
}
public SparseBooleanArray readSparseBooleanArray(SparseBooleanArray sparseBooleanArray, int i) {
if (!readField(i)) {
return sparseBooleanArray;
}
int readInt = readInt();
if (readInt < 0) {
return null;
}
SparseBooleanArray sparseBooleanArray2 = new SparseBooleanArray(readInt);
for (int i2 = 0; i2 < readInt; i2++) {
sparseBooleanArray2.put(readInt(), readBoolean());
}
return sparseBooleanArray2;
}
public <T> Set<T> readSet(Set<T> set, int i) {
if (!readField(i)) {
return set;
}
return (Set) readCollection(new ArraySet());
}
public <T> List<T> readList(List<T> list, int i) {
if (!readField(i)) {
return list;
}
return (List) readCollection(new ArrayList());
}
private <T, S extends Collection<T>> S readCollection(S s) {
int readInt = readInt();
if (readInt < 0) {
return null;
}
if (readInt != 0) {
int readInt2 = readInt();
if (readInt < 0) {
return null;
}
if (readInt2 == 1) {
while (readInt > 0) {
s.add(readVersionedParcelable());
readInt--;
}
} else if (readInt2 == 2) {
while (readInt > 0) {
s.add(readParcelable());
readInt--;
}
} else if (readInt2 == 3) {
while (readInt > 0) {
s.add(readSerializable());
readInt--;
}
} else if (readInt2 == 4) {
while (readInt > 0) {
s.add(readString());
readInt--;
}
} else if (readInt2 == 5) {
while (readInt > 0) {
s.add(readStrongBinder());
readInt--;
}
}
}
return s;
}
public <K, V> Map<K, V> readMap(Map<K, V> map, int i) {
if (!readField(i)) {
return map;
}
int readInt = readInt();
if (readInt < 0) {
return null;
}
ArrayMap arrayMap = new ArrayMap();
if (readInt == 0) {
return arrayMap;
}
ArrayList arrayList = new ArrayList();
ArrayList arrayList2 = new ArrayList();
readCollection(arrayList);
readCollection(arrayList2);
for (int i2 = 0; i2 < readInt; i2++) {
arrayMap.put(arrayList.get(i2), arrayList2.get(i2));
}
return arrayMap;
}
public <T> T[] readArray(T[] tArr, int i) {
if (!readField(i)) {
return tArr;
}
return readArray(tArr);
}
/* access modifiers changed from: protected */
public <T> T[] readArray(T[] tArr) {
int readInt = readInt();
if (readInt < 0) {
return null;
}
ArrayList arrayList = new ArrayList(readInt);
if (readInt != 0) {
int readInt2 = readInt();
if (readInt < 0) {
return null;
}
if (readInt2 == 1) {
while (readInt > 0) {
arrayList.add(readVersionedParcelable());
readInt--;
}
} else if (readInt2 == 2) {
while (readInt > 0) {
arrayList.add(readParcelable());
readInt--;
}
} else if (readInt2 == 3) {
while (readInt > 0) {
arrayList.add(readSerializable());
readInt--;
}
} else if (readInt2 == 4) {
while (readInt > 0) {
arrayList.add(readString());
readInt--;
}
} else if (readInt2 == 5) {
while (readInt > 0) {
arrayList.add(readStrongBinder());
readInt--;
}
}
}
return arrayList.toArray(tArr);
}
public <T extends VersionedParcelable> T readVersionedParcelable(T t, int i) {
if (!readField(i)) {
return t;
}
return readVersionedParcelable();
}
/* access modifiers changed from: protected */
public <T extends VersionedParcelable> T readVersionedParcelable() {
String readString = readString();
if (readString == null) {
return null;
}
return readFromParcel(readString, createSubParcel());
}
/* access modifiers changed from: protected */
public Serializable readSerializable() {
String readString = readString();
if (readString == null) {
return null;
}
try {
return (Serializable) new ObjectInputStream(new ByteArrayInputStream(readByteArray())) {
/* access modifiers changed from: protected */
public Class<?> resolveClass(ObjectStreamClass objectStreamClass) throws IOException, ClassNotFoundException {
Class<?> cls = Class.forName(objectStreamClass.getName(), false, getClass().getClassLoader());
if (cls != null) {
return cls;
}
return super.resolveClass(objectStreamClass);
}
}.readObject();
} catch (IOException e) {
throw new RuntimeException("VersionedParcelable encountered IOException reading a Serializable object (name = " + readString + ")", e);
} catch (ClassNotFoundException e2) {
throw new RuntimeException("VersionedParcelable encountered ClassNotFoundException reading a Serializable object (name = " + readString + ")", e2);
}
}
/* access modifiers changed from: protected */
public <T extends VersionedParcelable> T readFromParcel(String str, VersionedParcel versionedParcel) {
try {
return (VersionedParcelable) getReadMethod(str).invoke((Object) null, new Object[]{versionedParcel});
} catch (IllegalAccessException e) {
throw new RuntimeException("VersionedParcel encountered IllegalAccessException", e);
} catch (InvocationTargetException e2) {
if (e2.getCause() instanceof RuntimeException) {
throw ((RuntimeException) e2.getCause());
}
throw new RuntimeException("VersionedParcel encountered InvocationTargetException", e2);
} catch (NoSuchMethodException e3) {
throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", e3);
} catch (ClassNotFoundException e4) {
throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", e4);
}
}
/* access modifiers changed from: protected */
public <T extends VersionedParcelable> void writeToParcel(T t, VersionedParcel versionedParcel) {
try {
getWriteMethod(t.getClass()).invoke((Object) null, new Object[]{t, versionedParcel});
} catch (IllegalAccessException e) {
throw new RuntimeException("VersionedParcel encountered IllegalAccessException", e);
} catch (InvocationTargetException e2) {
if (e2.getCause() instanceof RuntimeException) {
throw ((RuntimeException) e2.getCause());
}
throw new RuntimeException("VersionedParcel encountered InvocationTargetException", e2);
} catch (NoSuchMethodException e3) {
throw new RuntimeException("VersionedParcel encountered NoSuchMethodException", e3);
} catch (ClassNotFoundException e4) {
throw new RuntimeException("VersionedParcel encountered ClassNotFoundException", e4);
}
}
private Method getReadMethod(String str) throws IllegalAccessException, NoSuchMethodException, ClassNotFoundException {
Class<VersionedParcel> cls = VersionedParcel.class;
Method method = this.mReadCache.get(str);
if (method != null) {
return method;
}
System.currentTimeMillis();
Method declaredMethod = Class.forName(str, true, cls.getClassLoader()).getDeclaredMethod("read", new Class[]{cls});
this.mReadCache.put(str, declaredMethod);
return declaredMethod;
}
private Method getWriteMethod(Class cls) throws IllegalAccessException, NoSuchMethodException, ClassNotFoundException {
Method method = this.mWriteCache.get(cls.getName());
if (method != null) {
return method;
}
Class findParcelClass = findParcelClass(cls);
System.currentTimeMillis();
Method declaredMethod = findParcelClass.getDeclaredMethod("write", new Class[]{cls, VersionedParcel.class});
this.mWriteCache.put(cls.getName(), declaredMethod);
return declaredMethod;
}
private Class findParcelClass(Class<? extends VersionedParcelable> cls) throws ClassNotFoundException {
Class cls2 = this.mParcelizerCache.get(cls.getName());
if (cls2 != null) {
return cls2;
}
Class<?> cls3 = Class.forName(String.format("%s.%sParcelizer", new Object[]{cls.getPackage().getName(), cls.getSimpleName()}), false, cls.getClassLoader());
this.mParcelizerCache.put(cls.getName(), cls3);
return cls3;
}
public static class ParcelException extends RuntimeException {
public ParcelException(Throwable th) {
super(th);
}
}
}
Download file