Java XposedBridge.hookAllMethods方法代码示例

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
@Override
public void initZygote(IXposedHookZygoteInit.StartupParam startupParam) throws Throwable {
    try {
        Class<?> c = findClass("android.media.MediaScanner$MyMediaScannerClient", null);

        XposedBridge.hookAllMethods(c, "endFile", new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                String mAlbumArtist = (String) XposedHelpers.getObjectField(param.thisObject, "mAlbumArtist");

                if (mAlbumArtist != null && mAlbumArtist.length() != 0)
                    XposedHelpers.setObjectField(param.thisObject, "mArtist", mAlbumArtist);
            }
        });
    } catch (Throwable t) {
        XposedBridge.log(t);
    }
}
 

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
public void overwriteResults(String classname, String method, final Object result){
    try {
        Class<?> aClass = cloader.loadClass(classname);
        XposedBridge.hookAllMethods(aClass, method, new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                param.setResult(result);
            }
        });

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}
 

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
public void hookLogs(){
    XposedBridge.hookAllMethods(Log.class, "d", new XposedAndroidLogMethodHook("debug"));
    XposedBridge.hookAllMethods(Log.class, "v", new XposedAndroidLogMethodHook("verbose"));
    XposedBridge.hookAllMethods(Log.class, "i", new XposedAndroidLogMethodHook("info"));
    XposedBridge.hookAllMethods(Log.class, "w", new XposedAndroidLogMethodHook("warning"));
    XposedBridge.hookAllMethods(Log.class, "e", new XposedAndroidLogMethodHook("exception"));
    XposedBridge.hookAllMethods(Log.class, "wtf", new XposedAndroidLogMethodHook("wtf"));
}
 

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
@Override
public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
    final Class<?> phoneWindowManager;
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
        phoneWindowManager = XposedHelpers.findClass("com.android.server.policy.PhoneWindowManager", lpparam.classLoader);
    } else {
        phoneWindowManager = XposedHelpers.findClass("com.android.internal.policy.impl.PhoneWindowManager", lpparam.classLoader);
    }

    XposedBridge.hookAllMethods(phoneWindowManager, "interceptKeyBeforeQueueing", new XC_MethodHook() {

        @Override
        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
            int keyCode = ((KeyEvent) param.args[0]).getKeyCode();
            if (keyCode == KeyEvent.KEYCODE_POWER) {
                XSharedPreferences mXsp = new XSharedPreferences(PACKAGE_NAME);

                Log.d("isBlockPowerButton", "=================" + mXsp.getBoolean("isBlockPowerButton", true));
                XposedBridge.log("isBlockPowerButton" + "=================" + mXsp.getBoolean("isBlockPowerButton", true));

                if (mXsp.getBoolean("isBlockPowerButton", true)) {
                    param.setResult(0);
                }
            }
        }
    });
}
 

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
public static void initAndroid(final XSharedPreferences mainPrefs, final ClassLoader classLoader) {
    mPrefs = new XSharedPreferences(GravityBox.PACKAGE_NAME, "ledcontrol");
    mPrefs.makeWorldReadable();
    mQhPrefs = new XSharedPreferences(GravityBox.PACKAGE_NAME, "quiet_hours");
    mQhPrefs.makeWorldReadable();
    mQuietHours = new QuietHours(mQhPrefs);

    mProximityWakeUpEnabled = mainPrefs.getBoolean(GravityBoxSettings.PREF_KEY_POWER_PROXIMITY_WAKE, false);

    try {
        final Class<?> nmsClass = XposedHelpers.findClass(CLASS_NOTIFICATION_MANAGER_SERVICE, classLoader);
        XposedBridge.hookAllConstructors(nmsClass, new XC_MethodHook() {
            @Override
            protected void afterHookedMethod(final MethodHookParam param) throws Throwable {
                if (mNotifManagerService == null) {
                    mNotifManagerService = param.thisObject;
                    mContext = (Context) XposedHelpers.callMethod(param.thisObject, "getContext");

                    IntentFilter intentFilter = new IntentFilter();
                    intentFilter.addAction(LedSettings.ACTION_UNC_SETTINGS_CHANGED);
                    intentFilter.addAction(Intent.ACTION_USER_PRESENT);
                    intentFilter.addAction(QuietHoursActivity.ACTION_QUIET_HOURS_CHANGED);
                    intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
                    intentFilter.addAction(ACTION_CLEAR_NOTIFICATIONS);
                    intentFilter.addAction(GravityBoxSettings.ACTION_PREF_POWER_CHANGED);
                    mContext.registerReceiver(mBroadcastReceiver, intentFilter);

                    toggleActiveScreenFeature(!mPrefs.getBoolean(LedSettings.PREF_KEY_LOCKED, false) && 
                            mPrefs.getBoolean(LedSettings.PREF_KEY_ACTIVE_SCREEN_ENABLED, false));
                    hookNotificationDelegate();

                    if (DEBUG) log("Notification manager service initialized");
                }
            }
        });

        XposedHelpers.findAndHookMethod(CLASS_NOTIFICATION_MANAGER_SERVICE, classLoader,
                "enqueueNotificationInternal", String.class, String.class,
                int.class, int.class, String.class, 
                int.class, Notification.class, int[].class, int.class, notifyHook);

        XposedHelpers.findAndHookMethod(CLASS_NOTIFICATION_MANAGER_SERVICE, classLoader,
                "applyZenModeLocked", CLASS_NOTIFICATION_RECORD, applyZenModeHook);

        XposedHelpers.findAndHookMethod(CLASS_NOTIFICATION_MANAGER_SERVICE, classLoader,
                "updateLightsLocked", updateLightsLockedHook);

        XposedBridge.hookAllMethods(XposedHelpers.findClass(CLASS_VIBRATOR_SERVICE, classLoader),
                "startVibrationLocked", startVibrationHook);
    } catch (Throwable t) {
        XposedBridge.log(t);
    }
}
 

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
public static void init(final XSharedPreferences prefs, final ClassLoader classLoader) {
    try {
        XposedBridge.hookAllMethods(
                XposedHelpers.findClass(CLASS_NOTIF_DATA, classLoader),
                "shouldFilterOut", new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                StatusBarNotification sbn = (StatusBarNotification)param.args[0];
                Notification n = sbn.getNotification();

                // whether to hide persistent everywhere
                if (!sbn.isClearable() && n.extras.getBoolean(NOTIF_EXTRA_HIDE_PERSISTENT)) {
                    param.setResult(true);
                    return;
                }

                // whether to hide during keyguard
                if (ModStatusBar.getStatusBarState() != StatusBarState.SHADE) {
                    VisibilityLs vls = n.extras.containsKey(NOTIF_EXTRA_VISIBILITY_LS) ?
                            VisibilityLs.valueOf(n.extras.getString(NOTIF_EXTRA_VISIBILITY_LS)) :
                                VisibilityLs.DEFAULT;
                    switch (vls) {
                        case CLEARABLE:
                            param.setResult(sbn.isClearable());
                            break;
                        case PERSISTENT:
                            param.setResult(!sbn.isClearable());
                            break;
                        case ALL:
                            param.setResult(true);
                            break;
                        case DEFAULT:
                        default: return;
                    }
                }
            }
        });
    } catch (Throwable t) {
        XposedBridge.log(t);
    }
}
 

