功能-权限管理

获取权限

app/build.gradle

// 权限
implementation 'com.yanzhenjie:permission:2.0.3'

获取权限

interface PermissionsCallBack {
    fun Granted();
}

private fun getPermission(callback: PermissionsCallBack) {
    if (hasPermissions) {
        callback.Granted()
        return
    }
    if (AndPermission.hasPermissions(this, *permissions)) {
        hasPermissions = true
        callback.Granted()
        return
    }
    AndPermission
        .with(this)
        .runtime()
        .permission(*permissions)
        .onGranted {
            hasPermissions = true
            callback.Granted()
        }
        .onDenied {
            mContext?.let {
                Toasty.info(it, "授权失败，功能无法使用！").show()
                AlertDialog.Builder(it)
                    .setTitle("提示")
                    .setMessage("需要打开应用权限才能正常使用！")
                    .setNegativeButton("取消", object : DialogInterface.OnClickListener {
                        override fun onClick(dialog: DialogInterface?, which: Int) {
                            dialog?.dismiss()
                        }
                    })
                    .setPositiveButton("确定", object : DialogInterface.OnClickListener {
                        override fun onClick(dialog: DialogInterface?, which: Int) {
                            dialog?.dismiss()
                            gotoMiuiPermission()
                        }
                    }).create().show()
            }
        }
        .start();
}

打开权限设置页面

/**
 * 权限管理
 */
public void permissionManager(View view){
    gotoMIUIPermission();
}

/**
 * 小米的权限管理页面
 */
private void gotoMIUIPermission() {
    Intent intent = new Intent("miui.intent.action.APP_PERM_EDITOR");
    ComponentName componentName = new ComponentName(
        "com.miui.securitycenter",
        "com.miui.permcenter.permissions.PermissionsEditorActivity"
    );
    intent.setComponent(componentName);
    intent.putExtra("extra_pkgname", getPackageName());
    try {
        startActivity(intent);
    } catch (Exception e) {
        e.printStackTrace();
        gotoMeizuPermission();
    }
}

/**
 * 跳转到魅族的权限管理系统
 */
private void gotoMeizuPermission() {
    Intent intent = new Intent("com.meizu.safe.security.SHOW_APPSEC");
    intent.addCategory(Intent.CATEGORY_DEFAULT);
    intent.putExtra("packageName", getPackageName());
    try {
        startActivity(intent);
    } catch (Exception e) {
        e.printStackTrace();
        gotoHuaweiPermission();
    }
}

/**
 * 华为的权限管理页面
 */
private void gotoHuaweiPermission() {
    try {
        Intent intent = new Intent();
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        ////华为权限管理
        ComponentName comp = new ComponentName(
            "com.huawei.systemmanager",
            "com.huawei.permissionmanager.ui.MainActivity");
        intent.setComponent(comp);
        startActivity(intent);
    } catch (Exception e) {
        e.printStackTrace();
        getAppDetailSettingIntent();
    }
}

/**
 * 跳转到权限设置界面
 */
