());
+ if (result != null) result.removeAll(WHITE_LIST);
+ return result;
+ } catch (Throwable throwable) {
+ Utils.logE("error when reading black list", throwable);
+ return new HashSet<>();
+ }
+ }
+
+ public static void hook(ClassLoader classLoader) {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+ return;
+ }
+ try {
+ XposedHelpers.findAndHookMethod(ContextWrapper.class, "getSharedPreferences", String.class, int.class, new XC_MethodHook() {
+ @TargetApi(Build.VERSION_CODES.N)
+ @Override
+ protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
+ try {
+ String prefName = (String) param.args[0];
+ if (!prefName.equals(BLACK_LIST_PREF_NAME)) {
+ return;
+ }
+ Activity activity = (Activity) param.thisObject;
+ Context context = activity.createDeviceProtectedStorageContext();
+ context.moveSharedPreferencesFrom(activity, prefName);
+ param.setResult(context.getSharedPreferences(prefName, (int) param.args[1]));
+ } catch (Throwable throwable) {
+ Utils.logE("error hooking Xposed BlackList", throwable);
+ }
+ }
+ });
+ } catch (Throwable throwable) {
+ Utils.logE("error hooking Xposed BlackList", throwable);
+ }
+ }
+}
diff --git a/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/entry/hooker/XposedInstallerHooker.java b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/entry/hooker/XposedInstallerHooker.java
new file mode 100644
index 00000000..e3b83a77
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/entry/hooker/XposedInstallerHooker.java
@@ -0,0 +1,64 @@
+package com.elderdrivers.riru.edxp.sandhook.entry.hooker;
+
+import com.elderdrivers.riru.edxp.util.Utils;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import de.robv.android.xposed.XC_MethodHook;
+import de.robv.android.xposed.XC_MethodReplacement;
+import de.robv.android.xposed.XposedBridge;
+import de.robv.android.xposed.XposedHelpers;
+
+import static com.elderdrivers.riru.edxp.config.InstallerChooser.LEGACY_INSTALLER_PACKAGE_NAME;
+
+public class XposedInstallerHooker {
+
+ public static void hookXposedInstaller(ClassLoader classLoader) {
+ try {
+ final String xposedAppClass = LEGACY_INSTALLER_PACKAGE_NAME + ".XposedApp";
+ final Class InstallZipUtil = XposedHelpers.findClass(LEGACY_INSTALLER_PACKAGE_NAME
+ + ".util.InstallZipUtil", classLoader);
+ XposedHelpers.findAndHookMethod(xposedAppClass, classLoader, "getActiveXposedVersion",
+ XC_MethodReplacement.returnConstant(XposedBridge.getXposedVersion()));
+ XposedHelpers.findAndHookMethod(xposedAppClass, classLoader,
+ "reloadXposedProp", new XC_MethodHook() {
+ @Override
+ protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
+ Utils.logD("before reloadXposedProp...");
+ final String propFieldName = "mXposedProp";
+ final Object thisObject = param.thisObject;
+ if (XposedHelpers.getObjectField(thisObject, propFieldName) != null) {
+ param.setResult(null);
+ Utils.logD("reloadXposedProp already done, skip...");
+ return;
+ }
+ File file = new File("/system/framework/edconfig.jar");
+ FileInputStream is = null;
+ try {
+ is = new FileInputStream(file);
+ Object props = XposedHelpers.callStaticMethod(InstallZipUtil,
+ "parseXposedProp", is);
+ synchronized (thisObject) {
+ XposedHelpers.setObjectField(thisObject, propFieldName, props);
+ }
+ Utils.logD("reloadXposedProp done...");
+ param.setResult(null);
+ } catch (IOException e) {
+ Utils.logE("Could not read " + file.getPath(), e);
+ } finally {
+ if (is != null) {
+ try {
+ is.close();
+ } catch (IOException ignored) {
+ }
+ }
+ }
+ }
+ });
+ } catch (Throwable t) {
+ Utils.logE("Could not hook Xposed Installer", t);
+ }
+ }
+}
diff --git a/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/proxy/BlackWhiteListProxy.java b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/proxy/BlackWhiteListProxy.java
new file mode 100644
index 00000000..5ddfdc2a
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/proxy/BlackWhiteListProxy.java
@@ -0,0 +1,132 @@
+package com.elderdrivers.riru.edxp.sandhook.proxy;
+
+import android.text.TextUtils;
+
+import com.elderdrivers.riru.edxp.config.ConfigManager;
+import com.elderdrivers.riru.edxp.util.ProcessUtils;
+import com.elderdrivers.riru.edxp.util.Utils;
+import com.elderdrivers.riru.edxp.Main;
+import com.elderdrivers.riru.edxp.sandhook.entry.Router;
+import com.elderdrivers.riru.edxp.sandhook.util.PrebuiltMethodsDeopter;
+
+import de.robv.android.xposed.XposedBridge;
+
+import static com.elderdrivers.riru.edxp.util.FileUtils.getDataPathPrefix;
+import static com.elderdrivers.riru.edxp.Main.isAppNeedHook;
+
+/**
+ * 1. Non dynamic mode
+ * - system_server is whitelisted
+ * * for all child processes of main zygote
+ * What've been done in main zygote pre-forking system_server
+ * 1) non dynamic flag set (no need to reset)
+ * 2) boot image methods deopted (no need to redo)
+ * 3) startSystemServer flag set to true (need to reset)
+ * 4) workaround hooks installed (need to redo)
+ * 5) module list loaded and initZygote called (no need to redo)
+ * 6) close all fds (no need to redo because of 5))
+ * * for all child processes of secondary zygote
+ * 1) do the same things pre-forking first child process
+ * - system_server is blacklisted:
+ * * for all child processes of both main zygote and secondary zygote
+ * 1) do the same things pre-forking first child process
+ * 2. Dynamic mode:
+ * to be continued
+ */
+public class BlackWhiteListProxy {
+
+ public static void forkAndSpecializePre(int uid, int gid, int[] gids, int debugFlags,
+ int[][] rlimits, int mountExternal, String seInfo,
+ String niceName, int[] fdsToClose, int[] fdsToIgnore,
+ boolean startChildZygote, String instructionSet,
+ String appDataDir) {
+ final boolean isDynamicModulesMode = Main.isDynamicModulesEnabled();
+ if (isDynamicModulesMode) {
+ // should never happen
+ return;
+ }
+ // only enter here when isDynamicModulesMode is off
+ onForkPreForNonDynamicMode(false);
+ }
+
+ public static void forkAndSpecializePost(int pid, String appDataDir, String niceName) {
+ onForkPostCommon(false, appDataDir, niceName);
+ }
+
+ public static void forkSystemServerPre(int uid, int gid, int[] gids, int debugFlags,
+ int[][] rlimits, long permittedCapabilities,
+ long effectiveCapabilities) {
+ final boolean isDynamicModulesMode = Main.isDynamicModulesEnabled();
+ if (isDynamicModulesMode) {
+ // should never happen
+ return;
+ }
+ // only enter here when isDynamicModulesMode is off
+ onForkPreForNonDynamicMode(true);
+ }
+
+ public static void forkSystemServerPost(int pid) {
+ onForkPostCommon(true, getDataPathPrefix() + "android", "system_server");
+ }
+
+ /**
+ * Some details are different between main zygote and secondary zygote.
+ */
+ private static void onForkPreForNonDynamicMode(boolean isSystemServer) {
+ ConfigManager.setDynamicModulesMode(false);
+ // set startsSystemServer flag used when loadModules
+ Router.prepare(isSystemServer);
+ // deoptBootMethods once for all child processes of zygote
+ PrebuiltMethodsDeopter.deoptBootMethods();
+ // we never install bootstrap hooks here in black/white list mode except workaround hooks
+ // because installed hooks would be propagated to all child processes of zygote
+ Router.startWorkAroundHook();
+ // loadModules once for all child processes of zygote
+ // TODO maybe just save initZygote callbacks and call them when whitelisted process forked?
+ Router.loadModulesSafely(true);
+ Main.closeFilesBeforeForkNative();
+ }
+
+ private static void onForkPostCommon(boolean isSystemServer, String appDataDir, String niceName) {
+ Main.appDataDir = appDataDir;
+ Main.niceName = niceName;
+ final boolean isDynamicModulesMode = Main.isDynamicModulesEnabled();
+ ConfigManager.setDynamicModulesMode(isDynamicModulesMode);
+ Router.onEnterChildProcess();
+ if (!isDynamicModulesMode) {
+ Main.reopenFilesAfterForkNative();
+ }
+ if (!checkNeedHook(appDataDir, niceName)) {
+ // if is blacklisted, just stop here
+ return;
+ }
+ Router.prepare(isSystemServer);
+ PrebuiltMethodsDeopter.deoptBootMethods();
+ Router.installBootstrapHooks(isSystemServer);
+ if (isDynamicModulesMode) {
+ Router.loadModulesSafely(false);
+ }
+ }
+
+ private static boolean checkNeedHook(String appDataDir, String niceName) {
+ boolean needHook;
+ if (TextUtils.isEmpty(appDataDir)) {
+ Utils.logE("niceName:" + niceName + ", procName:"
+ + ProcessUtils.getCurrentProcessName(Main.appProcessName) + ", appDataDir is null, blacklisted!");
+ needHook = false;
+ } else {
+ // FIXME some process cannot read app_data_file because of MLS, e.g. bluetooth
+ needHook = isAppNeedHook(appDataDir);
+ }
+ if (!needHook) {
+ // clean up the scene
+ onBlackListed();
+ }
+ return needHook;
+ }
+
+ private static void onBlackListed() {
+ XposedBridge.clearLoadedPackages();
+ XposedBridge.clearInitPackageResources();
+ }
+}
diff --git a/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/proxy/NormalProxy.java b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/proxy/NormalProxy.java
new file mode 100644
index 00000000..b09ff554
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/proxy/NormalProxy.java
@@ -0,0 +1,70 @@
+package com.elderdrivers.riru.edxp.sandhook.proxy;
+
+import com.elderdrivers.riru.edxp.config.ConfigManager;
+import com.elderdrivers.riru.edxp.Main;
+import com.elderdrivers.riru.edxp.sandhook.entry.Router;
+import com.elderdrivers.riru.edxp.sandhook.util.PrebuiltMethodsDeopter;
+
+import static com.elderdrivers.riru.edxp.util.FileUtils.getDataPathPrefix;
+
+public class NormalProxy {
+
+ public static void forkAndSpecializePre(int uid, int gid, int[] gids, int debugFlags,
+ int[][] rlimits, int mountExternal, String seInfo,
+ String niceName, int[] fdsToClose, int[] fdsToIgnore,
+ boolean startChildZygote, String instructionSet,
+ String appDataDir) {
+ // mainly for secondary zygote
+ final boolean isDynamicModulesMode = Main.isDynamicModulesEnabled();
+ ConfigManager.setDynamicModulesMode(isDynamicModulesMode);
+ // call this to ensure the flag is set to false ASAP
+ Router.prepare(false);
+ PrebuiltMethodsDeopter.deoptBootMethods(); // do it once for secondary zygote
+ // install bootstrap hooks for secondary zygote
+ Router.installBootstrapHooks(false);
+ // only load modules for secondary zygote
+ Router.loadModulesSafely(true);
+ Main.closeFilesBeforeForkNative();
+ }
+
+ public static void forkAndSpecializePost(int pid, String appDataDir, String niceName) {
+ // TODO consider processes without forkAndSpecializePost called
+ Main.appDataDir = appDataDir;
+ Main.niceName = niceName;
+ Router.prepare(false);
+ Main.reopenFilesAfterForkNative();
+ Router.onEnterChildProcess();
+ // load modules for each app process on its forked if dynamic modules mode is on
+ Router.loadModulesSafely(false);
+ }
+
+ public static void forkSystemServerPre(int uid, int gid, int[] gids, int debugFlags, int[][] rlimits,
+ long permittedCapabilities, long effectiveCapabilities) {
+ final boolean isDynamicModulesMode = Main.isDynamicModulesEnabled();
+ ConfigManager.setDynamicModulesMode(isDynamicModulesMode);
+ // set startsSystemServer flag used when loadModules
+ Router.prepare(true);
+ PrebuiltMethodsDeopter.deoptBootMethods(); // do it once for main zygote
+ // install bootstrap hooks for main zygote as early as possible
+ // in case we miss some processes not forked via forkAndSpecialize
+ // for instance com.android.phone
+ Router.installBootstrapHooks(true);
+ // loadModules have to be executed in zygote even isDynamicModules is false
+ // because if not global hooks installed in initZygote might not be
+ // propagated to processes not forked via forkAndSpecialize
+ Router.loadModulesSafely(true);
+ Main.closeFilesBeforeForkNative();
+ }
+
+ public static void forkSystemServerPost(int pid) {
+ // in system_server process
+ Main.appDataDir = getDataPathPrefix() + "android";
+ Main.niceName = "system_server";
+ Router.prepare(true);
+ Main.reopenFilesAfterForkNative();
+ Router.onEnterChildProcess();
+ // reload module list if dynamic mode is on
+ Router.loadModulesSafely(false);
+ }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/util/InlinedMethodCallers.java b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/util/InlinedMethodCallers.java
new file mode 100644
index 00000000..4ef716e1
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/util/InlinedMethodCallers.java
@@ -0,0 +1,49 @@
+package com.elderdrivers.riru.edxp.sandhook.util;
+
+import java.util.HashMap;
+
+/**
+ * Providing a whitelist of methods which are the callers of the target methods we want to hook.
+ * Because the target methods are inlined into the callers, we deoptimize the callers to
+ * run in intercept mode to make target methods hookable.
+ *
+ * Only for methods which are included in pre-compiled framework codes.
+ * TODO recompile system apps and priv-apps since their original dex files are available
+ */
+public class InlinedMethodCallers {
+
+ public static final String KEY_BOOT_IMAGE = "boot_image";
+ public static final String KEY_SYSTEM_SERVER = "system_server";
+
+ /**
+ * Key should be {@link #KEY_BOOT_IMAGE}, {@link #KEY_SYSTEM_SERVER}, or a package name
+ * of system apps or priv-apps i.e. com.android.systemui
+ */
+ private static final HashMap CALLERS = new HashMap<>();
+
+ /**
+ * format for each row: {className, methodName, methodSig}
+ */
+ private static final String[][] BOOT_IMAGE = {
+ // callers of Application#attach(Context)
+ {"android.app.Instrumentation", "newApplication", "(Ljava/lang/ClassLoader;Ljava/lang/String;Landroid/content/Context;)Landroid/app/Application;"}
+ };
+
+ private static final String[][] SYSTEM_SERVER = {};
+
+ private static final String[][] SYSTEM_UI = {};
+
+ static {
+ CALLERS.put(KEY_BOOT_IMAGE, BOOT_IMAGE);
+ CALLERS.put(KEY_SYSTEM_SERVER, SYSTEM_SERVER);
+ CALLERS.put("com.android.systemui", SYSTEM_UI);
+ }
+
+ public static HashMap getAll() {
+ return CALLERS;
+ }
+
+ public static String[][] get(String where) {
+ return CALLERS.get(where);
+ }
+}
diff --git a/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/util/PrebuiltMethodsDeopter.java b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/util/PrebuiltMethodsDeopter.java
new file mode 100644
index 00000000..01f871b2
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/elderdrivers/riru/edxp/sandhook/util/PrebuiltMethodsDeopter.java
@@ -0,0 +1,41 @@
+package com.elderdrivers.riru.edxp.sandhook.util;
+
+import com.elderdrivers.riru.edxp.util.Utils;
+import com.elderdrivers.riru.edxp.Main;
+
+import java.util.Arrays;
+
+import de.robv.android.xposed.XposedHelpers;
+
+import static com.elderdrivers.riru.edxp.sandhook.util.InlinedMethodCallers.KEY_BOOT_IMAGE;
+import static com.elderdrivers.riru.edxp.sandhook.util.InlinedMethodCallers.KEY_SYSTEM_SERVER;
+
+public class PrebuiltMethodsDeopter {
+
+ public static void deoptMethods(String where, ClassLoader cl) {
+ String[][] callers = InlinedMethodCallers.get(where);
+ if (callers == null) {
+ return;
+ }
+ for (String[] caller : callers) {
+ try {
+ Object method = Main.findMethodNative(
+ XposedHelpers.findClass(caller[0], cl), caller[1], caller[2]);
+ if (method != null) {
+ Main.deoptMethodNative(method);
+ }
+ } catch (Throwable throwable) {
+ Utils.logE("error when deopting method: " + Arrays.toString(caller), throwable);
+ }
+ }
+ }
+
+ public static void deoptBootMethods() {
+ // todo check if has been done before
+ deoptMethods(KEY_BOOT_IMAGE, null);
+ }
+
+ public static void deoptSystemServerMethods(ClassLoader sysCL) {
+ deoptMethods(KEY_SYSTEM_SERVER, sysCL);
+ }
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/XposedCompat.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/XposedCompat.java
new file mode 100644
index 00000000..7b494b50
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/XposedCompat.java
@@ -0,0 +1,48 @@
+package com.swift.sandhook.xposedcompat;
+
+import com.swift.sandhook.xposedcompat.classloaders.ComposeClassLoader;
+import com.swift.sandhook.xposedcompat.methodgen.SandHookXposedBridge;
+import com.swift.sandhook.xposedcompat.utils.FileUtils;
+
+import java.io.File;
+import java.lang.reflect.Member;
+
+import de.robv.android.xposed.XposedBridge;
+
+public class XposedCompat {
+
+ //try to use internal stub hooker & backup method to speed up hook
+ public static volatile boolean useInternalStub = true;
+ public static volatile boolean useNewDexMaker = true;
+ public static volatile boolean retryWhenCallOriginError = false;
+
+ private static ClassLoader sandHookXposedClassLoader;
+
+ public static synchronized void hookMethod(Member hookMethod, XposedBridge.AdditionalHookInfo additionalHookInfo) {
+ SandHookXposedBridge.hookMethod(hookMethod, additionalHookInfo);
+ }
+
+ public static ClassLoader getSandHookXposedClassLoader(ClassLoader appOriginClassLoader, ClassLoader sandBoxHostClassLoader) {
+ if (sandHookXposedClassLoader != null) {
+ return sandHookXposedClassLoader;
+ } else {
+ sandHookXposedClassLoader = new ComposeClassLoader(sandBoxHostClassLoader, appOriginClassLoader);
+ return sandHookXposedClassLoader;
+ }
+ }
+
+// public static boolean clearCache() {
+// try {
+// FileUtils.delete(cacheDir);
+// cacheDir.mkdirs();
+// return true;
+// } catch (Throwable throwable) {
+// return false;
+// }
+// }
+//
+// public static void clearOatCache() {
+// SandHookXposedBridge.clearOatFile();
+// }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/classloaders/ComposeClassLoader.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/classloaders/ComposeClassLoader.java
new file mode 100644
index 00000000..6d968f6f
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/classloaders/ComposeClassLoader.java
@@ -0,0 +1,34 @@
+package com.swift.sandhook.xposedcompat.classloaders;
+
+/**
+ * Created by weishu on 17/11/30.
+ */
+
+public class ComposeClassLoader extends ClassLoader {
+
+ private final ClassLoader mAppClassLoader;
+ public ComposeClassLoader(ClassLoader parent, ClassLoader appClassLoader) {
+ super(parent);
+ mAppClassLoader = appClassLoader;
+ }
+
+ @Override
+ protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
+ Class clazz = null;
+
+ try {
+ clazz = mAppClassLoader.loadClass(name);
+ } catch (ClassNotFoundException e) {
+ // IGNORE.
+ }
+ if (clazz == null) {
+ clazz = super.loadClass(name, resolve);
+ }
+
+ if (clazz == null) {
+ throw new ClassNotFoundException();
+ }
+
+ return clazz;
+ }
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/CallOriginCallBack.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/CallOriginCallBack.java
new file mode 100644
index 00000000..65657ef3
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/CallOriginCallBack.java
@@ -0,0 +1,5 @@
+package com.swift.sandhook.xposedcompat.hookstub;
+
+public interface CallOriginCallBack {
+ long call(long... args) throws Throwable;
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/HookMethodEntity.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/HookMethodEntity.java
new file mode 100644
index 00000000..1436908c
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/HookMethodEntity.java
@@ -0,0 +1,93 @@
+package com.swift.sandhook.xposedcompat.hookstub;
+
+import com.swift.sandhook.SandHook;
+import com.swift.sandhook.utils.ParamWrapper;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+public class HookMethodEntity {
+
+ public Member origin;
+ public Method hook;
+ public Method backup;
+ public Class[] parType;
+ public Class retType;
+
+ public HookMethodEntity(Member origin, Method hook, Method backup) {
+ this.origin = origin;
+ this.hook = hook;
+ this.backup = backup;
+ }
+
+ public Object[] getArgs(long... addresses) {
+ if (addresses == null || addresses.length == 0)
+ return new Object[0];
+ if (parType == null || parType.length == 0)
+ return new Object[0];
+ int argStart = 0;
+ if (!isStatic()) {
+ argStart = 1;
+ }
+ Object[] args = new Object[parType.length];
+ for (int i = argStart;i < parType.length + argStart;i++) {
+ args[i - argStart] = getArg(i - argStart, addresses[i]);
+ }
+ return args;
+ }
+
+ public long[] getArgsAddress(long[] oldAddress, Object... args) {
+ if (oldAddress == null || oldAddress.length == 0)
+ return new long[0];
+ long[] addresses;
+ int argStart = 0;
+ if (!isStatic()) {
+ argStart = 1;
+ addresses = new long[oldAddress.length + 1];
+ addresses[0] = oldAddress[0];
+ } else {
+ addresses = new long[oldAddress.length];
+ }
+ for (int i = 0;i < parType.length;i++) {
+ addresses[i + argStart] = ParamWrapper.objectToAddress(parType[i], args[i]);
+ }
+ return addresses;
+ }
+
+ public Object getThis(long address) {
+ if (isStatic())
+ return null;
+ return SandHook.getObject(address);
+ }
+
+ public Object getArg(int index, long address) {
+ return ParamWrapper.addressToObject(parType[index], address);
+ }
+
+ public Object getResult(long address) {
+ if (isVoid())
+ return null;
+ return ParamWrapper.addressToObject(retType, address);
+ }
+
+ public long getResultAddress(Object result) {
+ if (isVoid())
+ return 0;
+ return ParamWrapper.objectToAddress(retType, result);
+ }
+
+ public boolean isVoid() {
+ return retType == null || Void.TYPE.equals(retType);
+ }
+
+ public boolean isConstructor() {
+ return origin instanceof Constructor;
+ }
+
+ public boolean isStatic() {
+ return Modifier.isStatic(origin.getModifiers());
+ }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/HookStubManager.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/HookStubManager.java
new file mode 100644
index 00000000..1b27ed4a
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/HookStubManager.java
@@ -0,0 +1,409 @@
+package com.swift.sandhook.xposedcompat.hookstub;
+
+import android.util.Log;
+
+import com.swift.sandhook.SandHook;
+import com.swift.sandhook.SandHookMethodResolver;
+import com.swift.sandhook.utils.ParamWrapper;
+import com.swift.sandhook.wrapper.BackupMethodStubs;
+import com.swift.sandhook.xposedcompat.utils.DexLog;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import de.robv.android.xposed.XC_MethodHook;
+import de.robv.android.xposed.XposedBridge;
+import de.robv.android.xposed.XposedHelpers;
+
+import static de.robv.android.xposed.XposedBridge.sHookedMethodCallbacks;
+
+public class HookStubManager {
+
+
+ public static int MAX_STUB_ARGS = 0;
+
+ public static int[] stubSizes;
+
+ public static boolean hasStubBackup = false;
+
+ public static AtomicInteger[] curUseStubIndexes;
+
+ public static int ALL_STUB = 0;
+
+ public static Member[] originMethods;
+ public static HookMethodEntity[] hookMethodEntities;
+
+ private static final Map> hookCallbacks
+ = sHookedMethodCallbacks;
+
+ static {
+ Class stubClass = SandHook.is64Bit() ? MethodHookerStubs64.class : MethodHookerStubs32.class;
+ stubSizes = (int[]) XposedHelpers.getStaticObjectField(stubClass, "stubSizes");
+ Boolean hasBackup = (Boolean) XposedHelpers.getStaticObjectField(stubClass, "hasStubBackup");
+ hasStubBackup = hasBackup == null ? false : hasBackup;
+ if (stubSizes != null && stubSizes.length > 0) {
+ MAX_STUB_ARGS = stubSizes.length - 1;
+ curUseStubIndexes = new AtomicInteger[MAX_STUB_ARGS + 1];
+ for (int i = 0; i < MAX_STUB_ARGS + 1; i++) {
+ curUseStubIndexes[i] = new AtomicInteger(0);
+ ALL_STUB += stubSizes[i];
+ }
+ originMethods = new Member[ALL_STUB];
+ hookMethodEntities = new HookMethodEntity[ALL_STUB];
+ }
+ }
+
+
+ public static HookMethodEntity getHookMethodEntity(Member origin) {
+
+ if (!support()) {
+ return null;
+ }
+
+ Class[] parType;
+ Class retType;
+ boolean isStatic = Modifier.isStatic(origin.getModifiers());
+
+ if (origin instanceof Method) {
+ Method method = (Method) origin;
+ retType = method.getReturnType();
+ parType = method.getParameterTypes();
+ } else if (origin instanceof Constructor) {
+ Constructor constructor = (Constructor) origin;
+ retType = Void.TYPE;
+ parType = constructor.getParameterTypes();
+ } else {
+ return null;
+ }
+
+ if (!ParamWrapper.support(retType))
+ return null;
+
+ int needStubArgCount = isStatic ? 0 : 1;
+
+ if (parType != null) {
+ needStubArgCount += parType.length;
+ if (needStubArgCount > MAX_STUB_ARGS)
+ return null;
+ for (Class par:parType) {
+ if (!ParamWrapper.support(par))
+ return null;
+ }
+ } else {
+ parType = new Class[0];
+ }
+
+ synchronized (HookStubManager.class) {
+ StubMethodsInfo stubMethodInfo = getStubMethodPair(SandHook.is64Bit(), needStubArgCount);
+ if (stubMethodInfo == null)
+ return null;
+ HookMethodEntity entity = new HookMethodEntity(origin, stubMethodInfo.hook, stubMethodInfo.backup);
+ entity.retType = retType;
+ entity.parType = parType;
+ int id = getMethodId(stubMethodInfo.args, stubMethodInfo.index);
+ originMethods[id] = origin;
+ hookMethodEntities[id] = entity;
+ if (hasStubBackup && !tryCompileAndResolveCallOriginMethod(entity.backup, stubMethodInfo.args, stubMethodInfo.index)) {
+ DexLog.w("internal stub <" + entity.hook.getName() + "> call origin compile failure, skip use internal stub");
+ return null;
+ } else {
+ return entity;
+ }
+ }
+ }
+
+ public static int getMethodId(int args, int index) {
+ int id = index;
+ for (int i = 0;i < args;i++) {
+ id += stubSizes[i];
+ }
+ return id;
+ }
+
+ public static String getHookMethodName(int index) {
+ return "stub_hook_" + index;
+ }
+
+ public static String getBackupMethodName(int index) {
+ return "stub_backup_" + index;
+ }
+
+ public static String getCallOriginClassName(int args, int index) {
+ return "call_origin_" + args + "_" + index;
+ }
+
+
+ static class StubMethodsInfo {
+ int args = 0;
+ int index = 0;
+ Method hook;
+ Method backup;
+
+ public StubMethodsInfo(int args, int index, Method hook, Method backup) {
+ this.args = args;
+ this.index = index;
+ this.hook = hook;
+ this.backup = backup;
+ }
+ }
+
+ private static synchronized StubMethodsInfo getStubMethodPair(boolean is64Bit, int stubArgs) {
+
+ stubArgs = getMatchStubArgsCount(stubArgs);
+
+ if (stubArgs < 0)
+ return null;
+
+ int curUseStubIndex = curUseStubIndexes[stubArgs].getAndIncrement();
+ Class[] pars = getFindMethodParTypes(is64Bit, stubArgs);
+ try {
+ if (is64Bit) {
+ Method hook = MethodHookerStubs64.class.getDeclaredMethod(getHookMethodName(curUseStubIndex), pars);
+ Method backup = hasStubBackup ? MethodHookerStubs64.class.getDeclaredMethod(getBackupMethodName(curUseStubIndex), pars) : BackupMethodStubs.getStubMethod();
+ if (hook == null || backup == null)
+ return null;
+ return new StubMethodsInfo(stubArgs, curUseStubIndex, hook, backup);
+ } else {
+ Method hook = MethodHookerStubs32.class.getDeclaredMethod(getHookMethodName(curUseStubIndex), pars);
+ Method backup = hasStubBackup ? MethodHookerStubs32.class.getDeclaredMethod(getBackupMethodName(curUseStubIndex), pars) : BackupMethodStubs.getStubMethod();
+ if (hook == null || backup == null)
+ return null;
+ return new StubMethodsInfo(stubArgs, curUseStubIndex, hook, backup);
+ }
+ } catch (Throwable throwable) {
+ return null;
+ }
+ }
+
+ public static Method getCallOriginMethod(int args, int index) {
+ Class stubClass = SandHook.is64Bit() ? MethodHookerStubs64.class : MethodHookerStubs32.class;
+ String className = stubClass.getName();
+ className += "$";
+ className += getCallOriginClassName(args, index);
+ try {
+ Class callOriginClass = Class.forName(className, true, stubClass.getClassLoader());
+ return callOriginClass.getDeclaredMethod("call", long[].class);
+ } catch (Throwable e) {
+ Log.e("HookStubManager", "load call origin class error!", e);
+ return null;
+ }
+ }
+
+ public static boolean tryCompileAndResolveCallOriginMethod(Method backupMethod, int args, int index) {
+ Method method = getCallOriginMethod(args, index);
+ if (method != null) {
+ SandHookMethodResolver.resolveMethod(method, backupMethod);
+ return SandHook.compileMethod(method);
+ } else {
+ return false;
+ }
+ }
+
+ public static int getMatchStubArgsCount(int stubArgs) {
+ for (int i = stubArgs;i <= MAX_STUB_ARGS;i++) {
+ if (curUseStubIndexes[i].get() < stubSizes[i])
+ return i;
+ }
+ return -1;
+ }
+
+ public static Class[] getFindMethodParTypes(boolean is64Bit, int stubArgs) {
+ if (stubArgs == 0)
+ return null;
+ Class[] args = new Class[stubArgs];
+ if (is64Bit) {
+ for (int i = 0;i < stubArgs;i++) {
+ args[i] = long.class;
+ }
+ } else {
+ for (int i = 0;i < stubArgs;i++) {
+ args[i] = int.class;
+ }
+ }
+ return args;
+ }
+
+ public static long hookBridge(int id, CallOriginCallBack callOrigin, long... stubArgs) throws Throwable {
+
+ Member originMethod = originMethods[id];
+ HookMethodEntity entity = hookMethodEntities[id];
+
+ Object thiz = null;
+ Object[] args = null;
+
+ if (hasArgs(stubArgs)) {
+ thiz = entity.getThis(stubArgs[0]);
+ args = entity.getArgs(stubArgs);
+ }
+
+ if (XposedBridge.disableHooks) {
+ if (hasStubBackup) {
+ return callOrigin.call(stubArgs);
+ } else {
+ return callOrigin(entity, originMethod, thiz, args);
+ }
+ }
+
+ DexLog.printMethodHookIn(originMethod);
+
+ Object[] snapshot = hookCallbacks.get(originMethod).getSnapshot();
+ if (snapshot == null || snapshot.length == 0) {
+ if (hasStubBackup) {
+ return callOrigin.call(stubArgs);
+ } else {
+ return callOrigin(entity, originMethod, thiz, args);
+ }
+ }
+
+ XC_MethodHook.MethodHookParam param = new XC_MethodHook.MethodHookParam();
+
+ param.method = originMethod;
+ param.thisObject = thiz;
+ param.args = args;
+
+ int beforeIdx = 0;
+ do {
+ try {
+ ((XC_MethodHook) snapshot[beforeIdx]).callBeforeHookedMethod(param);
+ } catch (Throwable t) {
+ // reset result (ignoring what the unexpectedly exiting callback did)
+ param.setResult(null);
+ param.returnEarly = false;
+ continue;
+ }
+
+ if (param.returnEarly) {
+ // skip remaining "before" callbacks and corresponding "after" callbacks
+ beforeIdx++;
+ break;
+ }
+ } while (++beforeIdx < snapshot.length);
+
+ // call original method if not requested otherwise
+ if (!param.returnEarly) {
+ try {
+ if (hasStubBackup) {
+ //prepare new args
+ long[] newArgs = entity.getArgsAddress(stubArgs, param.args);
+ param.setResult(entity.getResult(callOrigin.call(newArgs)));
+ } else {
+ param.setResult(SandHook.callOriginMethod(originMethod, thiz, param.args));
+ }
+ } catch (Throwable e) {
+ XposedBridge.log(e);
+ param.setThrowable(e);
+ }
+ }
+
+ // call "after method" callbacks
+ int afterIdx = beforeIdx - 1;
+ do {
+ Object lastResult = param.getResult();
+ Throwable lastThrowable = param.getThrowable();
+
+ try {
+ ((XC_MethodHook) snapshot[afterIdx]).callAfterHookedMethod(param);
+ } catch (Throwable t) {
+ XposedBridge.log(t);
+ if (lastThrowable == null)
+ param.setResult(lastResult);
+ else
+ param.setThrowable(lastThrowable);
+ }
+ } while (--afterIdx >= 0);
+ if (!param.hasThrowable()) {
+ return entity.getResultAddress(param.getResult());
+ } else {
+ throw param.getThrowable();
+ }
+ }
+
+ public static Object hookBridge(Member origin, Object thiz, Object... args) throws Throwable {
+
+
+ if (XposedBridge.disableHooks) {
+ return SandHook.callOriginMethod(origin, thiz, args);
+ }
+
+ DexLog.printMethodHookIn(origin);
+
+ Object[] snapshot = hookCallbacks.get(origin).getSnapshot();
+ if (snapshot == null || snapshot.length == 0) {
+ return SandHook.callOriginMethod(origin, thiz, args);
+ }
+
+ XC_MethodHook.MethodHookParam param = new XC_MethodHook.MethodHookParam();
+
+ param.method = origin;
+ param.thisObject = thiz;
+ param.args = args;
+
+ int beforeIdx = 0;
+ do {
+ try {
+ ((XC_MethodHook) snapshot[beforeIdx]).callBeforeHookedMethod(param);
+ } catch (Throwable t) {
+ // reset result (ignoring what the unexpectedly exiting callback did)
+ param.setResult(null);
+ param.returnEarly = false;
+ continue;
+ }
+
+ if (param.returnEarly) {
+ // skip remaining "before" callbacks and corresponding "after" callbacks
+ beforeIdx++;
+ break;
+ }
+ } while (++beforeIdx < snapshot.length);
+
+ // call original method if not requested otherwise
+ if (!param.returnEarly) {
+ try {
+ param.setResult(SandHook.callOriginMethod(origin, thiz, param.args));
+ } catch (Throwable e) {
+ XposedBridge.log(e);
+ param.setThrowable(e);
+ }
+ }
+
+ // call "after method" callbacks
+ int afterIdx = beforeIdx - 1;
+ do {
+ Object lastResult = param.getResult();
+ Throwable lastThrowable = param.getThrowable();
+
+ try {
+ ((XC_MethodHook) snapshot[afterIdx]).callAfterHookedMethod(param);
+ } catch (Throwable t) {
+ XposedBridge.log(t);
+ if (lastThrowable == null)
+ param.setResult(lastResult);
+ else
+ param.setThrowable(lastThrowable);
+ }
+ } while (--afterIdx >= 0);
+ if (!param.hasThrowable()) {
+ return param.getResult();
+ } else {
+ throw param.getThrowable();
+ }
+ }
+
+ public static long callOrigin(HookMethodEntity entity, Member origin, Object thiz, Object[] args) throws Throwable {
+ Object res = SandHook.callOriginMethod(origin, thiz, args);
+ return entity.getResultAddress(res);
+ }
+
+ private static boolean hasArgs(long... args) {
+ return args != null && args.length > 0;
+ }
+
+ public static boolean support() {
+ return MAX_STUB_ARGS > 0 && SandHook.canGetObject() && SandHook.canGetObjectAddress();
+ }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/MethodHookerStubs32.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/MethodHookerStubs32.java
new file mode 100644
index 00000000..573eb4aa
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/MethodHookerStubs32.java
@@ -0,0 +1,1413 @@
+package com.swift.sandhook.xposedcompat.hookstub;
+
+import static com.swift.sandhook.xposedcompat.hookstub.HookStubManager.getMethodId;
+import static com.swift.sandhook.xposedcompat.hookstub.HookStubManager.hookBridge;
+
+/**
+* this file is auto gen by genhookstubs.py
+* it is for sandhook internal hooker & backup methods
+**/
+public class MethodHookerStubs32 {
+
+ public static boolean hasStubBackup = false;
+ public static int[] stubSizes = {10, 20, 30, 30, 30, 30, 30, 20, 10, 10, 5, 5, 3};
+
+
+ //stub of arg size 0, index 0
+ public static int stub_hook_0() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 0), null );
+ }
+
+
+ //stub of arg size 0, index 1
+ public static int stub_hook_1() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 1), null );
+ }
+
+
+ //stub of arg size 0, index 2
+ public static int stub_hook_2() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 2), null );
+ }
+
+
+ //stub of arg size 0, index 3
+ public static int stub_hook_3() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 3), null );
+ }
+
+
+ //stub of arg size 0, index 4
+ public static int stub_hook_4() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 4), null );
+ }
+
+
+ //stub of arg size 0, index 5
+ public static int stub_hook_5() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 5), null );
+ }
+
+
+ //stub of arg size 0, index 6
+ public static int stub_hook_6() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 6), null );
+ }
+
+
+ //stub of arg size 0, index 7
+ public static int stub_hook_7() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 7), null );
+ }
+
+
+ //stub of arg size 0, index 8
+ public static int stub_hook_8() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 8), null );
+ }
+
+
+ //stub of arg size 0, index 9
+ public static int stub_hook_9() throws Throwable {
+ return (int) hookBridge(getMethodId(0, 9), null );
+ }
+
+
+ //stub of arg size 1, index 0
+ public static int stub_hook_0(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 0), null , a0);
+ }
+
+
+ //stub of arg size 1, index 1
+ public static int stub_hook_1(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 1), null , a0);
+ }
+
+
+ //stub of arg size 1, index 2
+ public static int stub_hook_2(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 2), null , a0);
+ }
+
+
+ //stub of arg size 1, index 3
+ public static int stub_hook_3(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 3), null , a0);
+ }
+
+
+ //stub of arg size 1, index 4
+ public static int stub_hook_4(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 4), null , a0);
+ }
+
+
+ //stub of arg size 1, index 5
+ public static int stub_hook_5(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 5), null , a0);
+ }
+
+
+ //stub of arg size 1, index 6
+ public static int stub_hook_6(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 6), null , a0);
+ }
+
+
+ //stub of arg size 1, index 7
+ public static int stub_hook_7(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 7), null , a0);
+ }
+
+
+ //stub of arg size 1, index 8
+ public static int stub_hook_8(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 8), null , a0);
+ }
+
+
+ //stub of arg size 1, index 9
+ public static int stub_hook_9(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 9), null , a0);
+ }
+
+
+ //stub of arg size 1, index 10
+ public static int stub_hook_10(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 10), null , a0);
+ }
+
+
+ //stub of arg size 1, index 11
+ public static int stub_hook_11(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 11), null , a0);
+ }
+
+
+ //stub of arg size 1, index 12
+ public static int stub_hook_12(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 12), null , a0);
+ }
+
+
+ //stub of arg size 1, index 13
+ public static int stub_hook_13(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 13), null , a0);
+ }
+
+
+ //stub of arg size 1, index 14
+ public static int stub_hook_14(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 14), null , a0);
+ }
+
+
+ //stub of arg size 1, index 15
+ public static int stub_hook_15(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 15), null , a0);
+ }
+
+
+ //stub of arg size 1, index 16
+ public static int stub_hook_16(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 16), null , a0);
+ }
+
+
+ //stub of arg size 1, index 17
+ public static int stub_hook_17(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 17), null , a0);
+ }
+
+
+ //stub of arg size 1, index 18
+ public static int stub_hook_18(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 18), null , a0);
+ }
+
+
+ //stub of arg size 1, index 19
+ public static int stub_hook_19(int a0) throws Throwable {
+ return (int) hookBridge(getMethodId(1, 19), null , a0);
+ }
+
+
+ //stub of arg size 2, index 0
+ public static int stub_hook_0(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 0), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 1
+ public static int stub_hook_1(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 1), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 2
+ public static int stub_hook_2(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 2), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 3
+ public static int stub_hook_3(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 3), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 4
+ public static int stub_hook_4(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 4), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 5
+ public static int stub_hook_5(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 5), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 6
+ public static int stub_hook_6(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 6), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 7
+ public static int stub_hook_7(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 7), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 8
+ public static int stub_hook_8(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 8), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 9
+ public static int stub_hook_9(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 9), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 10
+ public static int stub_hook_10(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 10), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 11
+ public static int stub_hook_11(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 11), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 12
+ public static int stub_hook_12(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 12), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 13
+ public static int stub_hook_13(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 13), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 14
+ public static int stub_hook_14(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 14), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 15
+ public static int stub_hook_15(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 15), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 16
+ public static int stub_hook_16(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 16), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 17
+ public static int stub_hook_17(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 17), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 18
+ public static int stub_hook_18(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 18), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 19
+ public static int stub_hook_19(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 19), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 20
+ public static int stub_hook_20(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 20), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 21
+ public static int stub_hook_21(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 21), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 22
+ public static int stub_hook_22(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 22), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 23
+ public static int stub_hook_23(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 23), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 24
+ public static int stub_hook_24(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 24), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 25
+ public static int stub_hook_25(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 25), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 26
+ public static int stub_hook_26(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 26), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 27
+ public static int stub_hook_27(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 27), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 28
+ public static int stub_hook_28(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 28), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 29
+ public static int stub_hook_29(int a0, int a1) throws Throwable {
+ return (int) hookBridge(getMethodId(2, 29), null , a0, a1);
+ }
+
+
+ //stub of arg size 3, index 0
+ public static int stub_hook_0(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 0), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 1
+ public static int stub_hook_1(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 1), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 2
+ public static int stub_hook_2(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 2), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 3
+ public static int stub_hook_3(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 3), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 4
+ public static int stub_hook_4(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 4), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 5
+ public static int stub_hook_5(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 5), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 6
+ public static int stub_hook_6(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 6), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 7
+ public static int stub_hook_7(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 7), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 8
+ public static int stub_hook_8(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 8), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 9
+ public static int stub_hook_9(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 9), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 10
+ public static int stub_hook_10(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 10), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 11
+ public static int stub_hook_11(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 11), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 12
+ public static int stub_hook_12(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 12), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 13
+ public static int stub_hook_13(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 13), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 14
+ public static int stub_hook_14(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 14), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 15
+ public static int stub_hook_15(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 15), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 16
+ public static int stub_hook_16(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 16), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 17
+ public static int stub_hook_17(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 17), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 18
+ public static int stub_hook_18(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 18), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 19
+ public static int stub_hook_19(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 19), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 20
+ public static int stub_hook_20(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 20), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 21
+ public static int stub_hook_21(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 21), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 22
+ public static int stub_hook_22(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 22), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 23
+ public static int stub_hook_23(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 23), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 24
+ public static int stub_hook_24(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 24), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 25
+ public static int stub_hook_25(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 25), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 26
+ public static int stub_hook_26(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 26), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 27
+ public static int stub_hook_27(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 27), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 28
+ public static int stub_hook_28(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 28), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 29
+ public static int stub_hook_29(int a0, int a1, int a2) throws Throwable {
+ return (int) hookBridge(getMethodId(3, 29), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 4, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 0), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 1), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 2), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 3), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 4), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 5
+ public static int stub_hook_5(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 5), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 6
+ public static int stub_hook_6(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 6), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 7
+ public static int stub_hook_7(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 7), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 8
+ public static int stub_hook_8(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 8), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 9
+ public static int stub_hook_9(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 9), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 10
+ public static int stub_hook_10(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 10), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 11
+ public static int stub_hook_11(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 11), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 12
+ public static int stub_hook_12(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 12), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 13
+ public static int stub_hook_13(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 13), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 14
+ public static int stub_hook_14(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 14), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 15
+ public static int stub_hook_15(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 15), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 16
+ public static int stub_hook_16(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 16), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 17
+ public static int stub_hook_17(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 17), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 18
+ public static int stub_hook_18(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 18), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 19
+ public static int stub_hook_19(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 19), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 20
+ public static int stub_hook_20(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 20), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 21
+ public static int stub_hook_21(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 21), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 22
+ public static int stub_hook_22(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 22), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 23
+ public static int stub_hook_23(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 23), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 24
+ public static int stub_hook_24(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 24), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 25
+ public static int stub_hook_25(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 25), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 26
+ public static int stub_hook_26(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 26), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 27
+ public static int stub_hook_27(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 27), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 28
+ public static int stub_hook_28(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 28), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 29
+ public static int stub_hook_29(int a0, int a1, int a2, int a3) throws Throwable {
+ return (int) hookBridge(getMethodId(4, 29), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 5, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 0), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 1), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 2), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 3), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 4), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 5
+ public static int stub_hook_5(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 5), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 6
+ public static int stub_hook_6(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 6), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 7
+ public static int stub_hook_7(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 7), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 8
+ public static int stub_hook_8(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 8), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 9
+ public static int stub_hook_9(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 9), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 10
+ public static int stub_hook_10(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 10), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 11
+ public static int stub_hook_11(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 11), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 12
+ public static int stub_hook_12(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 12), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 13
+ public static int stub_hook_13(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 13), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 14
+ public static int stub_hook_14(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 14), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 15
+ public static int stub_hook_15(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 15), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 16
+ public static int stub_hook_16(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 16), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 17
+ public static int stub_hook_17(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 17), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 18
+ public static int stub_hook_18(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 18), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 19
+ public static int stub_hook_19(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 19), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 20
+ public static int stub_hook_20(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 20), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 21
+ public static int stub_hook_21(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 21), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 22
+ public static int stub_hook_22(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 22), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 23
+ public static int stub_hook_23(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 23), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 24
+ public static int stub_hook_24(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 24), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 25
+ public static int stub_hook_25(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 25), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 26
+ public static int stub_hook_26(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 26), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 27
+ public static int stub_hook_27(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 27), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 28
+ public static int stub_hook_28(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 28), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 29
+ public static int stub_hook_29(int a0, int a1, int a2, int a3, int a4) throws Throwable {
+ return (int) hookBridge(getMethodId(5, 29), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 6, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 0), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 1), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 2), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 3), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 4), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 5
+ public static int stub_hook_5(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 5), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 6
+ public static int stub_hook_6(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 6), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 7
+ public static int stub_hook_7(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 7), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 8
+ public static int stub_hook_8(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 8), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 9
+ public static int stub_hook_9(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 9), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 10
+ public static int stub_hook_10(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 10), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 11
+ public static int stub_hook_11(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 11), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 12
+ public static int stub_hook_12(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 12), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 13
+ public static int stub_hook_13(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 13), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 14
+ public static int stub_hook_14(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 14), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 15
+ public static int stub_hook_15(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 15), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 16
+ public static int stub_hook_16(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 16), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 17
+ public static int stub_hook_17(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 17), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 18
+ public static int stub_hook_18(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 18), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 19
+ public static int stub_hook_19(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 19), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 20
+ public static int stub_hook_20(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 20), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 21
+ public static int stub_hook_21(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 21), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 22
+ public static int stub_hook_22(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 22), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 23
+ public static int stub_hook_23(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 23), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 24
+ public static int stub_hook_24(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 24), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 25
+ public static int stub_hook_25(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 25), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 26
+ public static int stub_hook_26(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 26), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 27
+ public static int stub_hook_27(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 27), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 28
+ public static int stub_hook_28(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 28), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 29
+ public static int stub_hook_29(int a0, int a1, int a2, int a3, int a4, int a5) throws Throwable {
+ return (int) hookBridge(getMethodId(6, 29), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 7, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 0), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 1), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 2), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 3), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 4), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 5
+ public static int stub_hook_5(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 5), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 6
+ public static int stub_hook_6(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 6), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 7
+ public static int stub_hook_7(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 7), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 8
+ public static int stub_hook_8(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 8), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 9
+ public static int stub_hook_9(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 9), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 10
+ public static int stub_hook_10(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 10), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 11
+ public static int stub_hook_11(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 11), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 12
+ public static int stub_hook_12(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 12), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 13
+ public static int stub_hook_13(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 13), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 14
+ public static int stub_hook_14(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 14), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 15
+ public static int stub_hook_15(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 15), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 16
+ public static int stub_hook_16(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 16), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 17
+ public static int stub_hook_17(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 17), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 18
+ public static int stub_hook_18(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 18), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 19
+ public static int stub_hook_19(int a0, int a1, int a2, int a3, int a4, int a5, int a6) throws Throwable {
+ return (int) hookBridge(getMethodId(7, 19), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 8, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 0), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 1), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 2), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 3), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 4), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 5
+ public static int stub_hook_5(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 5), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 6
+ public static int stub_hook_6(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 6), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 7
+ public static int stub_hook_7(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 7), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 8
+ public static int stub_hook_8(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 8), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 9
+ public static int stub_hook_9(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7) throws Throwable {
+ return (int) hookBridge(getMethodId(8, 9), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 9, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 3), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 4), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 5
+ public static int stub_hook_5(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 5), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 6
+ public static int stub_hook_6(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 6), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 7
+ public static int stub_hook_7(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 7), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 8
+ public static int stub_hook_8(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 8), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 9
+ public static int stub_hook_9(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) throws Throwable {
+ return (int) hookBridge(getMethodId(9, 9), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 10, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9) throws Throwable {
+ return (int) hookBridge(getMethodId(10, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9) throws Throwable {
+ return (int) hookBridge(getMethodId(10, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9) throws Throwable {
+ return (int) hookBridge(getMethodId(10, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9) throws Throwable {
+ return (int) hookBridge(getMethodId(10, 3), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9) throws Throwable {
+ return (int) hookBridge(getMethodId(10, 4), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 11, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) throws Throwable {
+ return (int) hookBridge(getMethodId(11, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) throws Throwable {
+ return (int) hookBridge(getMethodId(11, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) throws Throwable {
+ return (int) hookBridge(getMethodId(11, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 3
+ public static int stub_hook_3(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) throws Throwable {
+ return (int) hookBridge(getMethodId(11, 3), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 4
+ public static int stub_hook_4(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10) throws Throwable {
+ return (int) hookBridge(getMethodId(11, 4), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 12, index 0
+ public static int stub_hook_0(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11) throws Throwable {
+ return (int) hookBridge(getMethodId(12, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+ }
+
+
+ //stub of arg size 12, index 1
+ public static int stub_hook_1(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11) throws Throwable {
+ return (int) hookBridge(getMethodId(12, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+ }
+
+
+ //stub of arg size 12, index 2
+ public static int stub_hook_2(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11) throws Throwable {
+ return (int) hookBridge(getMethodId(12, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+ }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/MethodHookerStubs64.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/MethodHookerStubs64.java
new file mode 100644
index 00000000..17887583
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/hookstub/MethodHookerStubs64.java
@@ -0,0 +1,1413 @@
+package com.swift.sandhook.xposedcompat.hookstub;
+
+import static com.swift.sandhook.xposedcompat.hookstub.HookStubManager.getMethodId;
+import static com.swift.sandhook.xposedcompat.hookstub.HookStubManager.hookBridge;
+
+/**
+* this file is auto gen by genhookstubs.py
+* it is for sandhook internal hooker & backup methods
+**/
+public class MethodHookerStubs64 {
+
+ public static boolean hasStubBackup = false;
+ public static int[] stubSizes = {10, 20, 30, 30, 30, 30, 30, 20, 10, 10, 5, 5, 3};
+
+
+ //stub of arg size 0, index 0
+ public static long stub_hook_0() throws Throwable {
+ return hookBridge(getMethodId(0, 0), null );
+ }
+
+
+ //stub of arg size 0, index 1
+ public static long stub_hook_1() throws Throwable {
+ return hookBridge(getMethodId(0, 1), null );
+ }
+
+
+ //stub of arg size 0, index 2
+ public static long stub_hook_2() throws Throwable {
+ return hookBridge(getMethodId(0, 2), null );
+ }
+
+
+ //stub of arg size 0, index 3
+ public static long stub_hook_3() throws Throwable {
+ return hookBridge(getMethodId(0, 3), null );
+ }
+
+
+ //stub of arg size 0, index 4
+ public static long stub_hook_4() throws Throwable {
+ return hookBridge(getMethodId(0, 4), null );
+ }
+
+
+ //stub of arg size 0, index 5
+ public static long stub_hook_5() throws Throwable {
+ return hookBridge(getMethodId(0, 5), null );
+ }
+
+
+ //stub of arg size 0, index 6
+ public static long stub_hook_6() throws Throwable {
+ return hookBridge(getMethodId(0, 6), null );
+ }
+
+
+ //stub of arg size 0, index 7
+ public static long stub_hook_7() throws Throwable {
+ return hookBridge(getMethodId(0, 7), null );
+ }
+
+
+ //stub of arg size 0, index 8
+ public static long stub_hook_8() throws Throwable {
+ return hookBridge(getMethodId(0, 8), null );
+ }
+
+
+ //stub of arg size 0, index 9
+ public static long stub_hook_9() throws Throwable {
+ return hookBridge(getMethodId(0, 9), null );
+ }
+
+
+ //stub of arg size 1, index 0
+ public static long stub_hook_0(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 0), null , a0);
+ }
+
+
+ //stub of arg size 1, index 1
+ public static long stub_hook_1(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 1), null , a0);
+ }
+
+
+ //stub of arg size 1, index 2
+ public static long stub_hook_2(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 2), null , a0);
+ }
+
+
+ //stub of arg size 1, index 3
+ public static long stub_hook_3(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 3), null , a0);
+ }
+
+
+ //stub of arg size 1, index 4
+ public static long stub_hook_4(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 4), null , a0);
+ }
+
+
+ //stub of arg size 1, index 5
+ public static long stub_hook_5(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 5), null , a0);
+ }
+
+
+ //stub of arg size 1, index 6
+ public static long stub_hook_6(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 6), null , a0);
+ }
+
+
+ //stub of arg size 1, index 7
+ public static long stub_hook_7(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 7), null , a0);
+ }
+
+
+ //stub of arg size 1, index 8
+ public static long stub_hook_8(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 8), null , a0);
+ }
+
+
+ //stub of arg size 1, index 9
+ public static long stub_hook_9(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 9), null , a0);
+ }
+
+
+ //stub of arg size 1, index 10
+ public static long stub_hook_10(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 10), null , a0);
+ }
+
+
+ //stub of arg size 1, index 11
+ public static long stub_hook_11(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 11), null , a0);
+ }
+
+
+ //stub of arg size 1, index 12
+ public static long stub_hook_12(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 12), null , a0);
+ }
+
+
+ //stub of arg size 1, index 13
+ public static long stub_hook_13(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 13), null , a0);
+ }
+
+
+ //stub of arg size 1, index 14
+ public static long stub_hook_14(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 14), null , a0);
+ }
+
+
+ //stub of arg size 1, index 15
+ public static long stub_hook_15(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 15), null , a0);
+ }
+
+
+ //stub of arg size 1, index 16
+ public static long stub_hook_16(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 16), null , a0);
+ }
+
+
+ //stub of arg size 1, index 17
+ public static long stub_hook_17(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 17), null , a0);
+ }
+
+
+ //stub of arg size 1, index 18
+ public static long stub_hook_18(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 18), null , a0);
+ }
+
+
+ //stub of arg size 1, index 19
+ public static long stub_hook_19(long a0) throws Throwable {
+ return hookBridge(getMethodId(1, 19), null , a0);
+ }
+
+
+ //stub of arg size 2, index 0
+ public static long stub_hook_0(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 0), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 1
+ public static long stub_hook_1(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 1), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 2
+ public static long stub_hook_2(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 2), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 3
+ public static long stub_hook_3(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 3), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 4
+ public static long stub_hook_4(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 4), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 5
+ public static long stub_hook_5(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 5), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 6
+ public static long stub_hook_6(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 6), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 7
+ public static long stub_hook_7(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 7), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 8
+ public static long stub_hook_8(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 8), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 9
+ public static long stub_hook_9(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 9), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 10
+ public static long stub_hook_10(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 10), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 11
+ public static long stub_hook_11(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 11), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 12
+ public static long stub_hook_12(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 12), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 13
+ public static long stub_hook_13(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 13), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 14
+ public static long stub_hook_14(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 14), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 15
+ public static long stub_hook_15(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 15), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 16
+ public static long stub_hook_16(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 16), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 17
+ public static long stub_hook_17(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 17), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 18
+ public static long stub_hook_18(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 18), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 19
+ public static long stub_hook_19(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 19), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 20
+ public static long stub_hook_20(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 20), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 21
+ public static long stub_hook_21(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 21), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 22
+ public static long stub_hook_22(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 22), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 23
+ public static long stub_hook_23(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 23), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 24
+ public static long stub_hook_24(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 24), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 25
+ public static long stub_hook_25(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 25), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 26
+ public static long stub_hook_26(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 26), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 27
+ public static long stub_hook_27(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 27), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 28
+ public static long stub_hook_28(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 28), null , a0, a1);
+ }
+
+
+ //stub of arg size 2, index 29
+ public static long stub_hook_29(long a0, long a1) throws Throwable {
+ return hookBridge(getMethodId(2, 29), null , a0, a1);
+ }
+
+
+ //stub of arg size 3, index 0
+ public static long stub_hook_0(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 0), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 1
+ public static long stub_hook_1(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 1), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 2
+ public static long stub_hook_2(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 2), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 3
+ public static long stub_hook_3(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 3), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 4
+ public static long stub_hook_4(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 4), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 5
+ public static long stub_hook_5(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 5), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 6
+ public static long stub_hook_6(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 6), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 7
+ public static long stub_hook_7(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 7), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 8
+ public static long stub_hook_8(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 8), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 9
+ public static long stub_hook_9(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 9), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 10
+ public static long stub_hook_10(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 10), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 11
+ public static long stub_hook_11(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 11), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 12
+ public static long stub_hook_12(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 12), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 13
+ public static long stub_hook_13(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 13), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 14
+ public static long stub_hook_14(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 14), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 15
+ public static long stub_hook_15(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 15), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 16
+ public static long stub_hook_16(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 16), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 17
+ public static long stub_hook_17(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 17), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 18
+ public static long stub_hook_18(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 18), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 19
+ public static long stub_hook_19(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 19), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 20
+ public static long stub_hook_20(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 20), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 21
+ public static long stub_hook_21(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 21), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 22
+ public static long stub_hook_22(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 22), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 23
+ public static long stub_hook_23(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 23), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 24
+ public static long stub_hook_24(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 24), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 25
+ public static long stub_hook_25(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 25), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 26
+ public static long stub_hook_26(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 26), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 27
+ public static long stub_hook_27(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 27), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 28
+ public static long stub_hook_28(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 28), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 3, index 29
+ public static long stub_hook_29(long a0, long a1, long a2) throws Throwable {
+ return hookBridge(getMethodId(3, 29), null , a0, a1, a2);
+ }
+
+
+ //stub of arg size 4, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 0), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 1), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 2), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 3), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 4), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 5
+ public static long stub_hook_5(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 5), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 6
+ public static long stub_hook_6(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 6), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 7
+ public static long stub_hook_7(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 7), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 8
+ public static long stub_hook_8(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 8), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 9
+ public static long stub_hook_9(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 9), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 10
+ public static long stub_hook_10(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 10), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 11
+ public static long stub_hook_11(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 11), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 12
+ public static long stub_hook_12(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 12), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 13
+ public static long stub_hook_13(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 13), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 14
+ public static long stub_hook_14(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 14), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 15
+ public static long stub_hook_15(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 15), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 16
+ public static long stub_hook_16(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 16), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 17
+ public static long stub_hook_17(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 17), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 18
+ public static long stub_hook_18(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 18), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 19
+ public static long stub_hook_19(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 19), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 20
+ public static long stub_hook_20(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 20), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 21
+ public static long stub_hook_21(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 21), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 22
+ public static long stub_hook_22(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 22), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 23
+ public static long stub_hook_23(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 23), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 24
+ public static long stub_hook_24(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 24), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 25
+ public static long stub_hook_25(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 25), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 26
+ public static long stub_hook_26(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 26), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 27
+ public static long stub_hook_27(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 27), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 28
+ public static long stub_hook_28(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 28), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 4, index 29
+ public static long stub_hook_29(long a0, long a1, long a2, long a3) throws Throwable {
+ return hookBridge(getMethodId(4, 29), null , a0, a1, a2, a3);
+ }
+
+
+ //stub of arg size 5, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 0), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 1), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 2), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 3), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 4), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 5
+ public static long stub_hook_5(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 5), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 6
+ public static long stub_hook_6(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 6), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 7
+ public static long stub_hook_7(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 7), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 8
+ public static long stub_hook_8(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 8), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 9
+ public static long stub_hook_9(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 9), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 10
+ public static long stub_hook_10(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 10), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 11
+ public static long stub_hook_11(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 11), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 12
+ public static long stub_hook_12(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 12), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 13
+ public static long stub_hook_13(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 13), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 14
+ public static long stub_hook_14(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 14), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 15
+ public static long stub_hook_15(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 15), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 16
+ public static long stub_hook_16(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 16), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 17
+ public static long stub_hook_17(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 17), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 18
+ public static long stub_hook_18(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 18), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 19
+ public static long stub_hook_19(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 19), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 20
+ public static long stub_hook_20(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 20), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 21
+ public static long stub_hook_21(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 21), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 22
+ public static long stub_hook_22(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 22), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 23
+ public static long stub_hook_23(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 23), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 24
+ public static long stub_hook_24(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 24), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 25
+ public static long stub_hook_25(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 25), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 26
+ public static long stub_hook_26(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 26), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 27
+ public static long stub_hook_27(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 27), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 28
+ public static long stub_hook_28(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 28), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 5, index 29
+ public static long stub_hook_29(long a0, long a1, long a2, long a3, long a4) throws Throwable {
+ return hookBridge(getMethodId(5, 29), null , a0, a1, a2, a3, a4);
+ }
+
+
+ //stub of arg size 6, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 0), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 1), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 2), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 3), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 4), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 5
+ public static long stub_hook_5(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 5), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 6
+ public static long stub_hook_6(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 6), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 7
+ public static long stub_hook_7(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 7), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 8
+ public static long stub_hook_8(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 8), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 9
+ public static long stub_hook_9(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 9), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 10
+ public static long stub_hook_10(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 10), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 11
+ public static long stub_hook_11(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 11), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 12
+ public static long stub_hook_12(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 12), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 13
+ public static long stub_hook_13(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 13), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 14
+ public static long stub_hook_14(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 14), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 15
+ public static long stub_hook_15(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 15), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 16
+ public static long stub_hook_16(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 16), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 17
+ public static long stub_hook_17(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 17), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 18
+ public static long stub_hook_18(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 18), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 19
+ public static long stub_hook_19(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 19), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 20
+ public static long stub_hook_20(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 20), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 21
+ public static long stub_hook_21(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 21), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 22
+ public static long stub_hook_22(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 22), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 23
+ public static long stub_hook_23(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 23), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 24
+ public static long stub_hook_24(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 24), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 25
+ public static long stub_hook_25(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 25), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 26
+ public static long stub_hook_26(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 26), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 27
+ public static long stub_hook_27(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 27), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 28
+ public static long stub_hook_28(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 28), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 6, index 29
+ public static long stub_hook_29(long a0, long a1, long a2, long a3, long a4, long a5) throws Throwable {
+ return hookBridge(getMethodId(6, 29), null , a0, a1, a2, a3, a4, a5);
+ }
+
+
+ //stub of arg size 7, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 0), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 1), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 2), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 3), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 4), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 5
+ public static long stub_hook_5(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 5), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 6
+ public static long stub_hook_6(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 6), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 7
+ public static long stub_hook_7(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 7), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 8
+ public static long stub_hook_8(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 8), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 9
+ public static long stub_hook_9(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 9), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 10
+ public static long stub_hook_10(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 10), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 11
+ public static long stub_hook_11(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 11), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 12
+ public static long stub_hook_12(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 12), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 13
+ public static long stub_hook_13(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 13), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 14
+ public static long stub_hook_14(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 14), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 15
+ public static long stub_hook_15(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 15), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 16
+ public static long stub_hook_16(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 16), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 17
+ public static long stub_hook_17(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 17), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 18
+ public static long stub_hook_18(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 18), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 7, index 19
+ public static long stub_hook_19(long a0, long a1, long a2, long a3, long a4, long a5, long a6) throws Throwable {
+ return hookBridge(getMethodId(7, 19), null , a0, a1, a2, a3, a4, a5, a6);
+ }
+
+
+ //stub of arg size 8, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 0), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 1), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 2), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 3), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 4), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 5
+ public static long stub_hook_5(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 5), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 6
+ public static long stub_hook_6(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 6), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 7
+ public static long stub_hook_7(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 7), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 8
+ public static long stub_hook_8(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 8), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 8, index 9
+ public static long stub_hook_9(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7) throws Throwable {
+ return hookBridge(getMethodId(8, 9), null , a0, a1, a2, a3, a4, a5, a6, a7);
+ }
+
+
+ //stub of arg size 9, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 3), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 4), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 5
+ public static long stub_hook_5(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 5), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 6
+ public static long stub_hook_6(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 6), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 7
+ public static long stub_hook_7(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 7), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 8
+ public static long stub_hook_8(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 8), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 9, index 9
+ public static long stub_hook_9(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8) throws Throwable {
+ return hookBridge(getMethodId(9, 9), null , a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ }
+
+
+ //stub of arg size 10, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable {
+ return hookBridge(getMethodId(10, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable {
+ return hookBridge(getMethodId(10, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable {
+ return hookBridge(getMethodId(10, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable {
+ return hookBridge(getMethodId(10, 3), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 10, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9) throws Throwable {
+ return hookBridge(getMethodId(10, 4), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ }
+
+
+ //stub of arg size 11, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10) throws Throwable {
+ return hookBridge(getMethodId(11, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10) throws Throwable {
+ return hookBridge(getMethodId(11, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10) throws Throwable {
+ return hookBridge(getMethodId(11, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 3
+ public static long stub_hook_3(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10) throws Throwable {
+ return hookBridge(getMethodId(11, 3), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 11, index 4
+ public static long stub_hook_4(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10) throws Throwable {
+ return hookBridge(getMethodId(11, 4), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
+ }
+
+
+ //stub of arg size 12, index 0
+ public static long stub_hook_0(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10, long a11) throws Throwable {
+ return hookBridge(getMethodId(12, 0), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+ }
+
+
+ //stub of arg size 12, index 1
+ public static long stub_hook_1(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10, long a11) throws Throwable {
+ return hookBridge(getMethodId(12, 1), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+ }
+
+
+ //stub of arg size 12, index 2
+ public static long stub_hook_2(long a0, long a1, long a2, long a3, long a4, long a5, long a6, long a7, long a8, long a9, long a10, long a11) throws Throwable {
+ return hookBridge(getMethodId(12, 2), null , a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
+ }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/ErrorCatch.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/ErrorCatch.java
new file mode 100644
index 00000000..c6a5a82d
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/ErrorCatch.java
@@ -0,0 +1,22 @@
+package com.swift.sandhook.xposedcompat.methodgen;
+
+import android.util.Log;
+
+import com.swift.sandhook.SandHook;
+import com.swift.sandhook.xposedcompat.XposedCompat;
+
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+
+public class ErrorCatch {
+
+ public static Object callOriginError(Member originMethod, Method backupMethod, Object thiz, Object[] args) throws Throwable {
+ if (XposedCompat.retryWhenCallOriginError) {
+ Log.w("SandHook", "method <" + originMethod.toString() + "> use invoke to call origin!");
+ return SandHook.callOriginMethod(originMethod, backupMethod, thiz, args);
+ } else {
+ return null;
+ }
+ }
+
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/HookMaker.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/HookMaker.java
new file mode 100644
index 00000000..ae5c05e7
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/HookMaker.java
@@ -0,0 +1,14 @@
+package com.swift.sandhook.xposedcompat.methodgen;
+
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+
+import de.robv.android.xposed.XposedBridge;
+
+public interface HookMaker {
+ void start(Member member, XposedBridge.AdditionalHookInfo hookInfo,
+ ClassLoader appClassLoader, String dexDirPath) throws Exception;
+ Method getHookMethod();
+ Method getBackupMethod();
+ Method getCallBackupMethod();
+}
diff --git a/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/HookerDexMaker.java b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/HookerDexMaker.java
new file mode 100644
index 00000000..4a72537b
--- /dev/null
+++ b/edxp-sandhook/src/main/java/com/swift/sandhook/xposedcompat/methodgen/HookerDexMaker.java
@@ -0,0 +1,698 @@
+package com.swift.sandhook.xposedcompat.methodgen;
+
+import android.text.TextUtils;
+
+import com.swift.sandhook.SandHook;
+import com.swift.sandhook.SandHookMethodResolver;
+import com.swift.sandhook.wrapper.HookWrapper;
+import com.swift.sandhook.xposedcompat.XposedCompat;
+import com.swift.sandhook.xposedcompat.utils.DexLog;
+
+import java.io.File;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Map;
+
+import de.robv.android.xposed.XC_MethodHook;
+import de.robv.android.xposed.XposedBridge;
+import external.com.android.dx.BinaryOp;
+import external.com.android.dx.Code;
+import external.com.android.dx.Comparison;
+import external.com.android.dx.DexMaker;
+import external.com.android.dx.FieldId;
+import external.com.android.dx.Label;
+import external.com.android.dx.Local;
+import external.com.android.dx.MethodId;
+import external.com.android.dx.TypeId;
+
+import static com.swift.sandhook.xposedcompat.utils.DexMakerUtils.MD5;
+import static com.swift.sandhook.xposedcompat.utils.DexMakerUtils.autoBoxIfNecessary;
+import static com.swift.sandhook.xposedcompat.utils.DexMakerUtils.autoUnboxIfNecessary;
+import static com.swift.sandhook.xposedcompat.utils.DexMakerUtils.createResultLocals;
+import static com.swift.sandhook.xposedcompat.utils.DexMakerUtils.getObjTypeIdIfPrimitive;
+
+public class HookerDexMaker implements HookMaker {
+
+ public static final String METHOD_NAME_BACKUP = "backup";
+ public static final String METHOD_NAME_HOOK = "hook";
+ public static final String METHOD_NAME_CALL_BACKUP = "callBackup";
+ public static final String METHOD_NAME_SETUP = "setup";
+ public static final String METHOD_NAME_LOG = "printMethodHookIn";
+ public static final TypeId objArrayTypeId = TypeId.get(Object[].class);
+ private static final String CLASS_DESC_PREFIX = "L";
+ private static final String CLASS_NAME_PREFIX = "SandHooker";
+ private static final String FIELD_NAME_HOOK_INFO = "additionalHookInfo";
+ private static final String FIELD_NAME_METHOD = "method";
+ private static final String FIELD_NAME_BACKUP_METHOD = "backupMethod";
+ private static final String PARAMS_FIELD_NAME_METHOD = "method";
+ private static final String PARAMS_FIELD_NAME_THIS_OBJECT = "thisObject";
+ private static final String PARAMS_FIELD_NAME_ARGS = "args";
+ private static final String CALLBACK_METHOD_NAME_BEFORE = "callBeforeHookedMethod";
+ private static final String CALLBACK_METHOD_NAME_AFTER = "callAfterHookedMethod";
+ private static final TypeId throwableTypeId = TypeId.get(Throwable.class);
+ private static final TypeId memberTypeId = TypeId.get(Member.class);
+ private static final TypeId methodTypeId = TypeId.get(Method.class);
+ private static final TypeId callbackTypeId = TypeId.get(XC_MethodHook.class);
+ private static final TypeId hookInfoTypeId
+ = TypeId.get(XposedBridge.AdditionalHookInfo.class);
+ private static final TypeId callbacksTypeId
+ = TypeId.get(XposedBridge.CopyOnWriteSortedSet.class);
+ private static final TypeId paramTypeId
+ = TypeId.get(XC_MethodHook.MethodHookParam.class);
+ private static final MethodId setResultMethodId =
+ paramTypeId.getMethod(TypeId.VOID, "setResult", TypeId.OBJECT);
+ private static final MethodId setThrowableMethodId =
+ paramTypeId.getMethod(TypeId.VOID, "setThrowable", throwableTypeId);
+ private static final MethodId getResultMethodId =
+ paramTypeId.getMethod(TypeId.OBJECT, "getResult");
+ private static final MethodId getThrowableMethodId =
+ paramTypeId.getMethod(throwableTypeId, "getThrowable");
+ private static final MethodId hasThrowableMethodId =
+ paramTypeId.getMethod(TypeId.BOOLEAN, "hasThrowable");
+ private static final MethodId callAfterCallbackMethodId =
+ callbackTypeId.getMethod(TypeId.VOID, CALLBACK_METHOD_NAME_AFTER, paramTypeId);
+ private static final MethodId callBeforeCallbackMethodId =
+ callbackTypeId.getMethod(TypeId.VOID, CALLBACK_METHOD_NAME_BEFORE, paramTypeId);
+ private static final FieldId returnEarlyFieldId =
+ paramTypeId.getField(TypeId.BOOLEAN, "returnEarly");
+ private static final TypeId xposedBridgeTypeId = TypeId.get(XposedBridge.class);
+ private static final MethodId logThrowableMethodId =
+ xposedBridgeTypeId.getMethod(TypeId.VOID, "log", throwableTypeId);
+
+ private FieldId mHookInfoFieldId;
+ private FieldId mMethodFieldId;
+ private FieldId mBackupMethodFieldId;
+ private MethodId mBackupMethodId;
+ private MethodId mCallBackupMethodId;
+ private MethodId mHookMethodId;
+ private MethodId mPrintLogMethodId;
+ private MethodId mSandHookCallOriginMethodId;
+
+ private TypeId mHookerTypeId;
+ private TypeId[] mParameterTypeIds;
+ private Class[] mActualParameterTypes;
+ private Class mReturnType;
+ private TypeId mReturnTypeId;
+ private boolean mIsStatic;
+ // TODO use this to generate methods
+ private boolean mHasThrowable;
+
+ private DexMaker mDexMaker;
+ private Member mMember;
+ private XposedBridge.AdditionalHookInfo mHookInfo;
+ private ClassLoader mAppClassLoader;
+ private Class mHookClass;
+ private Method mHookMethod;
+ private Method mBackupMethod;
+ private Method mCallBackupMethod;
+ private String mDexDirPath;
+
+ private static TypeId[] getParameterTypeIds(Class[] parameterTypes, boolean isStatic) {
+ int parameterSize = parameterTypes.length;
+ int targetParameterSize = isStatic ? parameterSize : parameterSize + 1;
+ TypeId[] parameterTypeIds = new TypeId[targetParameterSize];
+ int offset = 0;
+ if (!isStatic) {
+ parameterTypeIds[0] = TypeId.OBJECT;
+ offset = 1;
+ }
+ for (int i = 0; i < parameterTypes.length; i++) {
+ parameterTypeIds[i + offset] = TypeId.get(parameterTypes[i]);
+ }
+ return parameterTypeIds;
+ }
+
+ private static Class[] getParameterTypes(Class[] parameterTypes, boolean isStatic) {
+ if (isStatic) {
+ return parameterTypes;
+ }
+ int parameterSize = parameterTypes.length;
+ int targetParameterSize = parameterSize + 1;
+ Class[] newParameterTypes = new Class[targetParameterSize];
+ int offset = 1;
+ newParameterTypes[0] = Object.class;
+ System.arraycopy(parameterTypes, 0, newParameterTypes, offset, parameterTypes.length);
+ return newParameterTypes;
+ }
+
+ public void start(Member member, XposedBridge.AdditionalHookInfo hookInfo,
+ ClassLoader appClassLoader, String dexDirPath) throws Exception {
+ if (member instanceof Method) {
+ Method method = (Method) member;
+ mIsStatic = Modifier.isStatic(method.getModifiers());
+ mReturnType = method.getReturnType();
+ if (mReturnType.equals(Void.class) || mReturnType.equals(void.class)
+ || mReturnType.isPrimitive()) {
+ mReturnTypeId = TypeId.get(mReturnType);
+ } else {
+ // all others fallback to plain Object for convenience
+ mReturnType = Object.class;
+ mReturnTypeId = TypeId.OBJECT;
+ }
+ mParameterTypeIds = getParameterTypeIds(method.getParameterTypes(), mIsStatic);
+ mActualParameterTypes = getParameterTypes(method.getParameterTypes(), mIsStatic);
+ mHasThrowable = method.getExceptionTypes().length > 0;
+ } else if (member instanceof Constructor) {
+ Constructor constructor = (Constructor) member;
+ mIsStatic = false;
+ mReturnType = void.class;
+ mReturnTypeId = TypeId.VOID;
+ mParameterTypeIds = getParameterTypeIds(constructor.getParameterTypes(), mIsStatic);
+ mActualParameterTypes = getParameterTypes(constructor.getParameterTypes(), mIsStatic);
+ mHasThrowable = constructor.getExceptionTypes().length > 0;
+ } else if (member.getDeclaringClass().isInterface()) {
+ throw new IllegalArgumentException("Cannot hook interfaces: " + member.toString());
+ } else if (Modifier.isAbstract(member.getModifiers())) {
+ throw new IllegalArgumentException("Cannot hook abstract methods: " + member.toString());
+ } else {
+ throw new IllegalArgumentException("Only methods and constructors can be hooked: " + member.toString());
+ }
+ mMember = member;
+ mHookInfo = hookInfo;
+ mDexDirPath = dexDirPath;
+ if (appClassLoader == null
+ || appClassLoader.getClass().getName().equals("java.lang.BootClassLoader")) {
+ mAppClassLoader = this.getClass().getClassLoader();
+ } else {
+ mAppClassLoader = appClassLoader;
+ }
+
+ mDexMaker = new DexMaker();
+ // Generate a Hooker class.
+ String className = getClassName(mMember);
+ String dexName = className + ".jar";
+
+ HookWrapper.HookEntity hookEntity = null;
+ //try load cache first
+ try {
+ ClassLoader loader = mDexMaker.generateAndLoad(mAppClassLoader, new File(mDexDirPath), dexName);
+ if (loader != null) {
+ hookEntity = loadHookerClass(loader, className);
+ }
+ } catch (Throwable throwable) {}
+
+ //do generate
+ if (hookEntity == null) {
+ hookEntity = doMake(className, dexName);
+ }
+ SandHook.hook(hookEntity);
+ }
+
+ private HookWrapper.HookEntity doMake(String className, String dexName) throws Exception {
+ mHookerTypeId = TypeId.get(CLASS_DESC_PREFIX + className + ";");
+ mDexMaker.declare(mHookerTypeId, className + ".generated", Modifier.PUBLIC, TypeId.OBJECT);
+ generateFields();
+ generateSetupMethod();
+ if (XposedCompat.retryWhenCallOriginError) {
+ generateBackupAndCallOriginCheckMethod();
+ } else {
+ generateBackupMethod();
+ }
+ generateCallBackupMethod();
+ generateHookMethod();
+
+ ClassLoader loader;
+ if (TextUtils.isEmpty(mDexDirPath)) {
+ throw new IllegalArgumentException("dexDirPath should not be empty!!!");
+ }
+ // Create the dex file and load it.
+ loader = mDexMaker.generateAndLoad(mAppClassLoader, new File(mDexDirPath), dexName);
+ return loadHookerClass(loader, className);
+ }
+
+ private HookWrapper.HookEntity loadHookerClass(ClassLoader loader, String className) throws Exception {
+ mHookClass = loader.loadClass(className);
+ // Execute our newly-generated code in-process.
+ mHookMethod = mHookClass.getMethod(METHOD_NAME_HOOK, mActualParameterTypes);
+ mBackupMethod = mHookClass.getMethod(METHOD_NAME_BACKUP, mActualParameterTypes);
+ mCallBackupMethod = mHookClass.getMethod(METHOD_NAME_CALL_BACKUP, mActualParameterTypes);
+ SandHook.resolveStaticMethod(mCallBackupMethod);
+ SandHookMethodResolver.resolveMethod(mCallBackupMethod, mBackupMethod);
+ SandHook.compileMethod(mCallBackupMethod);
+ mHookClass.getMethod(METHOD_NAME_SETUP, Member.class, Method.class, XposedBridge.AdditionalHookInfo.class).invoke(null, mMember, mBackupMethod, mHookInfo);
+ return new HookWrapper.HookEntity(mMember, mHookMethod, mBackupMethod);
+ }
+
+ private String getClassName(Member originMethod) {
+ return CLASS_NAME_PREFIX + "_" + MD5(originMethod.toString());
+ }
+
+ public Method getHookMethod() {
+ return mHookMethod;
+ }
+
+ public Method getBackupMethod() {
+ return mBackupMethod;
+ }
+
+ public Method getCallBackupMethod() {
+ return mCallBackupMethod;
+ }
+
+ public Class getHookClass() {
+ return mHookClass;
+ }
+
+ private void generateFields() {
+ mHookInfoFieldId = mHookerTypeId.getField(hookInfoTypeId, FIELD_NAME_HOOK_INFO);
+ mMethodFieldId = mHookerTypeId.getField(memberTypeId, FIELD_NAME_METHOD);
+ mBackupMethodFieldId = mHookerTypeId.getField(methodTypeId, FIELD_NAME_BACKUP_METHOD);
+ mDexMaker.declare(mHookInfoFieldId, Modifier.STATIC, null);
+ mDexMaker.declare(mMethodFieldId, Modifier.STATIC, null);
+ mDexMaker.declare(mBackupMethodFieldId, Modifier.STATIC, null);
+ }
+
+ private void generateSetupMethod() {
+ MethodId setupMethodId = mHookerTypeId.getMethod(
+ TypeId.VOID, METHOD_NAME_SETUP, memberTypeId, methodTypeId, hookInfoTypeId);
+ Code code = mDexMaker.declare(setupMethodId, Modifier.PUBLIC | Modifier.STATIC);
+ // init logic
+ // get parameters
+ Local method = code.getParameter(0, memberTypeId);
+ Local backupMethod = code.getParameter(1, methodTypeId);
+ Local hookInfo = code.getParameter(2, hookInfoTypeId);
+ // save params to static
+ code.sput(mMethodFieldId, method);
+ code.sput(mBackupMethodFieldId, backupMethod);
+ code.sput(mHookInfoFieldId, hookInfo);
+ code.returnVoid();
+ }
+
+ private void generateBackupMethod() {
+ mBackupMethodId = mHookerTypeId.getMethod(mReturnTypeId, METHOD_NAME_BACKUP, mParameterTypeIds);
+ Code code = mDexMaker.declare(mBackupMethodId, Modifier.PUBLIC | Modifier.STATIC);
+
+ Local method = code.newLocal(memberTypeId);
+
+ Map resultLocals = createResultLocals(code);
+ MethodId errLogMethod = TypeId.get(DexLog.class).getMethod(TypeId.get(Void.TYPE), "printCallOriginError", memberTypeId);
+
+
+ //very very important!!!!!!!!!!!
+ //add a try cache block avoid inline
+ Label tryCatchBlock = new Label();
+
+ code.addCatchClause(throwableTypeId, tryCatchBlock);
+ code.sget(mMethodFieldId, method);
+ code.invokeStatic(errLogMethod, null, method);
+ // start of try
+ code.mark(tryCatchBlock);
+
+ // do nothing
+ if (mReturnTypeId.equals(TypeId.VOID)) {
+ code.returnVoid();
+ } else {
+ // we have limited the returnType to primitives or Object, so this should be safe
+ code.returnValue(resultLocals.get(mReturnTypeId));
+ }
+ }
+
+ private void generateBackupAndCallOriginCheckMethod() {
+ mBackupMethodId = mHookerTypeId.getMethod(mReturnTypeId, METHOD_NAME_BACKUP, mParameterTypeIds);
+ mSandHookCallOriginMethodId = TypeId.get(ErrorCatch.class).getMethod(TypeId.get(Object.class), "callOriginError", memberTypeId, methodTypeId, TypeId.get(Object.class), TypeId.get(Object[].class));
+ MethodId errLogMethod = TypeId.get(DexLog.class).getMethod(TypeId.get(Void.TYPE), "printCallOriginError", methodTypeId);
+
+ Code code = mDexMaker.declare(mBackupMethodId, Modifier.PUBLIC | Modifier.STATIC);
+
+ Local method = code.newLocal(memberTypeId);
+ Local backupMethod = code.newLocal(methodTypeId);
+ Local