CrackMe.apk
Download file
package com.google.android.gms.common.server.response;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.SparseArray;
import com.google.android.gms.common.internal.Preconditions;
import com.google.android.gms.common.internal.safeparcel.SafeParcelReader;
import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
import com.google.android.gms.common.server.response.FastJsonResponse;
import com.google.android.gms.common.util.ArrayUtils;
import com.google.android.gms.common.util.Base64Utils;
import com.google.android.gms.common.util.JsonUtils;
import com.google.android.gms.common.util.MapUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/* compiled from: com.google.android.gms:play-services-base@@18.0.1 */
public class SafeParcelResponse extends FastSafeParcelableJsonResponse {
public static final Parcelable.Creator<SafeParcelResponse> CREATOR = new zaq();
private final int zaa;
private final Parcel zab;
private final int zac;
private final zan zad;
private final String zae;
private int zaf;
private int zag;
SafeParcelResponse(int i, Parcel parcel, zan zan) {
this.zaa = i;
this.zab = (Parcel) Preconditions.checkNotNull(parcel);
this.zac = 2;
this.zad = zan;
this.zae = zan == null ? null : zan.zaa();
this.zaf = 2;
}
public static <T extends FastJsonResponse & SafeParcelable> SafeParcelResponse from(T t) {
zan zan = new zan(t.getClass());
zaF(zan, t);
zan.zac();
zan.zad();
return new SafeParcelResponse((SafeParcelable) t, zan, (String) Preconditions.checkNotNull(t.getClass().getCanonicalName()));
}
private static void zaF(zan zan, FastJsonResponse fastJsonResponse) {
Class<?> cls = fastJsonResponse.getClass();
if (!zan.zaf(cls)) {
Map<String, FastJsonResponse.Field<?, ?>> fieldMappings = fastJsonResponse.getFieldMappings();
zan.zae(cls, fieldMappings);
for (String str : fieldMappings.keySet()) {
FastJsonResponse.Field field = fieldMappings.get(str);
Class<? extends FastJsonResponse> cls2 = field.zag;
if (cls2 != null) {
try {
zaF(zan, (FastJsonResponse) cls2.newInstance());
} catch (InstantiationException e) {
String valueOf = String.valueOf(((Class) Preconditions.checkNotNull(field.zag)).getCanonicalName());
throw new IllegalStateException(valueOf.length() != 0 ? "Could not instantiate an object of type ".concat(valueOf) : new String("Could not instantiate an object of type "), e);
} catch (IllegalAccessException e2) {
String valueOf2 = String.valueOf(((Class) Preconditions.checkNotNull(field.zag)).getCanonicalName());
throw new IllegalStateException(valueOf2.length() != 0 ? "Could not access object of type ".concat(valueOf2) : new String("Could not access object of type "), e2);
}
}
}
}
}
private final void zaH(StringBuilder sb, Map<String, FastJsonResponse.Field<?, ?>> map, Parcel parcel) {
SparseArray sparseArray = new SparseArray();
for (Map.Entry next : map.entrySet()) {
sparseArray.put(((FastJsonResponse.Field) next.getValue()).getSafeParcelableFieldId(), next);
}
sb.append('{');
int validateObjectHeader = SafeParcelReader.validateObjectHeader(parcel);
boolean z = false;
while (parcel.dataPosition() < validateObjectHeader) {
int readHeader = SafeParcelReader.readHeader(parcel);
Map.Entry entry = (Map.Entry) sparseArray.get(SafeParcelReader.getFieldId(readHeader));
if (entry != null) {
if (z) {
sb.append(",");
}
FastJsonResponse.Field field = (FastJsonResponse.Field) entry.getValue();
sb.append("\"");
sb.append((String) entry.getKey());
sb.append("\":");
if (field.zaj()) {
int i = field.zac;
switch (i) {
case 0:
zaJ(sb, field, zaD(field, Integer.valueOf(SafeParcelReader.readInt(parcel, readHeader))));
break;
case 1:
zaJ(sb, field, zaD(field, SafeParcelReader.createBigInteger(parcel, readHeader)));
break;
case 2:
zaJ(sb, field, zaD(field, Long.valueOf(SafeParcelReader.readLong(parcel, readHeader))));
break;
case 3:
zaJ(sb, field, zaD(field, Float.valueOf(SafeParcelReader.readFloat(parcel, readHeader))));
break;
case 4:
zaJ(sb, field, zaD(field, Double.valueOf(SafeParcelReader.readDouble(parcel, readHeader))));
break;
case 5:
zaJ(sb, field, zaD(field, SafeParcelReader.createBigDecimal(parcel, readHeader)));
break;
case 6:
zaJ(sb, field, zaD(field, Boolean.valueOf(SafeParcelReader.readBoolean(parcel, readHeader))));
break;
case 7:
zaJ(sb, field, zaD(field, SafeParcelReader.createString(parcel, readHeader)));
break;
case 8:
case 9:
zaJ(sb, field, zaD(field, SafeParcelReader.createByteArray(parcel, readHeader)));
break;
case 10:
Bundle createBundle = SafeParcelReader.createBundle(parcel, readHeader);
HashMap hashMap = new HashMap();
for (String str : createBundle.keySet()) {
hashMap.put(str, (String) Preconditions.checkNotNull(createBundle.getString(str)));
}
zaJ(sb, field, zaD(field, hashMap));
break;
case 11:
throw new IllegalArgumentException("Method does not accept concrete type.");
default:
StringBuilder sb2 = new StringBuilder(36);
sb2.append("Unknown field out type = ");
sb2.append(i);
throw new IllegalArgumentException(sb2.toString());
}
} else if (field.zad) {
sb.append("[");
switch (field.zac) {
case 0:
ArrayUtils.writeArray(sb, SafeParcelReader.createIntArray(parcel, readHeader));
break;
case 1:
ArrayUtils.writeArray(sb, (T[]) SafeParcelReader.createBigIntegerArray(parcel, readHeader));
break;
case 2:
ArrayUtils.writeArray(sb, SafeParcelReader.createLongArray(parcel, readHeader));
break;
case 3:
ArrayUtils.writeArray(sb, SafeParcelReader.createFloatArray(parcel, readHeader));
break;
case 4:
ArrayUtils.writeArray(sb, SafeParcelReader.createDoubleArray(parcel, readHeader));
break;
case 5:
ArrayUtils.writeArray(sb, (T[]) SafeParcelReader.createBigDecimalArray(parcel, readHeader));
break;
case 6:
ArrayUtils.writeArray(sb, SafeParcelReader.createBooleanArray(parcel, readHeader));
break;
case 7:
ArrayUtils.writeStringArray(sb, SafeParcelReader.createStringArray(parcel, readHeader));
break;
case 8:
case 9:
case 10:
throw new UnsupportedOperationException("List of type BASE64, BASE64_URL_SAFE, or STRING_MAP is not supported");
case 11:
Parcel[] createParcelArray = SafeParcelReader.createParcelArray(parcel, readHeader);
int length = createParcelArray.length;
for (int i2 = 0; i2 < length; i2++) {
if (i2 > 0) {
sb.append(",");
}
createParcelArray[i2].setDataPosition(0);
zaH(sb, field.zah(), createParcelArray[i2]);
}
break;
default:
throw new IllegalStateException("Unknown field type out.");
}
sb.append("]");
} else {
switch (field.zac) {
case 0:
sb.append(SafeParcelReader.readInt(parcel, readHeader));
break;
case 1:
sb.append(SafeParcelReader.createBigInteger(parcel, readHeader));
break;
case 2:
sb.append(SafeParcelReader.readLong(parcel, readHeader));
break;
case 3:
sb.append(SafeParcelReader.readFloat(parcel, readHeader));
break;
case 4:
sb.append(SafeParcelReader.readDouble(parcel, readHeader));
break;
case 5:
sb.append(SafeParcelReader.createBigDecimal(parcel, readHeader));
break;
case 6:
sb.append(SafeParcelReader.readBoolean(parcel, readHeader));
break;
case 7:
String createString = SafeParcelReader.createString(parcel, readHeader);
sb.append("\"");
sb.append(JsonUtils.escapeString(createString));
sb.append("\"");
break;
case 8:
byte[] createByteArray = SafeParcelReader.createByteArray(parcel, readHeader);
sb.append("\"");
sb.append(Base64Utils.encode(createByteArray));
sb.append("\"");
break;
case 9:
byte[] createByteArray2 = SafeParcelReader.createByteArray(parcel, readHeader);
sb.append("\"");
sb.append(Base64Utils.encodeUrlSafe(createByteArray2));
sb.append("\"");
break;
case 10:
Bundle createBundle2 = SafeParcelReader.createBundle(parcel, readHeader);
Set<String> keySet = createBundle2.keySet();
sb.append("{");
boolean z2 = true;
for (String str2 : keySet) {
if (!z2) {
sb.append(",");
}
sb.append("\"");
sb.append(str2);
sb.append("\":\"");
sb.append(JsonUtils.escapeString(createBundle2.getString(str2)));
sb.append("\"");
z2 = false;
}
sb.append("}");
break;
case 11:
Parcel createParcel = SafeParcelReader.createParcel(parcel, readHeader);
createParcel.setDataPosition(0);
zaH(sb, field.zah(), createParcel);
break;
default:
throw new IllegalStateException("Unknown field type out");
}
}
z = true;
}
}
if (parcel.dataPosition() == validateObjectHeader) {
sb.append('}');
return;
}
StringBuilder sb3 = new StringBuilder(37);
sb3.append("Overread allowed size end=");
sb3.append(validateObjectHeader);
throw new SafeParcelReader.ParseException(sb3.toString(), parcel);
}
public final <T extends FastJsonResponse> void addConcreteTypeArrayInternal(FastJsonResponse.Field field, String str, ArrayList<T> arrayList) {
zaG(field);
ArrayList arrayList2 = new ArrayList();
((ArrayList) Preconditions.checkNotNull(arrayList)).size();
int size = arrayList.size();
for (int i = 0; i < size; i++) {
arrayList2.add(((SafeParcelResponse) ((FastJsonResponse) arrayList.get(i))).zaE());
}
SafeParcelWriter.writeParcelList(this.zab, field.getSafeParcelableFieldId(), arrayList2, true);
}
public final <T extends FastJsonResponse> void addConcreteTypeInternal(FastJsonResponse.Field field, String str, T t) {
zaG(field);
SafeParcelWriter.writeParcel(this.zab, field.getSafeParcelableFieldId(), ((SafeParcelResponse) t).zaE(), true);
}
public final Map<String, FastJsonResponse.Field<?, ?>> getFieldMappings() {
zan zan = this.zad;
if (zan == null) {
return null;
}
return zan.zab((String) Preconditions.checkNotNull(this.zae));
}
public final Object getValueObject(String str) {
throw new UnsupportedOperationException("Converting to JSON does not require this method.");
}
public final boolean isPrimitiveFieldSet(String str) {
throw new UnsupportedOperationException("Converting to JSON does not require this method.");
}
/* access modifiers changed from: protected */
public final void setBooleanInternal(FastJsonResponse.Field<?, ?> field, String str, boolean z) {
zaG(field);
SafeParcelWriter.writeBoolean(this.zab, field.getSafeParcelableFieldId(), z);
}
/* access modifiers changed from: protected */
public final void setDecodedBytesInternal(FastJsonResponse.Field<?, ?> field, String str, byte[] bArr) {
zaG(field);
SafeParcelWriter.writeByteArray(this.zab, field.getSafeParcelableFieldId(), bArr, true);
}
/* access modifiers changed from: protected */
public final void setIntegerInternal(FastJsonResponse.Field<?, ?> field, String str, int i) {
zaG(field);
SafeParcelWriter.writeInt(this.zab, field.getSafeParcelableFieldId(), i);
}
/* access modifiers changed from: protected */
public final void setLongInternal(FastJsonResponse.Field<?, ?> field, String str, long j) {
zaG(field);
SafeParcelWriter.writeLong(this.zab, field.getSafeParcelableFieldId(), j);
}
/* access modifiers changed from: protected */
public final void setStringInternal(FastJsonResponse.Field<?, ?> field, String str, String str2) {
zaG(field);
SafeParcelWriter.writeString(this.zab, field.getSafeParcelableFieldId(), str2, true);
}
/* access modifiers changed from: protected */
public final void setStringMapInternal(FastJsonResponse.Field<?, ?> field, String str, Map<String, String> map) {
zaG(field);
Bundle bundle = new Bundle();
for (String str2 : ((Map) Preconditions.checkNotNull(map)).keySet()) {
bundle.putString(str2, map.get(str2));
}
SafeParcelWriter.writeBundle(this.zab, field.getSafeParcelableFieldId(), bundle, true);
}
/* access modifiers changed from: protected */
public final void setStringsInternal(FastJsonResponse.Field<?, ?> field, String str, ArrayList<String> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
String[] strArr = new String[size];
for (int i = 0; i < size; i++) {
strArr[i] = arrayList.get(i);
}
SafeParcelWriter.writeStringArray(this.zab, field.getSafeParcelableFieldId(), strArr, true);
}
public final String toString() {
Preconditions.checkNotNull(this.zad, "Cannot convert to JSON on client side.");
Parcel zaE = zaE();
zaE.setDataPosition(0);
StringBuilder sb = new StringBuilder(100);
zaH(sb, (Map) Preconditions.checkNotNull(this.zad.zab((String) Preconditions.checkNotNull(this.zae))), zaE);
return sb.toString();
}
public final void writeToParcel(Parcel parcel, int i) {
zan zan;
int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
SafeParcelWriter.writeInt(parcel, 1, this.zaa);
SafeParcelWriter.writeParcel(parcel, 2, zaE(), false);
int i2 = this.zac;
if (i2 != 0) {
zan = i2 != 1 ? this.zad : this.zad;
} else {
zan = null;
}
SafeParcelWriter.writeParcelable(parcel, 3, zan, i, false);
SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
}
/* access modifiers changed from: protected */
public final void zab(FastJsonResponse.Field<?, ?> field, String str, BigDecimal bigDecimal) {
zaG(field);
SafeParcelWriter.writeBigDecimal(this.zab, field.getSafeParcelableFieldId(), bigDecimal, true);
}
/* access modifiers changed from: protected */
public final void zad(FastJsonResponse.Field<?, ?> field, String str, ArrayList<BigDecimal> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
BigDecimal[] bigDecimalArr = new BigDecimal[size];
for (int i = 0; i < size; i++) {
bigDecimalArr[i] = arrayList.get(i);
}
SafeParcelWriter.writeBigDecimalArray(this.zab, field.getSafeParcelableFieldId(), bigDecimalArr, true);
}
/* access modifiers changed from: protected */
public final void zaf(FastJsonResponse.Field<?, ?> field, String str, BigInteger bigInteger) {
zaG(field);
SafeParcelWriter.writeBigInteger(this.zab, field.getSafeParcelableFieldId(), bigInteger, true);
}
/* access modifiers changed from: protected */
public final void zah(FastJsonResponse.Field<?, ?> field, String str, ArrayList<BigInteger> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
BigInteger[] bigIntegerArr = new BigInteger[size];
for (int i = 0; i < size; i++) {
bigIntegerArr[i] = arrayList.get(i);
}
SafeParcelWriter.writeBigIntegerArray(this.zab, field.getSafeParcelableFieldId(), bigIntegerArr, true);
}
/* access modifiers changed from: protected */
public final void zak(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Boolean> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
boolean[] zArr = new boolean[size];
for (int i = 0; i < size; i++) {
zArr[i] = arrayList.get(i).booleanValue();
}
SafeParcelWriter.writeBooleanArray(this.zab, field.getSafeParcelableFieldId(), zArr, true);
}
/* access modifiers changed from: protected */
public final void zan(FastJsonResponse.Field<?, ?> field, String str, double d) {
zaG(field);
SafeParcelWriter.writeDouble(this.zab, field.getSafeParcelableFieldId(), d);
}
/* access modifiers changed from: protected */
public final void zap(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Double> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
double[] dArr = new double[size];
for (int i = 0; i < size; i++) {
dArr[i] = arrayList.get(i).doubleValue();
}
SafeParcelWriter.writeDoubleArray(this.zab, field.getSafeParcelableFieldId(), dArr, true);
}
/* access modifiers changed from: protected */
public final void zar(FastJsonResponse.Field<?, ?> field, String str, float f) {
zaG(field);
SafeParcelWriter.writeFloat(this.zab, field.getSafeParcelableFieldId(), f);
}
/* access modifiers changed from: protected */
public final void zat(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Float> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
float[] fArr = new float[size];
for (int i = 0; i < size; i++) {
fArr[i] = arrayList.get(i).floatValue();
}
SafeParcelWriter.writeFloatArray(this.zab, field.getSafeParcelableFieldId(), fArr, true);
}
/* access modifiers changed from: protected */
public final void zaw(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Integer> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
int[] iArr = new int[size];
for (int i = 0; i < size; i++) {
iArr[i] = arrayList.get(i).intValue();
}
SafeParcelWriter.writeIntArray(this.zab, field.getSafeParcelableFieldId(), iArr, true);
}
/* access modifiers changed from: protected */
public final void zaz(FastJsonResponse.Field<?, ?> field, String str, ArrayList<Long> arrayList) {
zaG(field);
int size = ((ArrayList) Preconditions.checkNotNull(arrayList)).size();
long[] jArr = new long[size];
for (int i = 0; i < size; i++) {
jArr[i] = arrayList.get(i).longValue();
}
SafeParcelWriter.writeLongArray(this.zab, field.getSafeParcelableFieldId(), jArr, true);
}
private SafeParcelResponse(SafeParcelable safeParcelable, zan zan, String str) {
this.zaa = 1;
Parcel obtain = Parcel.obtain();
this.zab = obtain;
safeParcelable.writeToParcel(obtain, 0);
this.zac = 1;
this.zad = (zan) Preconditions.checkNotNull(zan);
this.zae = (String) Preconditions.checkNotNull(str);
this.zaf = 2;
}
private final void zaG(FastJsonResponse.Field<?, ?> field) {
if (field.zaf != -1) {
Parcel parcel = this.zab;
if (parcel != null) {
int i = this.zaf;
if (i == 0) {
this.zag = SafeParcelWriter.beginObjectHeader(parcel);
this.zaf = 1;
} else if (i != 1) {
throw new IllegalStateException("Attempted to parse JSON with a SafeParcelResponse object that is already filled with data.");
}
} else {
throw new IllegalStateException("Internal Parcel object is null.");
}
} else {
throw new IllegalStateException("Field does not have a valid safe parcelable field id.");
}
}
private static final void zaJ(StringBuilder sb, FastJsonResponse.Field<?, ?> field, Object obj) {
if (field.zab) {
ArrayList arrayList = (ArrayList) obj;
sb.append("[");
int size = arrayList.size();
for (int i = 0; i < size; i++) {
if (i != 0) {
sb.append(",");
}
zaI(sb, field.zaa, arrayList.get(i));
}
sb.append("]");
return;
}
zaI(sb, field.zaa, obj);
}
public final Parcel zaE() {
int i = this.zaf;
if (i == 0) {
int beginObjectHeader = SafeParcelWriter.beginObjectHeader(this.zab);
this.zag = beginObjectHeader;
SafeParcelWriter.finishObjectHeader(this.zab, beginObjectHeader);
this.zaf = 2;
} else if (i == 1) {
SafeParcelWriter.finishObjectHeader(this.zab, this.zag);
this.zaf = 2;
}
return this.zab;
}
public SafeParcelResponse(zan zan, String str) {
this.zaa = 1;
this.zab = Parcel.obtain();
this.zac = 0;
this.zad = (zan) Preconditions.checkNotNull(zan);
this.zae = (String) Preconditions.checkNotNull(str);
this.zaf = 0;
}
private static final void zaI(StringBuilder sb, int i, Object obj) {
switch (i) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
sb.append(obj);
return;
case 7:
sb.append("\"");
sb.append(JsonUtils.escapeString(Preconditions.checkNotNull(obj).toString()));
sb.append("\"");
return;
case 8:
sb.append("\"");
sb.append(Base64Utils.encode((byte[]) obj));
sb.append("\"");
return;
case 9:
sb.append("\"");
sb.append(Base64Utils.encodeUrlSafe((byte[]) obj));
sb.append("\"");
return;
case 10:
MapUtils.writeStringMapToJson(sb, (HashMap) Preconditions.checkNotNull(obj));
return;
case 11:
throw new IllegalArgumentException("Method does not accept concrete type.");
default:
StringBuilder sb2 = new StringBuilder(26);
sb2.append("Unknown type = ");
sb2.append(i);
throw new IllegalArgumentException(sb2.toString());
}
}
}
Download file