public void getAppDetailSettingIntent(){
    try {
        Intent intent = new Intent();
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
        intent.setData(Uri.parse("package:" + getPackageName()));
        startActivity(intent);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

注意：高版本的小米、华为、魅族的权限管理页面不包含通知权限。所以看需求如果也要管理通知权限，那么直接跳转到“权限设置界面”即调用getAppDetailSettingIntent()

自己实现的获取权限

权限检查的工具类

public class PermissionsChecker {
    private final Context mContext;

    public PermissionsChecker(Context context) {
        mContext = context.getApplicationContext();
    }

    // 判断权限集合
    public boolean lacksPermissions(String... permissions) {
        for (String permission : permissions) {
            if (lacksPermission(permission)) {
                return true;
            }
        }
        return false;
    }

    // 判断是否缺少权限
    private boolean lacksPermission(String permission) {
        return ContextCompat.checkSelfPermission(mContext, permission) == PackageManager.PERMISSION_DENIED;
    }

    /*或者以下方法检测权限
    //需要申请的权限
    private static String[] permissions = new String[]{
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.BLUETOOTH,
            Manifest.permission.BLUETOOTH_ADMIN,
            Manifest.permission.CAMERA

    };

    //检测权限
    public static String[] checkPermission(Context context){
        List<String> data = new ArrayList<>();//存储未申请的权限
        for (String permission : permissions) {
            int checkSelfPermission = ContextCompat.checkSelfPermission(context, permission);
            if(checkSelfPermission == PackageManager.PERMISSION_DENIED){//未申请
                data.add(permission);
            }
        }
        return data.toArray(new String[data.size()]);
    }*/
}

权限配置页面

public class PermissionsActivity extends AppCompatActivity {

    public static final int PERMISSIONS_GRANTED = 0; // 权限授权
    public static final int PERMISSIONS_DENIED = 1; // 权限拒绝

    private static final int PERMISSION_REQUEST_CODE = 0; // 系统权限管理页面的参数
    private static final String EXTRA_PERMISSIONS =
            "com.ab.permission.extra_permission"; // 权限参数
    private static final String PACKAGE_URL_SCHEME = "package:"; // 方案

    private PermissionsChecker mChecker; // 权限检测器
    private boolean isRequireCheck; // 是否需要系统权限检测

    // 启动当前权限页面的公开接口
    public static void startActivityForResult(Activity activity, int requestCode, String... permissions) {
        Intent intent = new Intent(activity, PermissionsActivity.class);
        intent.putExtra(EXTRA_PERMISSIONS, permissions);
        ActivityCompat.startActivityForResult(activity, intent, requestCode, null);
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getIntent() == null || !getIntent().hasExtra(EXTRA_PERMISSIONS)) {
            throw new RuntimeException("PermissionsActivity需要使用静态startActivityForResult方法启动!");
        }
        setContentView(R.layout.activity_permissions);

        mChecker = new PermissionsChecker(this);
        isRequireCheck = true;
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (isRequireCheck) {
            String[] permissions = getPermissions();
            if (mChecker.lacksPermissions(permissions)) {
                requestPermissions(permissions); // 请求权限
            } else {
                allPermissionsGranted(); // 全部权限都已获取
            }
        } else {
            isRequireCheck = true;
        }
    }

    // 返回传递的权限参数
    private String[] getPermissions() {
        return getIntent().getStringArrayExtra(EXTRA_PERMISSIONS);
    }

    // 请求权限兼容低版本
    private void requestPermissions(String... permissions) {
        ActivityCompat.requestPermissions(this, permissions, PERMISSION_REQUEST_CODE);
    }

    // 全部权限均已获取
    private void allPermissionsGranted() {
        setResult(PERMISSIONS_GRANTED);
        finish();
    }

    /**
     * 用户权限处理,
     * 如果全部获取, 则直接过.
     * 如果权限缺失, 则提示Dialog.
     *
     * @param requestCode  请求码
     * @param permissions  权限
     * @param grantResults 结果
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == PERMISSION_REQUEST_CODE && hasAllPermissionsGranted(grantResults)) {
            isRequireCheck = true;
            allPermissionsGranted();
        } else {
            isRequireCheck = false;
            showMissingPermissionDialog();
        }
    }

    // 含有全部的权限
    private boolean hasAllPermissionsGranted(@NonNull int[] grantResults) {
        for (int grantResult : grantResults) {
            if (grantResult == PackageManager.PERMISSION_DENIED) {
                return false;
            }
        }
        return true;
    }

    // 显示缺失权限提示
    private void showMissingPermissionDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(PermissionsActivity.this);
        builder.setTitle("帮助");
        builder.setMessage("当前因公缺少必要权限。\n请点击\"设置\"-\"权限\"-打开所需权限。\n最后点击两次后退按钮，即可返回。");

        // 拒绝, 退出应用
        builder.setNegativeButton("退出", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                setResult(PERMISSIONS_DENIED);
                finish();
            }
        });

        builder.setPositiveButton("设置", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                startAppSettings();
            }
        });

        builder.show();
    }

    // 启动应用的设置
    private void startAppSettings() {
        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        intent.setData(Uri.parse(PACKAGE_URL_SCHEME + getPackageName()));
        startActivity(intent);
    }
}

其中R.layout.activity_permission是个空布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">

</LinearLayout>

在AndroidManifest.xm中声明权限

<uses-permission android:name="android.permission.CALL_PHONE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES"/>

在Constants.java中预加载权限语句

public static final int PERMISSION_REQUEST_CODE = 0; // 询问权限的请求码
// 所需的全部权限
public static final String[] PERMISSIONS = new String[]{
        Manifest.permission.INTERNET,
        Manifest.permission.CALL_PHONE,
        Manifest.permission.ACCESS_NETWORK_STATE,
        Manifest.permission.ACCESS_WIFI_STATE,
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE,
        Manifest.permission.CAMERA,
        Manifest.permission.KILL_BACKGROUND_PROCESSES
};

调用

在基类中声明

public PermissionsChecker permissionsChecker; // 权限检测器
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...
    permissionsChecker = new PermissionsChecker(this);
}
@Override
protected void onResume() {
    super.onResume();
    // 缺少权限时, 进入权限配置页面
    if (Build.VERSION.SDK_INT >= 23 && permissionsChecker.lacksPermissions(Constants.PERMISSIONS)) {
        startPermissionsActivity();
    }
}
public void startPermissionsActivity() {
    PermissionsActivity.startActivityForResult(this, Constants.PERMISSION_REQUEST_CODE, Constants.PERMISSIONS);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    // 拒绝时, 关闭页面, 缺少主要权限, 无法运行
    if (requestCode == Constants.PERMISSION_REQUEST_CODE && resultCode == PermissionsActivity.PERMISSIONS_DENIED) {
        finish();
    }
}

危险权限列表

权限设置界面

PermissionSettingActivity.java

/**
 * Describe:
 * 权限设置中心
 *
 * @author zhouhuan
 * @Date 2021/4/15
 */
public class PermissionSettingActivity extends BaseActivity {
    private static final int REQUEST_READ_PHONE_STATE_CODE = 101;
    private LinearLayout linearPhoneModel;
    private TextView tvPhoneModel;
    private Button btnOpenWindow;
    private Button btnOpenBattery;
    private Button btnOpenStartup;
    private Button btnOpenPowerSaving;
    private TextView tvSettingMsg1;
    private TextView tvSettingMsg2;
    private final String[] phoneModel = new String[]{"华为", "小米", "Oppo", "Vivo", "魅族", "三星", "乐视", "锤子", "一加"};
    /**
     * 对应机型提示消息 @{see phoneModel}
     */
    private final String[] settingMsg1 = new String[]{
            // 华为
            "设置方法：手机管家 -> 应用启动管理 -> 关闭自动管理当前App并打开各允许启动开关",
            // 小米
            "设置方法：安全中心 -> 权限管理 -> 自启管理 -> 打开 App 开关。",
            // Oppo
            "设置方法：手机管家 -> 权限隐私 -> 管理自启动应用 -> 允许当前 App 自启动。",
            // Vivo
            "设置方法：i管家 -> 应用管理 -> 权限管理 -> 自启动 -> 打开 App 对应开关。",
            "魅族",
            "三星",
            "乐视",
            "锤子",
            "一加"};
    private final String[] settingMsg2 = new String[]{
            // 华为
            "设置方法：手机管家 -> 电池 -> 耗电排行 -> 找到并点击当前App -> 点击应用启动管理 -> 关闭自动管理当前App并打开各允许启动开关",
            // 小米
            "设置方法：安全中心 -> 应用智能省电 -> 当前App -> 无限制。",
            // Oppo
            "设置方法：设置 -> 电池 -> 当前 App -> 取消后台冻结 和 异常自动优化。",
            // Vivo
            "设置方法：i管家 -> 电池管理 -> 后台高耗电 -> 打开 App 对应开关。",
            "魅族",
            "三星",
            "乐视",
            "锤子",
            "一加"};

    /**
     * 获取手机检测型号
     *
     * @return
     */
    private String getPhoneName() {
        if (isHuawei()) {
            return phoneModel[0];
        } else if (isXiaomi()) {
            return phoneModel[1];
        } else if (isOppo()) {
            return phoneModel[2];
        } else if (isVivo()) {
            return phoneModel[3];
        } else if (isMeizu()) {
            return phoneModel[4];
        } else if (isSamsung()) {
            return phoneModel[5];
        } else if (isLeTv()) {
            return phoneModel[6];
        } else if (isSmartisan()) {
            return phoneModel[7];
        } else if (isOnePlus()) {
            return phoneModel[8];
        } else {
            return "其他";
        }
    }

    @Override
    public String getTitleText() {
        return "权限设置";
    }

    @Override
    public int getContentId() {
        return R.layout.activity_permission_setting;
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initView();
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (checkPermission(this, Manifest.permission.READ_PHONE_STATE)) {
            initData();
        } else {
            //申请READ_PHONE_STATE权限
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.READ_PHONE_STATE},
                    REQUEST_READ_PHONE_STATE_CODE);
        }
    }

    private void initView() {
        linearPhoneModel = (LinearLayout) findViewById(R.id.linear_phone_model);
        tvPhoneModel = (TextView) findViewById(R.id.tv_phone_model);
        btnOpenWindow = (Button) findViewById(R.id.btn_open_window);
        btnOpenBattery = (Button) findViewById(R.id.btn_open_battery);
        btnOpenStartup = (Button) findViewById(R.id.btn_open_startup);
        btnOpenPowerSaving = (Button) findViewById(R.id.btn_open_power_saving);
        tvSettingMsg1 = (TextView) findViewById(R.id.tv_setting_msg_1);
        tvSettingMsg2 = (TextView) findViewById(R.id.tv_setting_msg_2);

        btnOpenWindow.setOnClickListener(this);
        btnOpenBattery.setOnClickListener(this);
        btnOpenStartup.setOnClickListener(this);
        btnOpenPowerSaving.setOnClickListener(this);
    }

    private void initData() {
        // 设置相应的引导信息
        if (isHuawei()) {
            tvSettingMsg1.setText(settingMsg1[0]);
            tvSettingMsg2.setText(settingMsg2[0]);
        } else if (isXiaomi()) {
            tvSettingMsg1.setText(settingMsg1[1]);
            tvSettingMsg2.setText(settingMsg2[1]);
        } else if (isOppo()) {
            tvSettingMsg1.setText(settingMsg1[2]);
            tvSettingMsg2.setText(settingMsg2[2]);
        } else if (isVivo()) {
            tvSettingMsg1.setText(settingMsg1[3]);
            tvSettingMsg2.setText(settingMsg2[3]);
        } else {
            // do other phone msg
        }
        // 手机型号
        tvPhoneModel.setText(getPhoneName());
        // 检测悬浮窗
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (!Settings.canDrawOverlays(this)) {
                btnOpenWindow.setText("开启悬浮窗权限");
            } else {
                btnOpenWindow.setText("已开启悬浮窗权限");
            }
        }
        // 电池优化
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            btnOpenBattery.setText(isIgnoringBatteryOptimizations() ? "电池优化已关闭" : "打开电池优化");
        } else {
            btnOpenBattery.setText("不支持电池优化");
        }
    }


    @SuppressLint("NonConstantResourceId")
    @Override
    public void onClick(View v) {
        if (!beFastClick()) {
            switch (v.getId()) {
                // 修改手机类型,暂时关闭，可以在 initView 增加监听即可使用
                case R.id.linear_phone_model:
                    new XPopup.Builder(this)
                            .asBottomList(null, phoneModel, (position, text) -> tvPhoneModel.setText(text))
                            .show();
                    break;
                // 申请打开悬浮窗
                case R.id.btn_open_window:
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        if (!Settings.canDrawOverlays(this)) {
                            requestAlertWindowPermission();
                        } else {
                            showToast("已开启悬浮窗权限");
                        }
                    }
                    break;
                // 申请电池优化
                case R.id.btn_open_battery:
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        if (!isIgnoringBatteryOptimizations()) {
                            requestIgnoreBatteryOptimizations();
                        } else {
                            showToast("电池优化已关闭");
                        }
                    }
                    break;
                // 打开应用自启管理
                case R.id.btn_open_startup:
                    if (isHuawei()) {
                        goHuaweiSetting();
                    } else if (isXiaomi()) {
                        goXiaomiSetting();
                    } else if (isOppo()) {
                        goOppoSetting();
                    } else if (isVivo()) {
                        goVivoSetting();
                    } else if (isMeizu()) {
                        goMeizuSetting();
                    } else if (isSamsung()) {
                        goSamsungSetting();
                    } else if (isLeTv()) {
                        goLetvSetting();
                    } else if (isSmartisan()) {
                        goSmartisanSetting();
                    } else if (isOnePlus()) {
                        goOnePlusSetting();
                    } else {
                        new XPopup.Builder(this)
                                .asConfirm("温馨提示", "尚不支持当前机型，请手动设置", () -> startActivity(new Intent(Settings.ACTION_APPLICATION_SETTINGS)))
                                .show();
                    }
                    break;
                // 打开智能省电中心
                case R.id.btn_open_power_saving:
                    if (isHuawei()) {
                        goHuaweiPowerSavingStrategySetting();
                    } else if (isXiaomi()) {
                        goXiaomiPowerSavingStrategySetting(true);
                    } else if (isOppo()) {
                        // 进入设置中心
                        startActivity(new Intent(Settings.ACTION_SETTINGS));
                    } else if (isVivo()) {
                        goVivoPowerSavingStrategySetting();
                    } else {
                        // other 直接进入设置中心
                        startActivity(new Intent(Settings.ACTION_APPLICATION_SETTINGS));
                    }
                    break;
                default:
                    break;
            }
        }
    }

    /**
     * 检查当前是否拥有权限
     *
     * @param context    上下文
     * @param permission 权限
     * @return true 已授予 false 未授予
     */
    private boolean checkPermission(Context context, String permission) {
        boolean result = false;
        if (Build.VERSION.SDK_INT >= 23) {
            try {
                Class<?> clazz = Class.forName("android.content.Context");
                Method method = clazz.getMethod("checkSelfPermission", String.class);
                int rest = (Integer) method.invoke(context, permission);
                result = rest == PackageManager.PERMISSION_GRANTED;
            } catch (Exception e) {
                result = false;
            }
        } else {
            PackageManager pm = context.getPackageManager();
            if (pm.checkPermission(permission, context.getPackageName()) == PackageManager.PERMISSION_GRANTED) {
                result = true;
            }
        }
        return result;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        // 请求读取文件权限结果回调
        if (requestCode == REQUEST_READ_PHONE_STATE_CODE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                initData();
            } else {
                Toast.makeText(this, "核心基础权限未通过，请允许后使用", Toast.LENGTH_SHORT).show();
            }
        }
    }

    /**
     * 请求悬浮窗权限
     * {@link Manifest.permission#SYSTEM_ALERT_WINDOW}
     */
    @RequiresApi(api = Build.VERSION_CODES.M)
    private void requestAlertWindowPermission() {
        try {
            Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION);
            intent.setData(Uri.parse("package:" + getPackageName()));
            startActivity(intent);
        } catch (Exception e) {
            Log.e(TAG, "requestAlertWindowPermission: ", e);
        }
    }

    /**
     * 判断应用是否在电池优化白名单中
     *
     * @return true 在 false 不在
     */
    @RequiresApi(api = Build.VERSION_CODES.M)
    private boolean isIgnoringBatteryOptimizations() {
        boolean isIgnoring = false;
        PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
        if (powerManager != null) {
            isIgnoring = powerManager.isIgnoringBatteryOptimizations(getPackageName());
        }
        return isIgnoring;
    }

    /**
     * 申请加入电池优化白名单
     * {@link Manifest.permission#REQUEST_IGNORE_BATTERY_OPTIMIZATIONS}
     */
    @RequiresApi(api = Build.VERSION_CODES.M)
    private void requestIgnoreBatteryOptimizations() {
        try {
            @SuppressLint("BatteryLife") Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
            intent.setData(Uri.parse("package:" + getPackageName()));
            startActivity(intent);
        } catch (Exception e) {
            Log.e(TAG, "requestIgnoreBatteryOptimizations: ", e);
            new XPopup.Builder(this)
                    .asConfirm("温馨提示", "设置失败，请手动添加应用到白名单", () -> {
                        Intent intent = new Intent(Intent.ACTION_MAIN);
                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                        intent.addCategory(Intent.CATEGORY_LAUNCHER);
                        ComponentName cn = ComponentName.unflattenFromString("com.android.settings/.Settings$HighPowerApplicationsActivity");
                        intent.setComponent(cn);
                        startActivity(intent);
                    })
                    .show();
        }
    }

    /**
     * 跳转到指定应用的首页
     */
    private void showActivity(@NonNull String packageName) {
        Intent intent = getPackageManager().getLaunchIntentForPackage(packageName);
        startActivity(intent);
    }

    /**
     * 跳转到指定应用的指定页面
     */
    private void showActivity(@NonNull String packageName, @NonNull String activityDir) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName(packageName, activityDir));
        intent.putExtra("package_name", getPackageName());
        intent.putExtra("package_label", getResources().getString(R.string.app_name));
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        //检测是否有能接受该Intent的Activity存在
        List<ResolveInfo> resolveInfos = getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
        if (resolveInfos.size() > 0) {
            startActivity(intent);
        }
    }

    /**
     * 华为
     *
     * @return
     */
    public boolean isHuawei() {
        if (Build.BRAND == null) {
            return false;
        } else {
            return "huawei".equals(Build.BRAND.toLowerCase()) || "honor".equals(Build.BRAND.toLowerCase());
        }
    }


    /**
     * 跳转华为手机管家的启动管理页
     * 操作步骤：应用启动管理 -> 关闭应用开关 -> 打开允许自启动
     */
    private void goHuaweiSetting() {
        try {
            showActivity("com.huawei.systemmanager",
                    "com.huawei.systemmanager.startupmgr.ui.StartupNormalAppListActivity");
        } catch (Exception e) {
            showActivity("com.huawei.systemmanager",
                    "com.huawei.systemmanager.optimize.bootstart.BootStartActivity");
        }
    }

    /**
     * 华为省电策略中心
     */
    private void goHuaweiPowerSavingStrategySetting() {
        showActivity("com.huawei.systemmanager",
                "com.huawei.systemmanager.power.ui.HwPowerManagerActivity");
    }

    /**
     * 小米
     *
     * @return
     */
    public static boolean isXiaomi() {
        return Build.BRAND != null && "xiaomi".equals(Build.BRAND.toLowerCase());
    }


    /**
     * 跳转小米安全中心的自启动管理页面
     * 操作步骤：授权管理 -> 自启动管理 -> 允许应用自启动。
     */
    private void goXiaomiSetting() {
        showActivity("com.miui.securitycenter",
                "com.miui.permcenter.autostart.AutoStartManagementActivity");
    }

    /**
     * 小米省电策略
     * 跳到小米应用智能省电 com.miui.powerkeeper.ui.HiddenAppsContainerManagementActivity
     * 跳到小米省电策略 com.miui.powerkeeper.ui.HiddenAppsConfigActivity
     *
     * @param isManagement 是否跳到小米智能省电控制中心 true 是 false 直接进入策略模式
     */
    private void goXiaomiPowerSavingStrategySetting(boolean isManagement) {
        if (isManagement) {
            showActivity("com.miui.powerkeeper", "com.miui.powerkeeper.ui.HiddenAppsContainerManagementActivity");
        } else {
            showActivity("com.miui.powerkeeper", "com.miui.powerkeeper.ui.HiddenAppsConfigActivity");
        }
    }

    /**
     * OPPO
     *
     * @return
     */
    public static boolean isOppo() {
        return Build.BRAND != null && "oppo".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转 OPPO 手机管家
     * 操作步骤：权限隐私 -> 自启动管理 -> 允许应用自启动。
     */
    private void goOppoSetting() {
        try {
            showActivity("com.coloros.phonemanager");
        } catch (Exception e1) {
            try {
                showActivity("com.oppo.safe");
            } catch (Exception e2) {
                try {
                    showActivity("com.coloros.oppoguardelf");
                } catch (Exception e3) {
                    showActivity("com.coloros.safecenter");
                }
            }
        }
    }

    /**
     * VIVO
     *
     * @return
     */
    public static boolean isVivo() {
        return Build.BRAND != null && "vivo".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转 VIVO 手机管家
     * 操作步骤：权限管理 -> 自启动 -> 允许应用自启动。
     */
    private void goVivoSetting() {
        showActivity("com.iqoo.secure");
    }

    /**
     * 跳转 VIVO 手机管家 电池管理
     * 设置方法：i管家 -> 电池管理 -> 后台高耗电 -> 打开 App 对应开关。
     */
    private void goVivoPowerSavingStrategySetting() {
        showActivity("com.iqoo.powersaving", "com.iqoo.powersaving.PowerSavingManagerActivity");
    }

    /**
     * 魅族
     *
     * @return
     */
    public static boolean isMeizu() {
        return Build.BRAND != null && "meizu".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转魅族手机管家
     * 操作步骤：权限管理 -> 后台管理 -> 点击应用 -> 允许后台运行。
     */
    private void goMeizuSetting() {
        showActivity("com.meizu.safe");
    }

    /**
     * 三星
     *
     * @return
     */
    public static boolean isSamsung() {
        return Build.BRAND != null && "samsung".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转三星智能管理器
     * 操作步骤：自动运行应用程序 -> 打开应用开关 -> 电池管理 -> 未监视的应用程序 -> 添加应用。
     */
    private void goSamsungSetting() {
        try {
            showActivity("com.samsung.android.sm_cn");
        } catch (Exception e) {
            showActivity("com.samsung.android.sm");
        }
    }

    /**
     * 乐视
     *
     * @return
     */
    public static boolean isLeTv() {
        return Build.BRAND != null && "letv".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转乐视手机管家
     * 操作步骤：自启动管理 -> 允许应用自启动
     */
    private void goLetvSetting() {
        showActivity("com.letv.android.letvsafe",
                "com.letv.android.letvsafe.AutobootManageActivity");
    }

    /**
     * 锤子
     *
     * @return
     */
    public static boolean isSmartisan() {
        return Build.BRAND != null && "smartisan".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转手机管理
     * 操作步骤：权限管理 -> 自启动权限管理 -> 点击应用 -> 允许被系统启动。
     */
    private void goSmartisanSetting() {
        showActivity("com.smartisanos.security");
    }

    /**
     * 一加
     *
     * @return
     */
    public static boolean isOnePlus() {
        return Build.BRAND != null && "oneplus".equals(Build.BRAND.toLowerCase());
    }

    /**
     * 跳转手机管理
     * 操作步骤：权限管理 -> 自启动权限管理 -> 点击应用 -> 允许被系统启动。
     */
    private void goOnePlusSetting() {
        showActivity("com.oneplus.security",
                "com.oneplus.security.chainlaunch.view.ChainLaunchAppListActivity");
    }

}

activity_permission_setting.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <include layout="@layout/common_title" />

    <LinearLayout
        android:id="@+id/linear_phone_model"
        android:layout_width="match_parent"
        android:layout_height="45dp"
        android:layout_marginTop="1dp"
        android:background="@drawable/drawable_color_white_selected"
        android:gravity="center_vertical"
        android:orientation="horizontal"
        android:paddingLeft="15dp">

        <TextView
            android:id="@+id/tv_phone_model"
            android:layout_width="0dp"
            android:layout_height="45dp"
            android:layout_weight="1"
            android:background="@drawable/drawable_color_white_selected"
            android:gravity="center_vertical"
            android:text="手机型号"
            android:textSize="16sp" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="45dp"
            android:layout_marginRight="5dp"
            android:background="@drawable/drawable_color_white_selected"
            android:gravity="center_vertical"
            android:text="手机识别有误？点击修改"
            android:textSize="12sp"
            android:visibility="gone" />

        <ImageView
            android:layout_width="10dp"
            android:layout_height="20dp"
            android:layout_marginRight="15dp"
            app:srcCompat="@drawable/tree_ec" />
    </LinearLayout>


    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:padding="10dp">


            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginTop="5dp"
                android:text="Android 由于省电设置与后台进程限制，可能会将正在后台运行的 App 关闭或者导致部分数据丢失。如果您遇到了相关问题，可参考如下方法设置。"
                android:textSize="13sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginTop="10dp"
                android:text="在其他应用上层显示（悬浮窗）设置"
                android:textColor="@color/black"
                android:textSize="13sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="为保证您在使用过程中不被手机系统误杀，导致数据丢失，请授予 App 悬浮窗权限"
                android:textSize="12sp" />

            <Button
                android:id="@+id/btn_open_window"
                android:layout_width="match_parent"
                android:layout_height="40dp"
                android:layout_marginStart="50dp"
                android:layout_marginTop="10dp"
                android:layout_marginEnd="50dp"
                android:background="@drawable/bg_btn_onclick_radius"
                android:enabled="true"
                android:text="开启悬浮窗权限"
                android:textColor="@color/white"
                android:textSize="14sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginTop="5dp"
                android:text="电池优化"
                android:textColor="@color/black"
                android:textSize="13sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="在省点模式下，App 的运行仍然可能受限。使用当前软件时应尽量使得电量处于相对充足的状态，并且关闭省电模式。相关设置入口一般在状态栏或者电池相关设置。"
                android:textSize="12sp" />

            <Button
                android:id="@+id/btn_open_battery"
                android:layout_width="match_parent"
                android:layout_height="40dp"
                android:layout_marginStart="50dp"
                android:layout_marginTop="10dp"
                android:layout_marginEnd="50dp"
                android:background="@drawable/bg_btn_onclick_radius"
                android:enabled="true"
                android:text="打开电池优化 | 电池优化已关闭"
                android:textColor="@color/white"
                android:textSize="14sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginTop="5dp"
                android:text="后台保护设置"
                android:textColor="@color/black"
                android:textSize="13sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="将 App 加入后台保护名单，可以在一定程度上面帮助 App 在后台持续运行。"
                android:textSize="12sp" />

            <TextView
                android:id="@+id/tv_setting_msg_1"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="设置方法：安全中心 -> 权限管理 -> 自启管理 -> 打开 App 开关。"
                android:textSize="12sp" />

            <Button
                android:id="@+id/btn_open_startup"
                android:layout_width="match_parent"
                android:layout_height="40dp"
                android:layout_marginStart="50dp"
                android:layout_marginTop="10dp"
                android:layout_marginEnd="50dp"
                android:background="@drawable/bg_btn_onclick_radius"
                android:enabled="true"
                android:text="打开后台保持系统设置"
                android:textColor="@color/white"
                android:textSize="14sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginTop="5dp"
                android:text="省电模式"
                android:textColor="@color/black"
                android:textSize="13sp" />

            <TextView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="由于系统的省电设置，会让 App 进入冻结状态。为保证后台活动不受影响，请将 App 加入电池优化白名单中。（部分机器需手动开启）"
                android:textSize="12sp" />

            <TextView
                android:id="@+id/tv_setting_msg_2"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="设置方法：安全中心 -> 应用智能省电 -> 当前App -> 无限制。"
                android:textSize="12sp" />

            <Button
                android:id="@+id/btn_open_power_saving"
                android:layout_width="match_parent"
                android:layout_height="40dp"
                android:layout_marginStart="50dp"
                android:layout_marginTop="10dp"
                android:layout_marginEnd="50dp"
                android:background="@drawable/bg_btn_onclick_radius"
                android:enabled="true"
                android:text="打开防睡眠系统设置"
                android:textColor="@color/white"
                android:textSize="14sp" />

        </LinearLayout>

    </ScrollView>
</LinearLayout>