android系统api工具类_android systemapi

package com.boeyu.systemmanagerlib;
 
 
import android.accessibilityservice.AccessibilityService;
import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.app.AlarmManager;
import android.app.AppOpsManager;
import android.app.PendingIntent;
import android.app.Service;
import android.app.admin.DeviceAdminReceiver;
import android.app.admin.DevicePolicyManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageDataObserver;
import android.content.pm.IPackageDeleteObserver;
import android.content.pm.IPackageInstallObserver;
import android.content.pm.PackageInfo;
import android.content.pm.PackageInstaller;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.graphics.Point;
import android.graphics.Rect;
import android.hardware.display.DisplayManager;
import android.hardware.display.VirtualDisplay;
import android.hardware.usb.UsbManager;
import android.media.Image;
import android.media.ImageReader;
import android.net.Uri;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Looper;
import android.os.PowerManager;
import android.os.RecoverySystem;
import android.os.RemoteException;
import android.os.SystemClock;
import android.os.UserHandle;
import android.os.UserManager;
import android.os.storage.StorageManager;
import android.os.storage.StorageVolume;
import android.provider.Settings;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.View;
import android.view.WindowManager;
import android.widget.Toast;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
 
 
/**
 * Created by yuanfang235 on 2019-12-26.
 */
 
public class SystemApi {
 
    private static final String TAG = "WALX";
 
    /**
     * op值，参考AppOpsManager类的声明
     */
    public static final int OP_NONE = -1;
    public static final int OP_COARSE_LOCATION = 0;
    public static final int OP_FINE_LOCATION = 1;
    public static final int OP_GPS = 2;
    public static final int OP_VIBRATE = 3;
    public static final int OP_READ_CONTACTS = 4;
    public static final int OP_WRITE_CONTACTS = 5;
    public static final int OP_READ_CALL_LOG = 6;
    public static final int OP_WRITE_CALL_LOG = 7;
    public static final int OP_READ_CALENDAR = 8;
    public static final int OP_WRITE_CALENDAR = 9;
    public static final int OP_WIFI_SCAN = 10;
    public static final int OP_POST_NOTIFICATION = 11;
    public static final int OP_NEIGHBORING_CELLS = 12;
    public static final int OP_CALL_PHONE = 13;
    public static final int OP_READ_SMS = 14;
    public static final int OP_WRITE_SMS = 15;
    public static final int OP_RECEIVE_SMS = 16;
    public static final int OP_RECEIVE_EMERGECY_SMS = 17;
    public static final int OP_RECEIVE_MMS = 18;
    public static final int OP_RECEIVE_WAP_PUSH = 19;
    public static final int OP_SEND_SMS = 20;
    public static final int OP_READ_ICC_SMS = 21;
    public static final int OP_WRITE_ICC_SMS = 22;
    public static final int OP_WRITE_SETTINGS = 23;
    public static final int OP_SYSTEM_ALERT_WINDOW = 24;
    public static final int OP_ACCESS_NOTIFICATIONS = 25;
    public static final int OP_CAMERA = 26;
    public static final int OP_RECORD_AUDIO = 27;
    public static final int OP_PLAY_AUDIO = 28;
    public static final int OP_READ_CLIPBOARD = 29;
    public static final int OP_WRITE_CLIPBOARD = 30;
    public static final int OP_TAKE_MEDIA_BUTTONS = 31;
    public static final int OP_TAKE_AUDIO_FOCUS = 32;
    public static final int OP_AUDIO_MASTER_VOLUME = 33;
    public static final int OP_AUDIO_VOICE_VOLUME = 34;
    public static final int OP_AUDIO_RING_VOLUME = 35;
    public static final int OP_AUDIO_MEDIA_VOLUME = 36;
    public static final int OP_AUDIO_ALARM_VOLUME = 37;
    public static final int OP_AUDIO_NOTIFICATION_VOLUME = 38;
    public static final int OP_AUDIO_BLUETOOTH_VOLUME = 39;
    public static final int OP_WAKE_LOCK = 40;
    public static final int OP_MONITOR_LOCATION = 41;
    public static final int OP_MONITOR_HIGH_POWER_LOCATION = 42;
    public static final int OP_GET_USAGE_STATS = 43;
    public static final int OP_MUTE_MICROPHONE = 44;
    public static final int OP_TOAST_WINDOW = 45;
    public static final int OP_PROJECT_MEDIA = 46;
    public static final int OP_ACTIVATE_VPN = 47;
    public static final int OP_WRITE_WALLPAPER = 48;
    public static final int OP_ASSIST_STRUCTURE = 49;
    public static final int OP_ASSIST_SCREENSHOT = 50;
    public static final int OP_READ_PHONE_STATE = 51;
    public static final int OP_ADD_VOICEMAIL = 52;
    public static final int OP_USE_SIP = 53;
    public static final int OP_PROCESS_OUTGOING_CALLS = 54;
    public static final int OP_USE_FINGERPRINT = 55;
    public static final int OP_BODY_SENSORS = 56;
    public static final int OP_READ_CELL_BROADCASTS = 57;
    public static final int OP_MOCK_LOCATION = 58;
    public static final int OP_READ_EXTERNAL_STORAGE = 59;
    public static final int OP_WRITE_EXTERNAL_STORAGE = 60;
    public static final int OP_TURN_SCREEN_ON = 61;
    public static final int OP_GET_ACCOUNTS = 62;
    public static final int OP_RUN_IN_BACKGROUND = 63;
    public static final int OP_AUDIO_ACCESSIBILITY_VOLUME = 64;
    public static final int OP_READ_PHONE_NUMBERS = 65;
    public static final int OP_REQUEST_INSTALL_PACKAGES = 66;
    public static final int OP_PICTURE_IN_PICTURE = 67;
    public static final int OP_INSTANT_APP_START_FOREGROUND = 68;
    public static final int OP_ANSWER_PHONE_CALLS = 69;
 
    public static final String OPSTR_PROJECT_MEDIA = "android:project_media";
 
    public static final int STATUS_SUCCESS = 0;
    public static final int STATUS_FAILURE = 1;
 
    public static final String USB_FUNCTION_NONE = "none";
    public static final String USB_FUNCTION_ADB = "adb";
    public static final String USB_FUNCTION_RNDIS = "rndis";
    public static final String USB_FUNCTION_MTP = "mtp";
    public static final String USB_FUNCTION_PTP = "ptp";
 
    public static final int ERROR_COMPONENT_STATE = -1;
 
    /* 权限标志 */
    public static final int FLAG_PERMISSION_ERROR = 0;
    public static final int FLAG_PERMISSION_USER_SET = 1 << 0;
    public static final int FLAG_PERMISSION_USER_FIXED = 1 << 1;
    public static final int FLAG_PERMISSION_POLICY_FIXED = 1 << 2;
    public static final int FLAG_PERMISSION_REVOKE_ON_UPGRADE = 1 << 3;
    public static final int FLAG_PERMISSION_SYSTEM_FIXED = 1 << 4;
    public static final int FLAG_PERMISSION_GRANTED_BY_DEFAULT = 1 << 5;
    public static final int FLAG_PERMISSION_REVIEW_REQUIRED = 1 << 6;
    public static final int MASK_PERMISSION_FLAGS = 0xFF;
 
 
    /*************************************************/
    private static final int INSTALL_SUCCEEDED = 1;
    private static final int DELETE_SUCCEEDED = 1;
 
    private static final int INSTALL_REPLACE_EXISTING = 0x00000002;
    private static final int DELETE_SYSTEM_APP = 0x00000004;
    private static final int OP_MODE_INVALID = -1;
 
    private static final String ACTION_MASTER_CLEAR = "android.intent.action.MASTER_CLEAR";
    private static final String EXTRA_REASON = "android.intent.extra.REASON";
    private static final String EXTRA_WIPE_EXTERNAL_STORAGE = "android.intent.extra.WIPE_EXTERNAL_STORAGE";
    private static final String ACTION_FACTORY_RESET = "android.intent.action.FACTORY_RESET";  //8.0
 
    private static final int STATUS_BAR_DISABLE_EXPAND = 0x00010000;
 
    private static final int DISABLE2_QUICK_SETTINGS = 1;
    private static final int DISABLE2_SYSTEM_ICONS = 1 << 1;
    private static final int DISABLE2_NOTIFICATION_SHADE = 1 << 2;
    private static final int DISABLE2_GLOBAL_ACTIONS = 1 << 3;
    private static final int DISABLE2_ROTATE_SUGGESTIONS = 1 << 4;
    private static final int DISABLE2_NONE = 0x00000000;
    private static final int DISABLE2_MASK = DISABLE2_QUICK_SETTINGS | DISABLE2_SYSTEM_ICONS
            | DISABLE2_NOTIFICATION_SHADE | DISABLE2_ROTATE_SUGGESTIONS;
 
    private static final int FIREWALL_RULE_DEFAULT = 0;
    private static final int FIREWALL_RULE_ALLOW = 1;
    private static final int FIREWALL_RULE_DENY = 2;
 
    private Context mContext;
 
    private Handler mHandler = new Handler(Looper.getMainLooper());
 
    private boolean mDebug;
 
    private boolean mLoggerEnabled;
 