import de.robv.android.xposed.XposedBridge; //导入方法依赖的package包/类
public static void hook(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
    String pwmClassPath;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        pwmClassPath = PHONE_WINDOW_MANAGER_M;
    } else {
        pwmClassPath = PHONE_WINDOW_MANAGER_L;
    }

    Class<?> pwmClass = loadPackageParam.classLoader.loadClass(pwmClassPath);
    XposedBridge.hookAllMethods(pwmClass, "init", new XC_MethodHook() {
        @Override
        protected void afterHookedMethod(final MethodHookParam param) throws Throwable {
            final Context mContext = (Context) XposedHelpers.getObjectField(param.thisObject, "mContext");
            WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
            screenH = wm.getDefaultDisplay().getHeight();
            final Resources resources = mContext.getResources();
            final int resourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android");
            navbarH = resources.getDimensionPixelSize(resourceId);
            if (navbarH == 0) {
                navbarH = 150;
            }

            BroadcastReceiver screenShotReceiver = new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    try {
                        int type = intent.getIntExtra(ConstantStr.TYPE, -1);
                        switch (type) {
                            case ConstantStr.TAKE_SCREENSHOT:
                                if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
                                    XposedHelpers.callMethod(param.thisObject, "takeScreenshot", 1);
                                } else {
                                    XposedHelpers.callMethod(param.thisObject, "takeScreenshot");
                                }
                                break;
                            case ConstantStr.HIDE_NAVBAR: {
                                setNavBarDimensions(param.thisObject, 0);
                            }
                            break;
                            case ConstantStr.NAVBAR_H: {
                                navbarH = resources.getDimensionPixelSize(resourceId);
                                navbarH = (int) (navbarH * (((float) intent.getIntExtra(ConstantStr.NAVBAR_HEIGHT, 100) / 100)));
                                setNavBarDimensions(param.thisObject, navbarH);
                            }
                            break;
                        }
                    } catch (Exception e) {
                        XpLog.e(e);
                    }

                }
            };
            IntentFilter filter = new IntentFilter(XpNavBarAction.ACTION_PHONE_WINDOW_MANAGER);
            mContext.registerReceiver(screenShotReceiver, filter);

            gesturesListener = new GesturesListener(mContext, new GesturesListener.Callbacks() {
                @Override
                public void onSwipeFromTop() {

                }

                @Override
                public void onSwipeFromBottom() {
                    setNavBarDimensions(param.thisObject, navbarH);
                }

                @Override
                public void onSwipeFromRight() {

                }

                @Override
                public void onDebug() {

                }
            });
        }
    });
}