681 lines
19 KiB
Java
681 lines
19 KiB
Java
package com.tencent.bugly.proguard;
|
|
|
|
import com.ijm.dataencryption.de.DataDecryptTool;
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.lang.reflect.Array;
|
|
import java.nio.BufferUnderflowException;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/* compiled from: BUGLY */
|
|
/* loaded from: classes.dex */
|
|
public final class i {
|
|
private ByteBuffer a;
|
|
private String b = "GBK";
|
|
|
|
/* compiled from: BUGLY */
|
|
public static class a {
|
|
public byte a;
|
|
public int b;
|
|
}
|
|
|
|
public i() {
|
|
}
|
|
|
|
private boolean[] d(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a != 9) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
boolean[] zArr = new boolean[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
zArr[i2] = a((byte) 0, 0, true) != 0;
|
|
}
|
|
return zArr;
|
|
}
|
|
|
|
private short[] e(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a != 9) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
short[] sArr = new short[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
sArr[i2] = a(sArr[0], 0, true);
|
|
}
|
|
return sArr;
|
|
}
|
|
|
|
private int[] f(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a != 9) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
int[] iArr = new int[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
iArr[i2] = a(iArr[0], 0, true);
|
|
}
|
|
return iArr;
|
|
}
|
|
|
|
private long[] g(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a != 9) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
long[] jArr = new long[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
jArr[i2] = a(jArr[0], 0, true);
|
|
}
|
|
return jArr;
|
|
}
|
|
|
|
private float[] h(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a != 9) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
float[] fArr = new float[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
fArr[i2] = a(fArr[0], 0, true);
|
|
}
|
|
return fArr;
|
|
}
|
|
|
|
private double[] i(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a != 9) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
double[] dArr = new double[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
dArr[i2] = a(dArr[0], 0, true);
|
|
}
|
|
return dArr;
|
|
}
|
|
|
|
public final void a(byte[] bArr) {
|
|
ByteBuffer byteBuffer = this.a;
|
|
if (byteBuffer != null) {
|
|
byteBuffer.clear();
|
|
}
|
|
this.a = ByteBuffer.wrap(bArr);
|
|
}
|
|
|
|
public final String b(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 6) {
|
|
int i2 = this.a.get();
|
|
if (i2 < 0) {
|
|
i2 += DataDecryptTool.DECRYPT_ALL_FILE;
|
|
}
|
|
byte[] bArr = new byte[i2];
|
|
this.a.get(bArr);
|
|
try {
|
|
return new String(bArr, this.b);
|
|
} catch (UnsupportedEncodingException unused) {
|
|
return new String(bArr);
|
|
}
|
|
}
|
|
if (b != 7) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
int i3 = this.a.getInt();
|
|
if (i3 > 104857600 || i3 < 0) {
|
|
throw new g("String too long: " + i3);
|
|
}
|
|
byte[] bArr2 = new byte[i3];
|
|
this.a.get(bArr2);
|
|
try {
|
|
return new String(bArr2, this.b);
|
|
} catch (UnsupportedEncodingException unused2) {
|
|
return new String(bArr2);
|
|
}
|
|
}
|
|
|
|
public final byte[] c(int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 9) {
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
byte[] bArr = new byte[a2];
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
bArr[i2] = a(bArr[0], 0, true);
|
|
}
|
|
return bArr;
|
|
}
|
|
if (b != 13) {
|
|
throw new g("type mismatch.");
|
|
}
|
|
a aVar2 = new a();
|
|
a(aVar2, this.a);
|
|
if (aVar2.a != 0) {
|
|
throw new g("type mismatch, tag: " + i + ", type: " + ((int) aVar.a) + ", " + ((int) aVar2.a));
|
|
}
|
|
int a3 = a(0, 0, true);
|
|
if (a3 >= 0) {
|
|
byte[] bArr2 = new byte[a3];
|
|
this.a.get(bArr2);
|
|
return bArr2;
|
|
}
|
|
throw new g("invalid size, tag: " + i + ", type: " + ((int) aVar.a) + ", " + ((int) aVar2.a) + ", size: " + a3);
|
|
}
|
|
|
|
public i(byte[] bArr) {
|
|
this.a = ByteBuffer.wrap(bArr);
|
|
}
|
|
|
|
private static int a(a aVar, ByteBuffer byteBuffer) {
|
|
byte b = byteBuffer.get();
|
|
aVar.a = (byte) (b & 15);
|
|
aVar.b = (b & 240) >> 4;
|
|
if (aVar.b != 15) {
|
|
return 1;
|
|
}
|
|
aVar.b = byteBuffer.get();
|
|
return 2;
|
|
}
|
|
|
|
public i(byte[] bArr, int i) {
|
|
this.a = ByteBuffer.wrap(bArr);
|
|
this.a.position(4);
|
|
}
|
|
|
|
private boolean a(int i) {
|
|
a aVar;
|
|
try {
|
|
aVar = new a();
|
|
while (true) {
|
|
int a2 = a(aVar, this.a.duplicate());
|
|
if (i <= aVar.b || aVar.a == 11) {
|
|
break;
|
|
}
|
|
this.a.position(this.a.position() + a2);
|
|
a(aVar.a);
|
|
}
|
|
} catch (g | BufferUnderflowException unused) {
|
|
}
|
|
return i == aVar.b;
|
|
}
|
|
|
|
private void a() {
|
|
a aVar = new a();
|
|
do {
|
|
a(aVar, this.a);
|
|
a(aVar.a);
|
|
} while (aVar.a != 11);
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
private <T> T[] b(T t, int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a == 9) {
|
|
int a2 = a(0, 0, true);
|
|
if (a2 >= 0) {
|
|
T[] tArr = (T[]) ((Object[]) Array.newInstance(t.getClass(), a2));
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
tArr[i2] = a((i) t, 0, true);
|
|
}
|
|
return tArr;
|
|
}
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
|
|
private void a(byte b) {
|
|
int i = 0;
|
|
switch (b) {
|
|
case 0:
|
|
ByteBuffer byteBuffer = this.a;
|
|
byteBuffer.position(byteBuffer.position() + 1);
|
|
return;
|
|
case 1:
|
|
ByteBuffer byteBuffer2 = this.a;
|
|
byteBuffer2.position(byteBuffer2.position() + 2);
|
|
return;
|
|
case 2:
|
|
ByteBuffer byteBuffer3 = this.a;
|
|
byteBuffer3.position(byteBuffer3.position() + 4);
|
|
return;
|
|
case 3:
|
|
ByteBuffer byteBuffer4 = this.a;
|
|
byteBuffer4.position(byteBuffer4.position() + 8);
|
|
return;
|
|
case 4:
|
|
ByteBuffer byteBuffer5 = this.a;
|
|
byteBuffer5.position(byteBuffer5.position() + 4);
|
|
return;
|
|
case 5:
|
|
ByteBuffer byteBuffer6 = this.a;
|
|
byteBuffer6.position(byteBuffer6.position() + 8);
|
|
return;
|
|
case 6:
|
|
int i2 = this.a.get();
|
|
if (i2 < 0) {
|
|
i2 += DataDecryptTool.DECRYPT_ALL_FILE;
|
|
}
|
|
ByteBuffer byteBuffer7 = this.a;
|
|
byteBuffer7.position(byteBuffer7.position() + i2);
|
|
return;
|
|
case 7:
|
|
int i3 = this.a.getInt();
|
|
ByteBuffer byteBuffer8 = this.a;
|
|
byteBuffer8.position(byteBuffer8.position() + i3);
|
|
return;
|
|
case 8:
|
|
int a2 = a(0, 0, true);
|
|
while (i < (a2 << 1)) {
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
a(aVar.a);
|
|
i++;
|
|
}
|
|
return;
|
|
case 9:
|
|
int a3 = a(0, 0, true);
|
|
while (i < a3) {
|
|
a aVar2 = new a();
|
|
a(aVar2, this.a);
|
|
a(aVar2.a);
|
|
i++;
|
|
}
|
|
return;
|
|
case 10:
|
|
a();
|
|
return;
|
|
case 11:
|
|
case 12:
|
|
return;
|
|
case 13:
|
|
a aVar3 = new a();
|
|
a(aVar3, this.a);
|
|
if (aVar3.a == 0) {
|
|
int a4 = a(0, 0, true);
|
|
ByteBuffer byteBuffer9 = this.a;
|
|
byteBuffer9.position(byteBuffer9.position() + a4);
|
|
return;
|
|
} else {
|
|
throw new g("skipField with invalid type, type value: " + ((int) b) + ", " + ((int) aVar3.a));
|
|
}
|
|
default:
|
|
throw new g("invalid type.");
|
|
}
|
|
}
|
|
|
|
public final boolean a(int i, boolean z) {
|
|
return a((byte) 0, i, z) != 0;
|
|
}
|
|
|
|
public final byte a(byte b, int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return b;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b2 = aVar.a;
|
|
if (b2 == 0) {
|
|
return this.a.get();
|
|
}
|
|
if (b2 == 12) {
|
|
return (byte) 0;
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
|
|
public final short a(short s, int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return s;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 0) {
|
|
return this.a.get();
|
|
}
|
|
if (b == 1) {
|
|
return this.a.getShort();
|
|
}
|
|
if (b == 12) {
|
|
return (short) 0;
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
|
|
public final int a(int i, int i2, boolean z) {
|
|
if (!a(i2)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return i;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 0) {
|
|
return this.a.get();
|
|
}
|
|
if (b == 1) {
|
|
return this.a.getShort();
|
|
}
|
|
if (b == 2) {
|
|
return this.a.getInt();
|
|
}
|
|
if (b == 12) {
|
|
return 0;
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
|
|
public final long a(long j, int i, boolean z) {
|
|
int i2;
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return j;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 0) {
|
|
i2 = this.a.get();
|
|
} else if (b == 1) {
|
|
i2 = this.a.getShort();
|
|
} else {
|
|
if (b != 2) {
|
|
if (b == 3) {
|
|
return this.a.getLong();
|
|
}
|
|
if (b == 12) {
|
|
return 0L;
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
i2 = this.a.getInt();
|
|
}
|
|
return i2;
|
|
}
|
|
|
|
private float a(float f, int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return f;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 4) {
|
|
return this.a.getFloat();
|
|
}
|
|
if (b == 12) {
|
|
return 0.0f;
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
|
|
private double a(double d, int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return d;
|
|
}
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
byte b = aVar.a;
|
|
if (b == 4) {
|
|
return this.a.getFloat();
|
|
}
|
|
if (b == 5) {
|
|
return this.a.getDouble();
|
|
}
|
|
if (b == 12) {
|
|
return 0.0d;
|
|
}
|
|
throw new g("type mismatch.");
|
|
}
|
|
|
|
public final <K, V> HashMap<K, V> a(Map<K, V> map, int i, boolean z) {
|
|
return (HashMap) a(new HashMap(), map, i, z);
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
private <K, V> Map<K, V> a(Map<K, V> map, Map<K, V> map2, int i, boolean z) {
|
|
if (map2 != null && !map2.isEmpty()) {
|
|
Map.Entry<K, V> next = map2.entrySet().iterator().next();
|
|
K key = next.getKey();
|
|
V value = next.getValue();
|
|
if (a(i)) {
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a == 8) {
|
|
int a2 = a(0, 0, true);
|
|
if (a2 < 0) {
|
|
throw new g("size invalid: " + a2);
|
|
}
|
|
for (int i2 = 0; i2 < a2; i2++) {
|
|
map.put(a((i) key, 0, true), a((i) value, 1, true));
|
|
}
|
|
} else {
|
|
throw new g("type mismatch.");
|
|
}
|
|
} else if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return map;
|
|
}
|
|
return new HashMap();
|
|
}
|
|
|
|
private <T> T[] a(T[] tArr, int i, boolean z) {
|
|
if (tArr != null && tArr.length != 0) {
|
|
return (T[]) b(tArr[0], i, z);
|
|
}
|
|
throw new g("unable to get type of key and value.");
|
|
}
|
|
|
|
public final k a(k kVar, int i, boolean z) {
|
|
if (!a(i)) {
|
|
if (z) {
|
|
throw new g("require field not exist.");
|
|
}
|
|
return null;
|
|
}
|
|
try {
|
|
k kVar2 = (k) kVar.getClass().newInstance();
|
|
a aVar = new a();
|
|
a(aVar, this.a);
|
|
if (aVar.a == 10) {
|
|
kVar2.a(this);
|
|
a();
|
|
return kVar2;
|
|
}
|
|
throw new g("type mismatch.");
|
|
} catch (Exception e) {
|
|
throw new g(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public final <T> Object a(T t, int i, boolean z) {
|
|
if (t instanceof Byte) {
|
|
return Byte.valueOf(a((byte) 0, i, z));
|
|
}
|
|
if (t instanceof Boolean) {
|
|
return Boolean.valueOf(a((byte) 0, i, z) != 0);
|
|
}
|
|
if (t instanceof Short) {
|
|
return Short.valueOf(a((short) 0, i, z));
|
|
}
|
|
if (t instanceof Integer) {
|
|
return Integer.valueOf(a(0, i, z));
|
|
}
|
|
if (t instanceof Long) {
|
|
return Long.valueOf(a(0L, i, z));
|
|
}
|
|
if (t instanceof Float) {
|
|
return Float.valueOf(a(0.0f, i, z));
|
|
}
|
|
if (t instanceof Double) {
|
|
return Double.valueOf(a(0.0d, i, z));
|
|
}
|
|
if (t instanceof String) {
|
|
return String.valueOf(b(i, z));
|
|
}
|
|
if (t instanceof Map) {
|
|
return (HashMap) a(new HashMap(), (Map) t, i, z);
|
|
}
|
|
if (t instanceof List) {
|
|
List list = (List) t;
|
|
if (list == null || list.isEmpty()) {
|
|
return new ArrayList();
|
|
}
|
|
Object[] b = b(list.get(0), i, z);
|
|
if (b == null) {
|
|
return null;
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
for (Object obj : b) {
|
|
arrayList.add(obj);
|
|
}
|
|
return arrayList;
|
|
}
|
|
if (t instanceof k) {
|
|
return a((k) t, i, z);
|
|
}
|
|
if (t.getClass().isArray()) {
|
|
if (!(t instanceof byte[]) && !(t instanceof Byte[])) {
|
|
if (t instanceof boolean[]) {
|
|
return d(i, z);
|
|
}
|
|
if (t instanceof short[]) {
|
|
return e(i, z);
|
|
}
|
|
if (t instanceof int[]) {
|
|
return f(i, z);
|
|
}
|
|
if (t instanceof long[]) {
|
|
return g(i, z);
|
|
}
|
|
if (t instanceof float[]) {
|
|
return h(i, z);
|
|
}
|
|
if (t instanceof double[]) {
|
|
return i(i, z);
|
|
}
|
|
return a((Object[]) t, i, z);
|
|
}
|
|
return c(i, z);
|
|
}
|
|
throw new g("read object error: unsupport type.");
|
|
}
|
|
|
|
public final int a(String str) {
|
|
this.b = str;
|
|
return 0;
|
|
}
|
|
}
|