    public SystemApi(Context context) {
        this.mContext = context;
        mDebug = (mContext.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
    }
 
    /**
     * 允许运行时权限
     *
     * @param packageName
     * @param permissions
     * @return
     */
    public SystemApi allowPermission(String packageName, String... permissions) {
        if (permissions == null || permissions.length == 0) return this;
        if (!needRuntimePermission()) return this;
        for (String permission : permissions) {
            if (!grantRuntimePermission(packageName, permission)) {
                setUidMode(packageName, AppOpsManager.permissionToOp(permission), AppOpsManager.MODE_ALLOWED);
            }
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                setUidMode(packageName, AppOpsManager.permissionToOp(permission), AppOpsManager.MODE_ALLOWED);
            }
        }
        return this;
    }
 
    public SystemApi allowPermission(String packageName, Collection<String> permissions) {
        if (permissions == null || permissions.isEmpty()) return this;
        String[] array = new String[permissions.size()];
        permissions.toArray(array);
        return allowPermission(packageName, array);
    }
 
    /**
     * 禁止运行时权限
     *
     * @param packageName
     * @param permissions
     * @return
     */
    public SystemApi denyPermission(String packageName, String... permissions) {
        if (permissions == null || permissions.length == 0) return this;
        if (!needRuntimePermission()) return this;
        for (String permission : permissions) {
            revokeRuntimePermission(packageName, permission);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                setUidMode(packageName, AppOpsManager.permissionToOp(permission), AppOpsManager.MODE_IGNORED);
            }
        }
        return this;
    }
 
    public SystemApi denyPermission(String packageName, Collection<String> permissions) {
        if (permissions == null || permissions.isEmpty()) return this;
        String[] array = new String[permissions.size()];
        permissions.toArray(array);
        return denyPermission(packageName, array);
    }
 
    /**
     * 固定权限
     *
     * @param packageName
     * @param permissions
     * @return
     */
    public SystemApi fixedPermission(String packageName, String... permissions) {
        if (permissions == null || permissions.length == 0) return this;
        if (!needRuntimePermission()) return this;
        for (String permission : permissions) {
            fixedPermissionInner(packageName, permission);
        }
        return this;
    }
 
    /**
     * 不固定权限
     *
     * @param packageName
     * @param permissions
     * @return
     */
    public SystemApi unfixedPermission(String packageName, String... permissions) {
        if (permissions == null || permissions.length == 0) return this;
        if (!needRuntimePermission()) return this;
        for (String permission : permissions) {
            unfixedPermissionInner(packageName, permission);
        }
        return this;
    }
 
    /**
     * 获取权限标志
     *
     * @param packageName
     * @param permission
     * @return
     */
    public int getPermissionFlags(String packageName, String permission) {
        try {
            Method method = PackageManager.class.getMethod("getPermissionFlags", String.class, String.class, UserHandle.class);
            UserHandle userHandle = (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, 0);
            return (int) method.invoke(mContext.getPackageManager(), permission, packageName, userHandle);
        } catch (Exception e) {
            printError(e);
        }
        return FLAG_PERMISSION_ERROR;
    }
 
 
    /**
     * 更新权限标志
     *
     * @param packageName
     * @param permission
     * @param flagMask
     * @param flagValues
     */
    public void updatePermissionFlags(String packageName, String permission, int flagMask, int flagValues) {
        try {
            Method method = PackageManager.class.getMethod("updatePermissionFlags", String.class, String.class, int.class, int.class, UserHandle.class);
            UserHandle userHandle = (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, 0);
            method.invoke(mContext.getPackageManager(), permission, packageName, flagMask, flagValues, userHandle);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 是否获取权限
     *
     * @param packageName
     * @param permissions
     * @return
     */
    public boolean isPermissionAllowed(String packageName, String... permissions) {
        if (permissions == null || permissions.length == 0) return true;
        if (!needRuntimePermission()) return true;
        Set<String> mDeniedPermissionList = getDeniedPermissionList(packageName, permissions);
        return mDeniedPermissionList.isEmpty();
    }
 
    /**
     * 是否是固定权限
     *
     * @param packageName
     * @param permission
     * @return
     */
    public boolean isFixedPermission(String packageName, String permission) {
        int flags = getPermissionFlags(packageName, permission);
        return (flags & FLAG_PERMISSION_SYSTEM_FIXED) == FLAG_PERMISSION_SYSTEM_FIXED
                || (flags & FLAG_PERMISSION_POLICY_FIXED) == FLAG_PERMISSION_POLICY_FIXED;
    }
 
    /**
     * 设置OP模式
     *
     * @param packageName
     * @param opCode
     * @param mode
     * @return
     */
    public SystemApi setOpMode(String packageName, int opCode, int mode) {
        try {
            Method method = AppOpsManager.class.getMethod("setMode", int.class, int.class, String.class, int.class);
            AppOpsManager mAppOps = (AppOpsManager) mContext.getSystemService(Service.APP_OPS_SERVICE);
            method.invoke(mAppOps, opCode, getPackageUid(packageName), packageName, mode);
        } catch (Exception e) {
            printError(e);
        }
        return this;
    }
 
    /**
     * 设置Uid模式
     *
     * @param packageName
     * @param opCode
     * @param mode
     */
    public void setUidMode(String packageName, int opCode, int mode) {
        try {
            Method method = AppOpsManager.class.getMethod("setUidMode", int.class, int.class, int.class);
            AppOpsManager mAppOps = (AppOpsManager) mContext.getSystemService(Service.APP_OPS_SERVICE);
            method.invoke(mAppOps, opCode, getPackageUid(packageName), mode);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 设置Uid模式
     *
     * @param packageName
     * @param appOp
     * @param mode
     */
    public void setUidMode(String packageName, String appOp, int mode) {
        try {
            Method method = AppOpsManager.class.getMethod("setUidMode", String.class, int.class, int.class);
            AppOpsManager mAppOps = (AppOpsManager) mContext.getSystemService(Service.APP_OPS_SERVICE);
            method.invoke(mAppOps, appOp, getPackageUid(packageName), mode);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 允许OP权限
     *
     * @param packageName
     * @param opCode
     * @return
     */
    public SystemApi allowOp(String packageName, int opCode) {
        setOpMode(packageName, opCode, AppOpsManager.MODE_ALLOWED);
        return this;
    }
 
    /**
     * 禁止OP权限
     *
     * @param packageName
     * @param opCode
     * @return
     */
    public SystemApi denyOp(String packageName, int opCode) {
        setOpMode(packageName, opCode, AppOpsManager.MODE_IGNORED);
        return this;
    }
 
    public SystemApi allowOp(String packageName, int opCode, boolean isAllow) {
        if (isAllow) {
            allowOp(packageName, opCode);
        } else {
            denyOp(packageName, opCode);
        }
        return this;
    }
 
    /**
     * 是否允许OP
     *
     * @param packageName
     * @param opCode
     * @return
     */
    public boolean isOpAllowed(String packageName, int opCode) {
        return getOpMode(packageName, opCode) == AppOpsManager.MODE_ALLOWED;
    }
 
    /**
     * 获取OP模式
     *
     * @param packageName
     * @param opCode
     * @return
     */
    public int getOpMode(String packageName, int opCode) {
        try {
            Object object = mContext.getSystemService(Context.APP_OPS_SERVICE);
            if (object == null) {
                return AppOpsManager.MODE_ALLOWED;
            }
            Class localClass = object.getClass();
            Class[] arrayOfClass = new Class[3];
            arrayOfClass[0] = Integer.TYPE;
            arrayOfClass[1] = Integer.TYPE;
            arrayOfClass[2] = String.class;
            Method method = localClass.getMethod("checkOpNoThrow", arrayOfClass);
 
            if (method == null) {
                return OP_MODE_INVALID;
            }
            Object[] arrayOfObject = new Object[3];
            arrayOfObject[0] = Integer.valueOf(opCode);
            arrayOfObject[1] = Integer.valueOf(getPackageUid(packageName));
            arrayOfObject[2] = packageName;
            int m = ((Integer) method.invoke(object, arrayOfObject)).intValue();
            return m;
        } catch (Exception e) {
            printError(e);
        }
        return OP_MODE_INVALID;
    }
 
    /**
     * 允许禁止悬浮窗权限
     *
     * @param packageName
     * @return
     */
    public SystemApi allowDrawOverlays(String packageName, boolean isAllow) {
        if (needRuntimePermission()) {
            setOpState(packageName, OP_SYSTEM_ALERT_WINDOW, isAllow);
        }
        return this;
    }
 
    /**
     * 是否允许悬浮窗
     *
     * @param packageName
     * @return
     */
    public boolean isDrawOverlaysAllowed(String packageName) {
        return isOpAllowed(packageName, OP_SYSTEM_ALERT_WINDOW);
    }
 
    /**
     * 允许禁止修改设置权限
     *
     * @param packageName
     * @return
     */
    public SystemApi allowWriteSettings(String packageName, boolean isAllow) {
        if (needRuntimePermission()) {
            setOpState(packageName, OP_WRITE_SETTINGS, isAllow);
        }
        return this;
    }
 
    /**
     * 是否允许修改设置
     *
     * @param packageName
     * @return
     */
    public boolean isWriteSettingsAllowed(String packageName) {
        return isOpAllowed(packageName, OP_WRITE_SETTINGS);
    }
 
    /**
     * 允许禁止查看应用统计
     *
     * @param packageName
     * @return
     */
    public SystemApi allowUsageStats(String packageName, boolean isAllow) {
        setOpState(packageName, OP_GET_USAGE_STATS, isAllow);
        return this;
    }
 
    /**
     * 是否允许查看应用统计
     *
     * @param packageName
     * @return
     */
    public boolean isUsageStatsAllowed(String packageName) {
        return isOpAllowed(packageName, OP_GET_USAGE_STATS);
    }
 
    /**
     * 允许禁止投屏
     *
     * @param packageName
     * @return
     */
    public SystemApi allowProjectMedia(String packageName, boolean isAllow) {
        setOpState(packageName, OP_PROJECT_MEDIA, isAllow);
        return this;
    }
 
    /**
     * 是否允许投屏
     *
     * @param packageName
     * @return
     */
    public boolean isProjectMediaAllowed(String packageName) {
        return isOpAllowed(packageName, OP_PROJECT_MEDIA);
    }
 
    /**
     * 允许安装包，android11会被系统杀死
     *
     * @param packageName
     * @param isAllow
     * @return
     */
    public SystemApi allowInstallPackage(String packageName, boolean isAllow) {
        if (Build.VERSION.SDK_INT < 30) {
            //android10及以下
            setOpState(packageName, OP_REQUEST_INSTALL_PACKAGES, isAllow);
        }
        return this;
    }
 
    /**
     * 是否允许安装包
     *
     * @param packageName
     * @return
     */
    public boolean isInstallPackageAllowed(String packageName) {
        return isOpAllowed(packageName, OP_REQUEST_INSTALL_PACKAGES);
    }
 
    /**
     * 允许禁止无障碍
     *
     * @param packageName
     * @param className
     * @param allow
     * @return
     */
    public SystemApi allowAccessibility(String packageName, String className, boolean allow) {
        if (!isSupportAccessibility()) return this;
        boolean hasService = isAccessibilityServiceEnabled(packageName, className);
        String srcServiceName = Settings.Secure.getString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
        String myServiceName = packageName + "/" + className;
        if (allow) {
            if (!hasService) {
                int enabled = 0;
                try {
                    enabled = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED);
                } catch (Throwable e) {
                    printError(e);
                }
                if (enabled == 0) {
                    try {
                        Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1);
                    } catch (Throwable e) {
                        printError(e);
                    }
                }
                if (srcServiceName == null || srcServiceName.trim().isEmpty()) {
                    srcServiceName = myServiceName;
                } else {
                    srcServiceName = srcServiceName + ":" + myServiceName;
                }
                try {
                    Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, makeSettingsValue(srcServiceName));
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        } else {
            if (hasService) {
                if (srcServiceName.equals(myServiceName)) {
                    srcServiceName = "";
                } else {
                    if (srcServiceName.endsWith(myServiceName)) {
                        srcServiceName = srcServiceName.replace(":" + myServiceName, "");
                    } else {
                        srcServiceName = srcServiceName.replace(myServiceName + ":", "");
                    }
                }
                if (srcServiceName.isEmpty()) {
                    srcServiceName = "\"\"";
                }
                try {
                    Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, makeSettingsValue(srcServiceName));
                } catch (Throwable e) {
                    printError(e);
                }
            }
        }
        return this;
    }
 
    /**
     * 允许禁止无障碍
     *
     * @param service
     * @param allow
     * @return
     */
    public SystemApi allowAccessibility(Class<? extends AccessibilityService> service, boolean allow) {
        allowAccessibility(mContext.getPackageName(), service.getName(), allow);
        return this;
    }
 
    /**
     * 允许禁止无障碍
     *
     * @param service
     * @param allow
     * @return
     */
    public SystemApi allowAccessibility(ComponentName service, boolean allow) {
        allowAccessibility(service.getPackageName(), service.getClassName(), allow);
        return this;
    }
 
    /**
     * 允许禁止设备管理器
     *
     * @param packageName
     * @param className
     * @param allow
     * @return
     */
    public SystemApi allowDeviceAdmin(String packageName, String className, boolean allow) {
        allowDeviceAdmin(new ComponentName(packageName, className), allow);
        return this;
    }
 
    public SystemApi allowDeviceAdmin(String componentName, boolean allow) {
        allowDeviceAdmin(parse(componentName), allow);
        return this;
    }
 
    /**
     * 允许禁止设备管理器
     *
     * @param activeAdmin
     * @param allow
     * @return
     */
    public SystemApi allowDeviceAdmin(Class<? extends DeviceAdminReceiver> activeAdmin, boolean allow) {
        allowDeviceAdmin(new ComponentName(mContext, activeAdmin), allow);
        return this;
    }
 
    /**
     * 允许禁止设备管理器
     *
     * @param activeAdmin
     * @param allow
     * @return
     */
    public SystemApi allowDeviceAdmin(ComponentName activeAdmin, boolean allow) {
        if (activeAdmin == null) return this;
        if (!isSupportDeviceAdmin()) return this;
        if (allow) {
            try {
                Method method = DevicePolicyManager.class.getMethod("setActiveAdmin", ComponentName.class, boolean.class);
                DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
                method.invoke(dpm, activeAdmin, true);
            } catch (Exception e) {
                printError(e);
            }
        } else {
            try {
                DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
                dpm.removeActiveAdmin(activeAdmin);
            } catch (Exception e) {
                printError(e);
            }
        }
        return this;
    }
 
 
    /**
     * 是否支持设备管理器
     *
     * @return
     */
    public static boolean isSupportDeviceAdmin() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO;
    }
 
    /**
     * 是否支持无障碍
     *
     * @return
     */
    public static boolean isSupportAccessibility() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.DONUT;
    }
 
    /**
     * 是否需要请求权限
     *
     * @return
     */
    public static boolean needRuntimePermission() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
    }
 
    /**
     * 是否启用无障碍
     *
     * @param pkgName
     * @param className
     * @return
     */
    public boolean isAccessibilityServiceEnabled(String pkgName, String className) {
        if (!isSupportAccessibility()) {
            return false;
        }
        if (isEmpty(pkgName) || isEmpty(className)) {
            return false;
        }
        try {
            int enabled = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED);
            if (enabled == 1) {
                String service = Settings.Secure.getString(mContext.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
                if (className.startsWith(".")) {
                    className = pkgName + className;
                }
                String myServiceName = pkgName + "/" + className;
 
                boolean hasService = service != null && service.contains(myServiceName);
                return hasService;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
 
    /**
     * 是否启用无障碍
     *
     * @param serviceClass
     * @return
     */
    public boolean isAccessibilityServiceEnabled(Class<? extends AccessibilityService> serviceClass) {
        return isAccessibilityServiceEnabled(mContext.getPackageName(), serviceClass.getCanonicalName());
    }
 
    /**
     * 是否启用无障碍
     *
     * @param service
     * @return
     */
    public boolean isAccessibilityServiceEnabled(ComponentName service) {
        return isAccessibilityServiceEnabled(service.getPackageName(), service.getClassName());
    }
 
    /**
     * 是否是设备管理器
     *
     * @param admin
     * @return
     */
    public boolean isDeviceAdmin(ComponentName admin) {
        if (!isSupportDeviceAdmin()) {
            return false;
        }
        DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
        return dpm.isAdminActive(admin);
    }
 
    /**
     * 是否是设备管理器
     *
     * @param pkgName
     * @param className
     * @return
     */
    public boolean isDeviceAdmin(String pkgName, String className) {
        return isDeviceAdmin(new ComponentName(pkgName, className));
    }
 
    /**
     * 是否是设备管理器
     *
     * @param receiverClass
     * @return
     */
    public boolean isDeviceAdmin(Class<? extends DeviceAdminReceiver> receiverClass) {
        return isDeviceAdmin(new ComponentName(mContext, receiverClass));
    }
 
    /**
     * 设置设备所有者
     *
     * @param pkgName
     * @return
     */
    public boolean setDeviceOwner(String pkgName) {
        if (!isSupportDeviceAdmin()) {
            return false;
        }
        ComponentName admin = getDeviceAdminClass(mContext, pkgName);
        if (admin == null) {
            return false;
        }
        DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
        try {
            Method method = dpm.getClass().getMethod("setDeviceOwner", ComponentName.class);
            return (boolean) method.invoke(dpm, admin);
        } catch (Exception e) {
            printError("setDeviceOwner", e);
        }
        return false;
    }
 
    /**
     * 移除设备所有者
     *
     * @param pkgName
     */
    public void removeDeviceOwner(String pkgName) {
        DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                dpm.clearDeviceOwnerApp(pkgName);
            }
        } catch (Exception e) {
            printError(e);
        }
    }
 
 
    /**
     * 是否设备所有者
     *
     * @param pkgName
     * @return
     */
    public boolean isDeviceOwner(String pkgName) {
        if (!isSupportDeviceAdmin()) {
            return false;
        }
        DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService(Service.DEVICE_POLICY_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            return dpm.isDeviceOwnerApp(pkgName);
        }
        return false;
    }
 
    /**
     * 设置包状态
     *
     * @param packageName
     * @param state       PackageManager.COMPONENT_
     */
    public boolean setPackageState(String packageName, int state) {
        try {
            Log.d(TAG, "setPackageState: " + packageName + ", state=" + state);
            mContext.getPackageManager().setApplicationEnabledSetting(packageName, state, 0);
            return true;
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
    /**
     * 获取包状态
     *
     * @param packageName
     * @return
     */
    public int getPackageState(String packageName) {
        try {
            return mContext.getPackageManager().getApplicationEnabledSetting(packageName);
        } catch (Exception e) {
            printError(e);
        }
        return ERROR_COMPONENT_STATE;
    }
 
    /**
     * 设置组件状态
     *
     * @param componentName
     * @param state:PackageManager.COMPONENT_
     */
    public boolean setComponentState(ComponentName componentName, int state) {
        try {
            Log.d(TAG, "setComponentEnabledSetting: " + componentName.toShortString() + ", state=" + state);
            mContext.getPackageManager().setComponentEnabledSetting(componentName, state, 0);
            return true;
        } catch (Exception e) {
            printError("setComponentState", e);
        }
        return false;
    }
 
    /**
     * 获取组件状态
     *
     * @param componentName
     * @return
     */
    public int getComponentState(ComponentName componentName) {
        try {
            return mContext.getPackageManager().getComponentEnabledSetting(componentName);
        } catch (Exception e) {
            printError(e);
        }
        return ERROR_COMPONENT_STATE;
    }
 
    /**
     * 设置组件状态
     *
     * @param packageName
     * @param className
     * @param state:PackageManager.COMPONENT_
     */
    public boolean setComponentState(String packageName, String className, int state) {
        return setComponentState(new ComponentName(packageName, className), state);
    }
 
    /**
     * 禁止包
     *
     * @param packageName
     * @param disable     true:禁止，false:恢复默认
     */
    public boolean disablePackage(String packageName, boolean disable) {
        return setPackageState(packageName, disable ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED : PackageManager.COMPONENT_ENABLED_STATE_DEFAULT);
    }
 
    /**
     * 判断包是否禁止
     *
     * @param packageName
     * @return
     */
    public boolean isPackageDisabled(String packageName) {
        int state = getPackageState(packageName);
        return state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED
                || state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER
                || state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    }
 
    /**
     * 启用包
     *
     * @param packageName
     * @return
     */
    public boolean enablePackage(String packageName) {
        return setPackageState(packageName, PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
    }
 
    /**
     * 禁止组件
     *
     * @param componentName
     * @param disable
     */
    public boolean disableComponent(ComponentName componentName, boolean disable) {
        return setComponentState(componentName, disable ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED : PackageManager.COMPONENT_ENABLED_STATE_DEFAULT);
    }
 
    /**
     * 禁止组件
     *
     * @param packageName
     * @param className
     * @param disable     true:禁止，false:恢复默认
     */
    public boolean disableComponent(String packageName, String className, boolean disable) {
        if (className != null && className.startsWith(".")) {
            className = packageName + className;
        }
        return disableComponent(new ComponentName(packageName, className), disable);
    }
 
    /**
     * 禁止组件
     *
     * @param componentName
     * @param disable
     */
    public void disableComponent(String componentName, boolean disable) {
        int start = componentName.indexOf('/');
        if (start != -1) {
            disableComponent(componentName.substring(0, start), componentName.substring(start + 1), disable);
        }
    }
 
    /**
     * 启用组件
     *
     * @param componentName
     * @return
     */
    public boolean enableComponent(ComponentName componentName) {
        return setComponentState(componentName, PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
    }
 
    /**
     * 启用组件
     *
     * @param packageName
     * @param className
     * @return
     */
    public boolean enableComponent(String packageName, String className) {
        return enableComponent(new ComponentName(packageName, className));
    }
 
    /**
     * 判断组件是否禁止
     *
     * @param componentName
     * @return
     */
    public boolean isComponentDisabled(ComponentName componentName) {
        int state = getComponentState(componentName);
        return state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED
                || state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER
                || state == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    }
 
    /**
     * 判断组件是否禁止
     *
     * @param packageName
     * @param className
     * @return
     */
    public boolean isComponentDisabled(String packageName, String className) {
        return isComponentDisabled(new ComponentName(packageName, className));
    }
 
    /**
     * 隐藏包
     *
     * @param packageName
     * @param hidden
     */
    public void hideApplication(String packageName, boolean hidden) {
        try {
            Method method = PackageManager.class.getMethod("setApplicationHiddenSettingAsUser", String.class, boolean.class, UserHandle.class);
            PackageManager pm = mContext.getPackageManager();
            method.invoke(pm, packageName, hidden, newUserHandler(0));
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 判断包是否隐藏
     *
     * @param packageName
     * @return
     */
    public boolean isApplicationHidden(String packageName) {
        try {
            Method method = PackageManager.class.getMethod("getApplicationHiddenSettingAsUser", String.class, UserHandle.class);
            PackageManager pm = mContext.getPackageManager();
            return (boolean) method.invoke(pm, packageName, newUserHandler(0));
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
    /*public String[] suspendPackage(String[] packageNames, boolean suspended) {
        try {
            Method method = PackageManager.class.getMethod("setPackagesSuspendedAsUser", String[].class, boolean.class, int.class);
            PackageManager pm = mContext.getPackageManager();
            return (String[]) method.invoke(pm, packageNames, suspended, 0);
        } catch (Exception e) {
            printError(e);
        }
        return null;
    }*/
 
    /**
     * 杀死应用
     *
     * @param packageName
     */
    public void forceStopPackage(String packageName) {
        try {
            Method method = ActivityManager.class.getMethod("forceStopPackage", String.class);
            ActivityManager am = (ActivityManager) mContext.getSystemService(Service.ACTIVITY_SERVICE);
            method.invoke(am, packageName);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 清除应用数据
     *
     * @param packageName
     * @return
     */
    public boolean clearApplicationData(String packageName) {
        boolean isSuccess = false;
        IPackageDataObserver.Stub mStub = new IPackageDataObserver.Stub() {
            public void onRemoveCompleted(String paramAnonymousString, boolean paramAnonymousBoolean) {
            }
        };
        try {
            Method method = ActivityManager.class.getMethod("clearApplicationUserData", String.class, IPackageDataObserver.class);
            ActivityManager am = (ActivityManager) mContext.getSystemService(Service.ACTIVITY_SERVICE);
            isSuccess = (boolean) method.invoke(am, packageName, mStub);
        } catch (Exception e) {
            printError(e);
        }
        return isSuccess;
    }
 
    /**
     * 清除应用缓存
     *
     * @param packageName
     */
    public void clearApplicationCache(String packageName) {
        IPackageDataObserver.Stub mStub = new IPackageDataObserver.Stub() {
            public void onRemoveCompleted(String paramAnonymousString, boolean paramAnonymousBoolean) {
            }
        };
        try {
            Method method = PackageManager.class.getMethod("deleteApplicationCacheFiles", String.class, IPackageDataObserver.class);
            PackageManager pm = mContext.getPackageManager();
            method.invoke(pm, packageName, mStub);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 安装应用
     *
     * @param path
     */
    public void installPackage(final String path, final OnPackageInstallListener listener) {
        // Toast.makeText(mContext, "path="+ path, Toast.LENGTH_SHORT).show();
        if (Build.VERSION.SDK_INT < 28) {
            IPackageInstallObserver.Stub mStub = new IPackageInstallObserver.Stub() {
                @Override
                public void packageInstalled(String packageName, int returnCode) throws RemoteException {
                    if (listener != null)
                        listener.onPackageInstalled(packageName, returnCode == INSTALL_SUCCEEDED ? STATUS_SUCCESS : STATUS_FAILURE);
                }
            };
            try {
                Method method = PackageManager.class.getMethod("installPackage", Uri.class, IPackageInstallObserver.class, int.class, String.class);
                PackageManager pm = mContext.getPackageManager();
                Uri uri = Uri.fromFile(new File(path));
                method.invoke(pm, uri, mStub, INSTALL_REPLACE_EXISTING, null);
            } catch (Exception e) {
                printError(e);
                if (listener != null) {
                    listener.onPackageInstalled(null, STATUS_FAILURE);
                }
            }
        } else {
            installPackageFromQ(path, listener);
        }
 
    }
 
    public int installExistingPackage(String packageName) {
        try {
            Method method = PackageManager.class.getMethod("installExistingPackage", String.class);
            PackageManager pm = mContext.getPackageManager();
            return (int) method.invoke(pm, packageName);
        } catch (Exception e) {
            printError(e);
        }
        return -1;
    }
 
    /**
     * 安装应用
     *
     * @param path
     */
    public void installPackage(String path) {
        installPackage(path, null);
    }
 
    public boolean launchApplication(String packageName) {
        try {
            Intent intent = mContext.getPackageManager().getLaunchIntentForPackage(packageName);
            if (intent != null) {
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                mContext.startActivity(intent);
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
 
    /**
     * 卸载应用
     *
     * @param packageName
     */
    public void deletePackage(String packageName, boolean isDeleteSystemApp, final OnPackageDeleteListener listener) {
        IPackageDeleteObserver.Stub mStub = new IPackageDeleteObserver.Stub() {
            @Override
            public void packageDeleted(String packageName, int returnCode) throws RemoteException {
                if (listener != null) {
                    listener.onPackageDeleted(packageName, returnCode == DELETE_SUCCEEDED ? STATUS_SUCCESS : STATUS_FAILURE);
                }
            }
        };
        try {
            Method method = PackageManager.class.getMethod("deletePackage", String.class, IPackageDeleteObserver.class, int.class);
            PackageManager pm = mContext.getPackageManager();
            method.invoke(pm, packageName, mStub, isDeleteSystemApp ? DELETE_SYSTEM_APP : 0);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 卸载应用
     *
     * @param packageName
     */
    public void deletePackage(String packageName, final OnPackageDeleteListener listener) {
        deletePackage(packageName, false, listener);
    }
 
 
    /**
     * 卸载应用
     *
     * @param packageName
     */
    public void deletePackage(String packageName) {
        deletePackage(packageName, null);
    }
 
    /**
     * 卸载应用
     *
     * @param packageName
     */
    public void deletePackage(String packageName, boolean isDeleteSystemApp) {
        deletePackage(packageName, isDeleteSystemApp, null);
    }
 
    /**
     * 重启
     */
    public void reboot() {
        PowerManager pm = (PowerManager) mContext.getSystemService(Service.POWER_SERVICE);
        try {
            pm.reboot("");
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 关机
     */
    public void shutdown() {
        try {
            Method method = PowerManager.class.getMethod("shutdown", boolean.class, String.class, boolean.class);
            PowerManager pm = (PowerManager) mContext.getSystemService(Service.POWER_SERVICE);
            method.invoke(pm, false, "", false);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 恢复出厂设置
     */
    public void wipeData() {
        if (Build.VERSION.SDK_INT >= 26) {
            //8.0以上
            Intent intent = new Intent(ACTION_FACTORY_RESET);
            intent.setPackage("android");
            intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
            intent.putExtra(EXTRA_REASON, "MasterClearConfirm");
            intent.putExtra(EXTRA_WIPE_EXTERNAL_STORAGE, true);
            mContext.sendBroadcast(intent);
        } else {
            Intent intent = new Intent(ACTION_MASTER_CLEAR);
            intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
            intent.putExtra(EXTRA_REASON, "MasterClearConfirm");
            intent.putExtra(EXTRA_WIPE_EXTERNAL_STORAGE, true);
            mContext.sendBroadcast(intent);
        }
//        try {
//            RecoverySystem.rebootWipeUserData(mContext);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
    }
 
    /**
     * 设置系统时间
     *
     * @param time
     */
    public void setSystemTime(long time) {
        try {
            AlarmManager am = (AlarmManager) mContext.getSystemService(Service.ALARM_SERVICE);
            am.setTime(time);
        } catch (Throwable e) {
            printError(e);
        }
    }
 
    /**
     * 执行shell命令
     *
     * @param command
     */
    public void execSync(String command) {
        Process process = null;
        try {
            process = Runtime.getRuntime().exec(command);
            process.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (process != null) {
                    process.destroy();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
 
    /**
     * 执行shell命令
     *
     * @param command
     */
    public void exec(final String command) {
        new Thread() {
            @Override
            public void run() {
                super.run();
                execSync(command);
            }
        }.start();
    }
 
    /**
     * 设置主线程处理
     *
     * @param mHandler
     */
    public void setUiHandler(Handler mHandler) {
        this.mHandler = mHandler;
    }
 
    /**
     * 禁止状态栏展开
     *
     * @param disable
     */
    public void disableStatusBarExpand(boolean disable) {
        try {
            @SuppressLint("WrongConstant") Object service = mContext.getSystemService("statusbar");
            Class<?> c = Class.forName("android.app.StatusBarManager");
            Method method = c.getMethod("disable2", int.class);
            method.invoke(service, disable ? DISABLE2_MASK : 0);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 禁止系统界面
     *
     * @param statusbar
     * @param notificationBar
     * @param home
     * @param back
     * @param recent
     */
    public void disableSystemUI(boolean statusbar, boolean notificationBar, boolean home, boolean back, boolean recent) {
        int value = 0;
        if (statusbar) value |= 0x00010000;
        if (notificationBar) value |= (0x00020000 | 0x00040000 | 0x00080000);
        if (home) value |= 0x00200000;
        if (back) value |= 0x00400000;
        if (recent) value |= 0x01000000;
        disableSystemUI(value);
    }
 
    public void disableSystemUI(int state) {
        try {
            @SuppressLint("WrongConstant") Object service = mContext.getSystemService("statusbar");
            Class<?> c = Class.forName("android.app.StatusBarManager");
            Method method = c.getMethod("disable", int.class);
            method.invoke(service, state);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    public void disableSystemUIEx(int state) {
        try {
            @SuppressLint("WrongConstant") Object service = mContext.getSystemService("statusbar");
            Class<?> c = Class.forName("android.app.StatusBarManager");
            Method method = c.getMethod("disable2", int.class);
            method.invoke(service, state);
        } catch (Exception e) {
            printError(e);
        }
    }
 
 
    /**
     * 设置usb功能
     *
     * @param function
     */
    public void setUsbFunction(String function) {
        UsbManager um = (UsbManager) mContext.getSystemService(Service.USB_SERVICE);
        if (Build.VERSION.SDK_INT < 26) {
            //8.0以下
            try {
                Method setCurrentFunction = um.getClass().getMethod("setCurrentFunction", String.class);
                setCurrentFunction.invoke(um, function);
 
                Method setUsbDataUnlocked = um.getClass().getMethod("setUsbDataUnlocked", boolean.class);
                if (function != null && function.equals("none")) {
                    setUsbDataUnlocked.invoke(um, false);
                } else {
                    setUsbDataUnlocked.invoke(um, true);
                }
            } catch (Exception e) {
                printError(e);
            }
        } else {
            //8.0以上
            try {
                Method setCurrentFunction = um.getClass().getMethod("setCurrentFunction", String.class, boolean.class);
                if (function != null && function.equals("none")) {
                    setCurrentFunction.invoke(um, function, false);
                } else {
                    setCurrentFunction.invoke(um, function, true);
                }
            } catch (Exception e) {
                printError(e);
            }
        }
 
    }
 
    /**
     * 设置用户限制
     *
     * @param key
     * @param value
     */
    public void setUserRestriction(String key, boolean value) {
        UserManager um = (UserManager) mContext.getSystemService(Service.USER_SERVICE);
        try {
            Method method = um.getClass().getMethod("setUserRestriction", String.class, boolean.class);
            method.invoke(um, key, value);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 是否有用户限制
     *
     * @param key
     * @return
     */
    public boolean hasUserRestriction(String key) {
        UserManager um = (UserManager) mContext.getSystemService(Service.USER_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            try {
                return um.hasUserRestriction(key);
            } catch (Exception e) {
                printError(e);
            }
        }
        return false;
    }
 
    /**
     * 权限转OP代码
     *
     * @param permission
     * @return
     */
    public int permissionToOpCode(String permission) {
        AppOpsManager manager = (AppOpsManager) mContext.getSystemService(Service.APP_OPS_SERVICE);
        try {
            Method method = manager.getClass().getMethod("permissionToOpCode", String.class);
            return (int) method.invoke(manager, permission);
        } catch (Exception e) {
            printError(e);
        }
        return -1;
    }
 
    /**
     * 禁止卸载应用
     *
     * @param packageName
     * @param block
     * @return
     */
    public boolean setBlockUninstall(String packageName, boolean block) {
        Object mPm = getIPackageManager();
        if (mPm == null) return false;
        try {
            Method method = mPm.getClass().getMethod("setBlockUninstallForUser", String.class, boolean.class, int.class);
            return (boolean) method.invoke(mPm, packageName, block, 0);
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
    /**
     * 是否禁止卸载应用
     *
     * @param packageName
     * @return
     */
    public boolean isUninstallBlocked(String packageName) {
        Object mPm = getIPackageManager();
        if (mPm == null) return false;
        try {
            Method method = mPm.getClass().getMethod("getBlockUninstallForUser", String.class, int.class);
            return (boolean) method.invoke(mPm, packageName, 0);
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
    /**
     * 设置默认桌面
     *
     * @param launcher
     */
    public void setHomeLauncher(ComponentName launcher) {
        Object mPm = getIPackageManager();
        if (mPm == null) return;
        try {
            Method method = mPm.getClass().getMethod("setHomeActivity", ComponentName.class, int.class);
            method.invoke(mPm, launcher, 0);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    /**
     * 设置默认桌面
     *
     * @param packageName
     * @param className
     */
    public void setHomeLauncher(String packageName, String className) {
        setHomeLauncher(new ComponentName(packageName, className));
    }
 
    /**
     * 设置默认桌面
     *
     * @param packageName
     */
    public boolean setHomeLauncher(String packageName) {
        if (packageName == null) return false;
        List<ComponentName> launchers = new ArrayList<>();
        getHomeLauncherList(launchers);
        for (ComponentName launcher : launchers) {
            if (launcher.getPackageName().equals(packageName)) {
                setHomeLauncher(launcher);
                return true;
            }
        }
        return false;
    }
 
    /**
     * 获取默认桌面
     *
     * @return
     */
    public ComponentName getHomeLauncher() {
        List<ComponentName> mList = new ArrayList<>();
        return getHomeLauncherList(mList);
    }
 
    /**
     * 获取默认桌面包名
     *
     * @return
     */
    public String getHomeLauncherPackage() {
        ComponentName launcher = getHomeLauncher();
        return launcher != null ? launcher.getPackageName() : null;
    }
 
    /**
     * 清除默认桌面
     */
    public void clearHomeLauncher() {
        ComponentName launcher = getHomeLauncher();
        if (launcher != null) {
            try {
                mContext.getPackageManager().clearPackagePreferredActivities(launcher.getPackageName());
            } catch (Exception e) {
                printError(e);
            }
        }
    }
 
    /**
     * 获取桌面列表，返回默认桌面
     *
     * @param launchers
     * @return
     */
    public ComponentName getHomeLauncherList(List<ComponentName> launchers) {
        if (launchers == null) return null;
        try {
            PackageManager pm = mContext.getPackageManager();
            Method method = pm.getClass().getMethod("getHomeActivities", List.class);
            List<ResolveInfo> resolveInfos = new ArrayList<>();
            ComponentName defaultLauncher = (ComponentName) method.invoke(pm, resolveInfos);
            for (ResolveInfo resolveInfo : resolveInfos) {
                if (resolveInfo.activityInfo != null
                        && hasValue(resolveInfo.activityInfo.packageName)
                        && hasValue(resolveInfo.activityInfo.name)) {
                    launchers.add(new ComponentName(resolveInfo.activityInfo.packageName, resolveInfo.activityInfo.name));
                }
            }
            return defaultLauncher;
        } catch (Exception e) {
            printError(e);
        }
        return null;
    }
 
    /**
     * 禁用sim卡
     */
    public void disableMobileRadios() {
        IInterface mIPhone = getAIDLService("phone", "com.android.internal.telephony.ITelephony");
        try {
            Method method = mIPhone.getClass().getMethod("shutdownMobileRadios");
            method.invoke(mIPhone);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 设置电源保护模式
     *
     * @param mode
     * @return
     */
    public boolean setPowerSaveMode(int mode) {
        try {
            IInterface mIPowerManagerEx = getAIDLService("power_ex", "android.os.IPowerManagerEx");
            Method setPowerSaveMode = mIPowerManagerEx.getClass().getMethod("setPowerSaveMode", int.class);
            return (boolean) setPowerSaveMode.invoke(mIPowerManagerEx, mode);
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
    /**
     * 添加电源优化白名单
     *
     * @param packageName
     */
    public void addPowerSaveWhiteApp(String packageName) {
        IInterface mIDeviceIdleController = getAIDLService("deviceidle", "android.os.IDeviceIdleController");
        if (mIDeviceIdleController != null) {
            try {
                Method method = mIDeviceIdleController.getClass().getMethod("addPowerSaveWhitelistApp", String.class);
                method.invoke(mIDeviceIdleController, packageName);
            } catch (Exception e) {
                printError(e);
            }
        }
    }
 
    /**
     * 移除电源优化白名单
     *
     * @param packageName
     */
    public void removePowerSaveWhiteApp(String packageName) {
        IInterface mIDeviceIdleController = getAIDLService("deviceidle", "android.os.IDeviceIdleController");
        if (mIDeviceIdleController != null) {
            try {
                Method method = mIDeviceIdleController.getClass().getMethod("removePowerSaveWhitelistApp", String.class);
                method.invoke(mIDeviceIdleController, packageName);
            } catch (Exception e) {
                printError(e);
            }
        }
    }
 
    /**
     * 是否电源优化白名单
     *
     * @param packageName
     * @return
     */
    public boolean isPowerSaveWhiteApp(String packageName) {
        IInterface mIDeviceIdleController = getAIDLService("deviceidle", "android.os.IDeviceIdleController");
        if (mIDeviceIdleController != null) {
            try {
                Method method = mIDeviceIdleController.getClass().getMethod("isPowerSaveWhitelistApp", String.class);
                return (boolean) method.invoke(mIDeviceIdleController, packageName);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return false;
    }
 
    /**
     * 挂载外部存储
     */
    public void mountExternalStorage() {
        StorageManager sm = (StorageManager) mContext.getSystemService(Service.STORAGE_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            List<StorageVolume> volumes = sm.getStorageVolumes();
            if (volumes != null) {
                for (StorageVolume volume : volumes) {
                    try {
                        if (!volume.isPrimary()) {
                            String volumeId = (String) volume.getClass().getMethod("getId").invoke(volume);
                            sm.getClass().getMethod("mount", String.class).invoke(sm, volumeId);
                        }
                        //print("挂载外部存储成功");
                    } catch (Exception e) {
                        e.printStackTrace();
                        printError(e);
                        //print("挂载外部存储失败");
                    }
                }
            }
        }
    }
 
    /**
     * 卸载外部存储
     */
    public void unmountExternalStorage() {
        StorageManager sm = (StorageManager) mContext.getSystemService(Service.STORAGE_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            List<StorageVolume> volumes = sm.getStorageVolumes();
            if (volumes != null) {
                for (StorageVolume volume : volumes) {
                    try {
                        if (!volume.isPrimary()) {
                            String volumeId = (String) volume.getClass().getMethod("getId").invoke(volume);
                            sm.getClass().getMethod("unmount", String.class).invoke(sm, volumeId);
                        }
                        //print("卸载外部存储成功");
                    } catch (Exception e) {
                        e.printStackTrace();
                        printError(e);
                        //print("卸载外部存储失败");
                    }
                }
            }
        }
    }
 
    /**
     * 截屏
     *
     * @return
     */
    public Bitmap screenshot() {
        WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        if (Build.VERSION.SDK_INT >= 31) {
            //android 12
            VirtualDisplay virtualDisplay = null;
            ImageReader reader = null;
            Image image = null;
            try {
                DisplayMetrics metrics = new DisplayMetrics();
                wm.getDefaultDisplay().getRealMetrics(metrics);
                DisplayManager dm = (DisplayManager) mContext.getSystemService(Service.DISPLAY_SERVICE);
                reader = ImageReader.newInstance(metrics.widthPixels, metrics.heightPixels, PixelFormat.RGBA_8888, 1);
                virtualDisplay = dm.createVirtualDisplay("launcher3_screen", metrics.widthPixels, metrics.heightPixels, metrics.densityDpi, reader.getSurface(),
                        DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR);
 
                int count = 0;
                while (image == null) {
                    Thread.sleep(50);
                    image = reader.acquireLatestImage();
                    if (++count > 10) {
                        break;
                    }
                }
                if (image != null) {
                    int width = image.getWidth();
                    int height = image.getHeight();
                    final Image.Plane[] planes = image.getPlanes();
                    final ByteBuffer buffer = planes[0].getBuffer();
                    int pixelStride = planes[0].getPixelStride();
                    int rowStride = planes[0].getRowStride();
                    int rowPadding = rowStride - pixelStride * width;
                    Bitmap bitmap = Bitmap.createBitmap(width + rowPadding / pixelStride, height, Bitmap.Config.ARGB_8888);
                    bitmap.copyPixelsFromBuffer(buffer);
                    return bitmap;
                }
            } catch (Throwable e) {
                printError("screenshot", e);
            } finally {
                try {
                    if (image != null) {
                        image.close();
                    }
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
                try {
                    if (virtualDisplay != null) {
                        virtualDisplay.release();
                    }
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
                try {
                    if (reader != null) {
                        reader.close();
                    }
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        } else {
            try {
                Class c = Class.forName("android.view.SurfaceControl");
//            if (Build.VERSION.SDK_INT >= 31) {
//                /*Class CDisplayCaptureArgs = Class.forName("android.view.SurfaceControl$DisplayCaptureArgs");
//                Method method = c.getDeclaredMethod("captureDisplay", CDisplayCaptureArgs);
//                method.setAccessible(true);
//                Object mScreenshotHardwareBuffer = method.invoke(c, null);
//                Log.i(TAG, "screenshot" + (mScreenshotHardwareBuffer == null));*/
//            } else {
//
//            }
                Method method = c.getMethod("screenshot", Rect.class, int.class, int.class, int.class);
                return (Bitmap) method.invoke(c, new Rect(), 0, 0, wm.getDefaultDisplay().getRotation());
            } catch (Exception e) {
                printError("screenshot", e);
            }
        }
        return null;
    }
 
 
    public Bitmap screenshotHw() {
        WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        Class c = null;
        try {
            c = Class.forName("android.view.SurfaceControl");
            Method method = c.getMethod("screenshot_ext_hw", Rect.class, int.class, int.class, int.class);
            return (Bitmap) method.invoke(c, new Rect(0, 0, 2000, 1200), 2000, 1200, wm.getDefaultDisplay().getRotation());
        } catch (Throwable e) {
            printError(e);
        }
        return null;
    }
 
    public Bitmap screenshot(int minLayer, int maxLayer) {
        WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        try {
            Class c = Class.forName("android.view.SurfaceControl");
            Method method = c.getMethod("screenshot", Rect.class, int.class, int.class, int.class, int.class, boolean.class, int.class);
            return (Bitmap) method.invoke(c, new Rect(), 0, 0, minLayer, maxLayer, true, wm.getDefaultDisplay().getRotation());
        } catch (Exception e) {
            printError(e);
        }
        return null;
    }
 
 
    /**
     * 设置防火墙模式
     *
     * @param isWhiteMode
     */
    public void setFirewallMode(boolean isWhiteMode) {
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            for (int i = 0; i <= 3; i++) {
                try {
                    Method setFirewallChainEnabled = mINetworkManagementService.getClass().getDeclaredMethod("setFirewallChainEnabled", int.class, boolean.class);
                    setFirewallChainEnabled.invoke(mINetworkManagementService, i, isWhiteMode);
                } catch (Exception e) {
                    printError(e);
                }
            }
        }
    }
 
    /**
     * 设置防火墙规则
     *
     * @param packageName
     * @param allow
     */
    public void setFirewallPackageRule(String packageName, boolean allow) {
        int uid = getPackageUid(packageName);
        if (uid <= 0) return;
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            for (int i = 0; i <= 3; i++) {
                try {
                    Method method = mINetworkManagementService.getClass().getDeclaredMethod("setFirewallUidRule", int.class, int.class, int.class);
                    method.invoke(mINetworkManagementService, i, uid, allow ? FIREWALL_RULE_ALLOW : FIREWALL_RULE_DENY);
                } catch (Exception e) {
                    printError("setFirewallPackageRule", e);
                }
            }
        }
    }
 
    /**
     * 设置防火墙规则 <=android9.0
     *
     * @param packageNames
     * @param allow
     */
    public void setFirewallPackageRules(List<String> packageNames, boolean allow) {
        if (packageNames == null || packageNames.isEmpty()) return;
        int size = packageNames.size();
        int[] uids = new int[size];
        int[] rules = new int[size];
        int allowValue = allow ? FIREWALL_RULE_ALLOW : FIREWALL_RULE_DENY;
        for (int i = 0; i < size; i++) {
            uids[i] = getPackageUid(packageNames.get(i));
            rules[i] = allowValue;
            print(uids[i], rules[i]);
        }
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            for (int i = 0; i <= 3; i++) {
                try {
                    Method method = mINetworkManagementService.getClass().getDeclaredMethod("setFirewallUidRules", int.class, int[].class, int[].class);
                    method.invoke(mINetworkManagementService, i, uids, rules);
                } catch (Exception e) {
                    e.printStackTrace();
                    print("setFirewallPackageRules", e);
                }
            }
        }
    }
 
    /**
     * 设置防火墙状态
     *
     * @param enabled
     */
    public void setFirewallEnabled(boolean enabled) {
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            try {
                Method setFirewallEnabled = mINetworkManagementService.getClass().getDeclaredMethod("setFirewallEnabled", boolean.class);
                setFirewallEnabled.invoke(mINetworkManagementService, enabled);
            } catch (Exception e) {
                printError(e);
            }
        }
    }
 
    /**
     * 防火墙是否开启
     *
     * @return
     */
    public boolean isFirewallEnabled() {
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            try {
                Method isFirewallEnabled = mINetworkManagementService.getClass().getDeclaredMethod("isFirewallEnabled");
                return (boolean) isFirewallEnabled.invoke(mINetworkManagementService);
            } catch (Exception e) {
                printError(e);
            }
        }
        return false;
    }
 
    /**
     * 设置ip转发是否可用
     *
     * @param enabled
     */
    public void setIpForwardingEnabled(boolean enabled) {
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            try {
                Method setIpForwardingEnabled = mINetworkManagementService.getClass().getDeclaredMethod("setIpForwardingEnabled", boolean.class);
                setIpForwardingEnabled.invoke(mINetworkManagementService, enabled);
            } catch (Exception e) {
                printError(e);
            }
        }
    }
 
    /**
     * ip转发是否能用
     *
     * @return
     */
    public boolean isIpForwardingEnabled() {
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            try {
                Method getIpForwardingEnabled = mINetworkManagementService.getClass().getDeclaredMethod("getIpForwardingEnabled");
                return (boolean) getIpForwardingEnabled.invoke(mINetworkManagementService);
            } catch (Exception e) {
                printError(e);
            }
        }
        return false;
    }
 
 
    /**
     * 设置锁屏是否禁用
     */
    public void setLockScreenDisabled(boolean disabled) {
        Class c = null;
        try {
            c = Class.forName("com.android.internal.widget.LockPatternUtils");
            Method method = c.getDeclaredMethod("setLockScreenDisabled", boolean.class, int.class);
            method.setAccessible(true);
            method.invoke(newInstance(c, new Class[]{Context.class}, mContext), disabled, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /*
     * 内部数据
     *
     */
    private static boolean hasElement(Collection c) {
        return c != null && !c.isEmpty();
    }
 
    private static boolean hasElement(Object[] array) {
        return array != null && array.length > 0;
    }
 
    private static boolean hasElement(Map map) {
        return map != null && !map.isEmpty();
    }
 
    private static boolean hasValue(String value) {
        return value != null && !value.isEmpty();
    }
 
    private static boolean isEmpty(String value) {
        return !hasValue(value);
    }
 
    private static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }
 
    private static boolean equalsValue(String v1, String v2) {
        return v1 != null && v2 != null && v1.equals(v2);
    }
 
    private SystemApi setOpState(String packageName, int opCode, boolean isAllow) {
        if (isAllow) {
            setOpMode(packageName, opCode, AppOpsManager.MODE_ALLOWED);
        } else {
            setOpMode(packageName, opCode, AppOpsManager.MODE_IGNORED);
        }
        return this;
    }
 
    public boolean grantRuntimePermission(String packageName, String permission) {
        try {
            Method method = PackageManager.class.getMethod("grantRuntimePermission", String.class, String.class, UserHandle.class);
            UserHandle userHandle = (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, 0);
            method.invoke(mContext.getPackageManager(), packageName, permission, userHandle);
            return true;
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
    public void revokeRuntimePermission(String packageName, String permission) {
        try {
            Method method = PackageManager.class.getMethod("revokeRuntimePermission", String.class, String.class, UserHandle.class);
            UserHandle userHandle = (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, 0);
            method.invoke(mContext.getPackageManager(), packageName, permission, userHandle);
        } catch (Exception e) {
            printError(e);
        }
    }
 
    private int getPackageUid(String packageName) {
        try {
            PackageInfo info = mContext.getPackageManager().getPackageInfo(packageName, PackageManager.GET_DISABLED_COMPONENTS);
            if (info != null && info.applicationInfo != null) {
                return info.applicationInfo.uid;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
 
 
    private String makeSettingsValue(String value) {
        return value != null && !value.trim().isEmpty() ? value : "\"\"";
    }
 
//    public void unlockDevice() {
//        try {
//            IInterface mITurstManager = getAIDLService("trust", "android.app.trust.ITrustManager");
//            Method method= mITurstManager.getClass().getMethod("setDeviceLockedForUser", int.class, boolean.class);
//            method.invoke(mITurstManager, 0, false);
//        } catch (Exception e) {
//            printError("unlockDevice", e);
//        }
//
//    }
 
    public interface OnPackageInstallListener {
        void onPackageInstalled(String packageName, int returnCode);
    }
 
    public interface OnPackageDeleteListener {
        void onPackageDeleted(String packageName, int returnCode);
 
    }
 
    private Set<String> getDeniedPermissionList(String packageName, String[] permissions) {
        Set<String> mDeniedPermissionList = new HashSet<>();
        PackageManager pm = mContext.getPackageManager();
        for (String permission : permissions) {
            int pmState = pm.checkPermission(permission, packageName);
            int opMode = getOpMode(packageName, permissionToOpCode(permission));
            boolean hasPermission = pmState == PackageManager.PERMISSION_GRANTED && (opMode == AppOpsManager.MODE_ALLOWED || opMode == AppOpsManager.MODE_DEFAULT);
            if (!hasPermission) {
                mDeniedPermissionList.add(permission);
            }
        }
        return mDeniedPermissionList;
    }
 
 
    private Object newInstance(Class clazz, Class[] argsType, Object... args) {
        Object instance = null;
        try {
            Constructor constructor = clazz.getConstructor(argsType);
            constructor.setAccessible(true);
            instance = constructor.newInstance(args);
        } catch (Exception e) {
            printError(e);
        }
        return instance;
    }
 
    private void print(Object... info) {
        if (mLoggerEnabled || mDebug) {
            if (info == null || info.length == 0) {
                return;
            }
            StringBuilder sb = new StringBuilder();
            for (Object o : info) {
                sb.append(o != null ? o.toString() + ", " : ", ");
            }
            String msg = sb.toString();
            if (msg.endsWith(",")) msg = sb.deleteCharAt(sb.length() - 1).toString();
            Log.i(TAG, msg);
        }
    }
 
    private void printError(Throwable e) {
        printError(null, e);
    }
 
    private void printError(String tag, Throwable e) {
        if (mLoggerEnabled || mDebug) {
            if (e.getCause() != null) {
                Log.e(TAG, (tag == null ? "" : tag + " error=") + e.getCause().toString());
            } else {
                Log.e(TAG, (tag == null ? "" : tag + " error=") + e.toString());
            }
        }
    }
 
 
    /**
     * android9.0 安装应用
     *
     * @param path
     * @param listener
     */
    private void installPackageFromQ(final String path, final OnPackageInstallListener listener) {
 
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            return;
        }
 
        int mSessionId = -1;
        String packageName = null;
 
        try {
            PackageManager pm = mContext.getPackageManager();
 
            PackageInfo packageInfo = pm.getPackageArchiveInfo(path, PackageManager.GET_ACTIVITIES | PackageManager.GET_SERVICES);
            if (packageInfo != null) {
                packageName = packageInfo.packageName;
            }
 
            PackageInstaller packageInstaller = pm.getPackageInstaller();
            PackageInstaller.SessionParams sessionParams = new PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL);
 
            File apkFile = new File(path);
            print("apkFile length" + apkFile.length());
            sessionParams.setSize(apkFile.length());
            mSessionId = packageInstaller.createSession(sessionParams);
        } catch (Throwable e) {
            printError(e);
        }
 
        if (mSessionId != -1 && packageName != null) {
            final int finalMSessionId = mSessionId;
            final String finalPackageName = packageName;
            new Thread() {
                @Override
                public void run() {
                    super.run();
                    boolean copySuccess = onTransfesApkFile(path, finalMSessionId);
                    if (copySuccess) {
                        if (mHandler != null) {
                            mHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    execInstallAPP(finalMSessionId, finalPackageName, listener);
                                }
                            });
                        } else {
                            execInstallAPP(finalMSessionId, finalPackageName, listener);
                        }
                    } else {
                        if (mHandler != null) {
                            mHandler.post(new Runnable() {
                                @Override
                                public void run() {
                                    if (listener != null) {
                                        listener.onPackageInstalled(finalPackageName, STATUS_FAILURE);
                                    }
                                }
                            });
                        } else {
                            if (listener != null) {
                                listener.onPackageInstalled(finalPackageName, STATUS_FAILURE);
                            }
                        }
                    }
                }
            }.start();
        } else {
            if (listener != null) {
                listener.onPackageInstalled(packageName, STATUS_FAILURE);
            }
        }
 
    }
 
 
    private boolean onTransfesApkFile(String apkFilePath, int mSessionId) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            InputStream in = null;
            OutputStream out = null;
            PackageInstaller.Session session = null;
            boolean success = false;
            try {
                File apkFile = new File(apkFilePath);
                session = mContext.getPackageManager().getPackageInstaller().openSession(mSessionId);
                out = session.openWrite("base.apk", 0, apkFile.length());
                in = new FileInputStream(apkFile);
                int total = 0, c;
                byte[] buffer = new byte[1024 * 1024];
                while ((c = in.read(buffer)) != -1) {
                    total += c;
                    out.write(buffer, 0, c);
                }
                session.fsync(out);
                success = true;
            } catch (Throwable e) {
                printError(e);
            } finally {
                if (null != session) {
                    session.close();
                }
                try {
                    if (null != out) {
                        out.close();
                    }
                    if (null != in) {
                        in.close();
                    }
                } catch (Exception e) {
                    printError(e);
                }
            }
            return success;
        }
        return false;
    }
 
    /**
     * 执行安装并通知安装结果
     */
    private void execInstallAPP(int mSessionId, final String packageName, final OnPackageInstallListener listener) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            PackageInstaller.Session session = null;
            try {
                session = mContext.getPackageManager().getPackageInstaller().openSession(mSessionId);
                Intent intent = new Intent(mContext, new BroadcastReceiver() {
                    @Override
                    public void onReceive(Context context, Intent intent) {
                        if (intent != null) {
                            int status = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE);
                            if (listener != null) {
                                listener.onPackageInstalled(packageName, status);
                            }
                        }
                    }
                }.getClass());
                PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext,
                        1, intent,
                        PendingIntent.FLAG_UPDATE_CURRENT);
                session.commit(pendingIntent.getIntentSender());
            } catch (Exception e) {
                printError(e);
                printError(e);
                if (listener != null) {
                    listener.onPackageInstalled(packageName, STATUS_FAILURE);
                }
            } finally {
                if (null != session) {
                    session.close();
                }
            }
        }
    }
 
    private ComponentName getDeviceAdminClass(Context context, String pkgName) {
        List<ResolveInfo> infos = context.getPackageManager().queryBroadcastReceivers(
                new Intent(DeviceAdminReceiver.ACTION_DEVICE_ADMIN_ENABLED),
                PackageManager.GET_DISABLED_UNTIL_USED_COMPONENTS);
        if (infos != null) {
            for (ResolveInfo info : infos) {
                if (info.activityInfo.packageName.equals(pkgName)) {
                    return new ComponentName(pkgName, info.activityInfo.name);
                }
            }
        }
        return null;
    }
 
    private boolean isAppInstalled(String pkgName) {
        try {
            PackageInfo info = mContext.getPackageManager().getPackageInfo(pkgName, PackageManager.GET_DISABLED_COMPONENTS);
            return info != null;
        } catch (Exception e) {
            printError(e);
        }
        return false;
    }
 
 
    private void fixedPermissionInner(String packageName, String permission) {
        updatePermissionFlags(packageName, permission, FLAG_PERMISSION_SYSTEM_FIXED, FLAG_PERMISSION_SYSTEM_FIXED);
    }
 
    private void unfixedPermissionInner(String packageName, String permission) {
        updatePermissionFlags(packageName, permission, FLAG_PERMISSION_SYSTEM_FIXED, 0);
    }
 
    private UserHandle newUserHandler(int id) {
        return (UserHandle) newInstance(UserHandle.class, new Class[]{int.class}, id);
    }
 
    private Object getIPackageManager() {
        try {
            Class<?> atClass = Class.forName("android.app.ActivityThread");
            Method method = atClass.getDeclaredMethod("getPackageManager");
            return method.invoke(atClass);
        } catch (Exception e) {
            printError(e);
        }
        return null;
    }
 
    private IInterface getAIDLService(String serverName, String interfaceName) {
        IBinder binder = getService(serverName);
        if (binder != null) {
            return getInterface(interfaceName, binder);
        }
        return null;
    }
 
    private IBinder getService(String name) {
        try {
            Class ServiceManager = Class.forName("android.os.ServiceManager");
            Method getService = ServiceManager.getMethod("getService", String.class);
            return (IBinder) getService.invoke(ServiceManager, name);
        } catch (Exception e) {
            printError(e);
        }
        return null;
    }
 
    private IInterface getInterface(String name, IBinder service) {
        try {
            Class<?> mClass = Class.forName(name + "$Stub");
            Method asInterface = mClass.getDeclaredMethod("asInterface", IBinder.class);
            return (IInterface) asInterface.invoke(null, service);
        } catch (Exception e) {
            printError(e);
        }
        return null;
    }
 
 
    /**
     * 是否禁止联网 error
     *
     * @param packageName
     * @return
     */
    private boolean isNetworkDisabled(String packageName) {
        int uid = getPackageUid(packageName);
        if (uid <= 0) return false;
        IInterface mINetworkManagementService = getNetworkManagement();
        if (mINetworkManagementService != null) {
            try {
                Method isNetworkRestricted = mINetworkManagementService.getClass().getDeclaredMethod("isNetworkRestricted", int.class);
                return (boolean) isNetworkRestricted.invoke(mINetworkManagementService, uid);
            } catch (Exception e) {
                printError(e);
            }
        }
        return false;
    }
 
    private IInterface getNetworkManagement() {
        return getAIDLService("network_management", "android.os.INetworkManagementService");
    }
 
    public void setLoggerEnabled(boolean loggerEnabled) {
        this.mLoggerEnabled = loggerEnabled;
    }
 
    public static ComponentName parse(String componentName) {
        if (componentName == null || componentName.isEmpty()) return null;
        int pos = componentName.indexOf('/');
        if (pos > 0 && pos < componentName.length() - 1) {
            String packageName = componentName.substring(0, pos).trim();
            String className = componentName.substring(pos + 1).trim();
            if (className.startsWith(".")) {
                className = packageName + className;
            }
            return new ComponentName(packageName, className);
        } else {
            return null;
        }
    }
 
    public boolean removeTask(int taskId) {
        IInterface mIActivityManager = getAIDLService("activity", "android.app.IActivityManager");
        if (mIActivityManager != null) {
            try {
                Method method = mIActivityManager.getClass().getDeclaredMethod("removeTask", int.class);
                return (boolean) method.invoke(mIActivityManager, taskId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return false;
    }
 
    public static String getFactoryMacAddr(Context context) {
        WifiManager manager = (WifiManager) context.getApplicationContext().getSystemService(Service.WIFI_SERVICE);
        try {
            Method getFactoryMacAddresses = manager.getClass().getMethod("getFactoryMacAddresses");
            getFactoryMacAddresses.setAccessible(true);
            String[] macAddrs = (String[]) getFactoryMacAddresses.invoke(manager, null);
            if (macAddrs != null && macAddrs.length > 0) {
                return macAddrs[0].toUpperCase();
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }
}