package andhook.lib.xposed;
import andhook.lib.AndHook;
import andhook.lib.xposed.XC_MethodHook;
import android.util.Log;
import i.am.jaggu;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
public final class XposedBridge {
public static final ClassLoader BOOTCLASSLOADER = ClassLoader.getSystemClassLoader();
private static final Object[] EMPTY_ARRAY = new Object[0];
public static final String TAG = "AndHook";
private static final ConcurrentHashMap<Member, AdditionalHookInfo> sHookedMethodInfos = new ConcurrentHashMap<>();
/* access modifiers changed from: private */
public static final class AdditionalHookInfo {
final CopyOnWriteSortedSet<XC_MethodHook> callbacks;
final Member method;
final int slot;
private AdditionalHookInfo(Member member, int i2) {
this.callbacks = new CopyOnWriteSortedSet<>();
this.method = member;
this.slot = i2;
}
}
public static final class CopyOnWriteSortedSet<E> {
private volatile transient Object[] elements = XposedBridge.EMPTY_ARRAY;
private int indexOf(Object obj) {
for (int i2 = 0; i2 < this.elements.length; i2++) {
if (obj.equals(this.elements[i2])) {
return i2;
}
}
return -1;
}
public synchronized boolean add(E e) {
if (indexOf(e) >= 0) {
return false;
}
Object[] objArr = new Object[(this.elements.length + 1)];
System.arraycopy(this.elements, 0, objArr, 0, this.elements.length);
objArr[this.elements.length] = e;
Arrays.sort(objArr);
this.elements = objArr;
return true;
}
public Object[] getSnapshot() {
return this.elements;
}
public synchronized boolean remove(E e) {
int indexOf = indexOf(e);
if (indexOf == -1) {
return false;
}
Object[] objArr = new Object[(this.elements.length - 1)];
System.arraycopy(this.elements, 0, objArr, 0, indexOf);
System.arraycopy(this.elements, indexOf + 1, objArr, indexOf, (this.elements.length - indexOf) - 1);
this.elements = objArr;
return true;
}
}
static {
AndHook.ensureNativeLibraryLoaded(null);
}
public static int getBackupSlot(Member member) {
AdditionalHookInfo additionalHookInfo = sHookedMethodInfos.get(member);
if (additionalHookInfo != null) {
return additionalHookInfo.slot;
}
return -1;
}
private static Object handleHookedMethod(Object obj, Object obj2, Object[] objArr) throws Throwable {
AdditionalHookInfo additionalHookInfo = (AdditionalHookInfo) obj;
Object[] snapshot = additionalHookInfo.callbacks.getSnapshot();
int length = snapshot.length;
if (length == 0) {
return invokeOriginalMethod(additionalHookInfo.slot, obj2, objArr);
}
XC_MethodHook.MethodHookParam methodHookParam = new XC_MethodHook.MethodHookParam();
methodHookParam.slot = additionalHookInfo.slot;
methodHookParam.method = additionalHookInfo.method;
methodHookParam.thisObject = obj2;
methodHookParam.args = objArr;
int i2 = 0;
while (true) {
try {
((XC_MethodHook) snapshot[i2]).beforeHookedMethod(methodHookParam);
if (methodHookParam.returnEarly) {
i2++;
break;
}
} catch (Throwable th) {
log(th);
methodHookParam.setResult(null);
methodHookParam.returnEarly = false;
}
i2++;
if (i2 >= length) {
break;
}
}
if (!methodHookParam.returnEarly) {
try {
methodHookParam.setResult(invokeOriginalMethod(additionalHookInfo.slot, methodHookParam.thisObject, methodHookParam.args));
} catch (Throwable th2) {
methodHookParam.setThrowable(th2);
}
}
int i3 = i2 - 1;
do {
Object result = methodHookParam.getResult();
Throwable throwable = methodHookParam.getThrowable();
try {
((XC_MethodHook) snapshot[i3]).afterHookedMethod(methodHookParam);
} catch (Throwable th3) {
log(th3);
if (throwable == null) {
methodHookParam.setResult(result);
} else {
methodHookParam.setThrowable(throwable);
}
}
i3--;
} while (i3 >= 0);
if (!methodHookParam.hasThrowable()) {
return methodHookParam.getResult();
}
throw methodHookParam.getThrowable();
}
public static HashSet<XC_MethodHook.Unhook> hookAllConstructors(Class<?> cls, XC_MethodHook xC_MethodHook) {
HashSet<XC_MethodHook.Unhook> hashSet = new HashSet<>();
for (Constructor<?> constructor : cls.getDeclaredConstructors()) {
hashSet.add(hookMethod(constructor, xC_MethodHook));
}
return hashSet;
}
public static HashSet<XC_MethodHook.Unhook> hookAllMethods(Class<?> cls, XC_MethodHook xC_MethodHook) {
HashSet<XC_MethodHook.Unhook> hashSet = new HashSet<>();
for (Method method : cls.getDeclaredMethods()) {
hashSet.add(hookMethod(method, xC_MethodHook));
}
return hashSet;
}
public static HashSet<XC_MethodHook.Unhook> hookAllMethods(Class<?> cls, String str, XC_MethodHook xC_MethodHook) {
HashSet<XC_MethodHook.Unhook> hashSet = new HashSet<>();
Method[] declaredMethods = cls.getDeclaredMethods();
for (Method method : declaredMethods) {
if (method.getName().equals(str)) {
hashSet.add(hookMethod(method, xC_MethodHook));
}
}
return hashSet;
}
public static XC_MethodHook.Unhook hookMethod(Member member, XC_MethodHook xC_MethodHook) {
if (!(member instanceof Method) && !(member instanceof Constructor)) {
throw new IllegalArgumentException(jaggu.base.decode("2C08094F17090644505F064141045A0213570E591242161050440C4045135A510D460753170C0C5F5355060841") + member.toString());
} else if (!Modifier.isAbstract(member.getModifiers())) {
AdditionalHookInfo additionalHookInfo = sHookedMethodInfos.get(member);
if (additionalHookInfo == null) {
if (Modifier.isStatic(member.getModifiers())) {
AndHook.ensureClassInitialized(member.getDeclaringClass());
}
additionalHookInfo = new AdditionalHookInfo(member, AndHook.backup(member));
if (additionalHookInfo.slot != -1) {
additionalHookInfo.callbacks.add(xC_MethodHook);
if (AndHook.hook(member, additionalHookInfo, additionalHookInfo.slot)) {
sHookedMethodInfos.put(member, additionalHookInfo);
} else {
throw new RuntimeException(jaggu.base.decode("25070C5A5200434457100A5D0E0E140B5640095805455E45") + member.toString());
}
} else {
throw new RuntimeException(jaggu.base.decode("25070C5A5200434457100053020E411613590443095900160910") + member.toString());
}
} else if (additionalHookInfo.method.getDeclaringClass().getClassLoader().equals(member.getDeclaringClass().getClassLoader())) {
additionalHookInfo.callbacks.add(xC_MethodHook);
} else {
throw new RuntimeException(jaggu.base.decode("3608004E470100445D544241000851465E51155F0E5217454459175A5F5D19540A00035345010D535D10217E5B45") + member.toString());
}
xC_MethodHook.getClass();
return new XC_MethodHook.Unhook(additionalHookInfo.method, additionalHookInfo.slot);
} else {
throw new IllegalArgumentException(jaggu.base.decode("20070B5858104358575F09120007471241550243415B01115B5F07410C13") + member.toString());
}
}
public static Object invokeOriginalMethod(int i2, Object obj, Object[] objArr) {
return AndHook.invoke(i2, obj, objArr);
}
public static Object invokeOriginalMethod(Member member, Object obj, Object[] objArr) {
int backupSlot = getBackupSlot(member);
if (backupSlot != -1) {
return invokeOriginalMethod(backupSlot, obj, objArr);
}
return null;
}
public static void log(String str) {
Log.i(jaggu.base.decode("2208017E580B08"), str);
}
public static void log(Throwable th) {
Log.e(jaggu.base.decode("2208017E580B08"), Log.getStackTraceString(th));
}
public static void unhookMethod(Member member, XC_MethodHook xC_MethodHook) {
AdditionalHookInfo additionalHookInfo = sHookedMethodInfos.get(member);
if (additionalHookInfo != null) {
additionalHookInfo.callbacks.remove(xC_MethodHook);
}
}
public static boolean unhookMethod(Member member, int i2) {
boolean restore = AndHook.restore(i2, member);
if (restore) {
sHookedMethodInfos.remove(member);
}
return restore;
}
}