2026年03月19日15:27:21 蓝牙开发中

wjc

2026-03-19 b2340ac4ce1c9ea2070c0e7fb72a03fb2b2500ad

 app/src/main/java/com/hdl/photovoltaic/utils/PermissionUtils.java

@@ -1,19 +1,28 @@
package com.hdl.photovoltaic.utils;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.AppOpsManager;
import android.app.Application;
import android.app.NotificationManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.provider.Settings;

import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import com.hdl.photovoltaic.R;
import com.hdl.photovoltaic.other.HdlThreadLogic;
import com.hdl.photovoltaic.HDLApp;
import com.hdl.photovoltaic.other.HdlDialogLogic;
import com.hjq.permissions.OnPermissionCallback;
import com.hjq.permissions.XXPermissions;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

@@ -42,7 +51,7 @@
     * @param activity -
     * @param strings  -
     */
    public static void askPermission(Activity activity, String[] strings) {
    public static void activityPermission(Activity activity, String[] strings) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            List<String> newList = new ArrayList<>();
            for (String permission : strings) {
@@ -70,10 +79,22 @@
    }

    /**
     * 检查一个权限
     *
     * @param context    -
     * @param permission -
     * @return -
     */
    public static boolean checkPermission(Context context, String permission) {
        //first we need check this Drive has? CAMERA Permission
        return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED;
    }

    /**
     * 检查多个权限
     *
     * @param activity -
     * @param strings  -
     * @param strings  -权限的数据
     * @return -
     */
    public static String[] checkPermission(Activity activity, String[] strings) {
@@ -93,9 +114,17 @@
    /**
     * 获取权限状态
     */
    public static int getAuthorizeStaus(Activity activity, String authorize) {
    public static int getPermissionState(Activity activity, String authorize) {
        int flag = ActivityCompat.checkSelfPermission(activity, authorize);
        Boolean isShould = ActivityCompat.shouldShowRequestPermissionRationale(activity, authorize);
        //此时需要判断是否是"永久拒绝"
        //当前isShould =false；
        // 永久拒绝（用户勾选了"不再询问"）
        // 或者是在某些特殊场景下（如设备策略限制）
        // 这种情况再次 requestPermissions() 也不会弹窗，必须引导用户去设置页面手动开启
        //当前isShould =true；
        // 普通拒绝（用户只是点了拒绝，没有勾选"不再询问"）
        // 这种情况再次 requestPermissions() 还会弹窗
        boolean isShould = ActivityCompat.shouldShowRequestPermissionRationale(activity, authorize);
        if (isShould) {
            return STATUS_REFUSE;
        }
@@ -110,15 +139,53 @@
    }

    /**
     * 获取权限状态( 权限检查结果对比)
     *
     * @param activity  活动
     * @param authorize 权限名称
     * @return （0=授予权限；1=普通拒绝（用户只是点了拒绝，没有勾选"不再询问"）；2=永久拒绝（用户勾选了"不再询问"）；3=首次申请）
     */
    public static int getPermissionStateV2(Activity activity, String authorize) {
        int flag = ActivityCompat.checkSelfPermission(activity, authorize);
        // 情况 1: 用户授予权限
        if (flag == PackageManager.PERMISSION_GRANTED) {
            //获取到权限
            return STATUS_SUCCESS;
        }
        if (!SharedPreUtils.contains(authorize)) {
            SharedPreUtils.putBoolean(authorize, true);
            //首次申请
            return STATUS_DEFAULT;
        }
        // 情况 2: 用户拒绝权限（包括首次拒绝、永久拒绝）
        if (flag == PackageManager.PERMISSION_DENIED) {
            boolean isShould = ActivityCompat.shouldShowRequestPermissionRationale(activity, authorize);
            if (isShould) {
                // 普通拒绝（用户只是点了拒绝，没有勾选"不再询问"）
                // 这种情况再次 requestPermissions() 还会弹窗
                return STATUS_REFUSE;
            } else {
                // 永久拒绝（用户勾选了"不再询问"）；【注意：有些手机没有“不再询问”选项，点击两次以上拒绝，就会变成永久拒绝】
                // 或者是在某些特殊场景下（如设备策略限制）
                // 这种情况再次 requestPermissions() 也不会弹窗，必须引导用户去设置页面手动开启
                return STATUS_REFUSE_PERMANENT;
            }
        }
        return STATUS_REFUSE;
    }


    /**
     * 申请权限有回调
     *
     * @param activity                -
     * @param permission              -
     * @param permissionStateCallback -
     * @param is_skip                 拒绝权限后是否引导到设置那里打开(true=引导)
     */
    public static void applyForRight(Activity activity, String permission, PermissionState permissionStateCallback) {
    public static void requestPermissionsResultCallback(Activity activity, String permission, PermissionState permissionStateCallback, boolean is_skip) {
//        String permission = Manifest.permission.WRITE_EXTERNAL_STORAGE;
        int status = PermissionUtils.getAuthorizeStaus(activity, permission);
        int status = PermissionUtils.getPermissionState(activity, permission);
        switch (status) {
            case PermissionUtils.STATUS_SUCCESS:
                if (permissionStateCallback != null) {
@@ -127,28 +194,36 @@
                break;
            case PermissionUtils.STATUS_REFUSE:
            case PermissionUtils.STATUS_DEFAULT:
                XXPermissions.with(activity)
                        .permission(permission)
                        .request(new OnPermissionCallback() {
                            @Override
                            public void onGranted(List<String> permissions, boolean all) {
                                SharedPreUtils.putBoolean(permission, true);
                                if (permissionStateCallback != null) {
                                    permissionStateCallback.Success(STATUS_REFUSE);
                                }
                            }
                XXPermissions.with(activity).permission(permission).request(new OnPermissionCallback() {
                    @Override
                    public void onGranted(List<String> permissions, boolean all) {
                        SharedPreUtils.putBoolean(permission, true);
                        if (permissionStateCallback != null) {
                            permissionStateCallback.Success(STATUS_SUCCESS);
                        }
                    }

                            @Override
                            public void onDenied(List<String> permissions, boolean never) {
                                SharedPreUtils.putBoolean(permission, true);
                            }
                        });
                    @Override
                    public void onDenied(List<String> permissions, boolean never) {
                        if (permissionStateCallback != null) {
                            permissionStateCallback.Success(STATUS_REFUSE);
                        }
                        if (is_skip) {
                            SharedPreUtils.putBoolean(permission, true);
                        }
                    }
                });
                break;
            case PermissionUtils.STATUS_REFUSE_PERMANENT:
//                if (permissionStateCallback != null) {
//                    permissionStateCallback.Success(STATUS_REFUSE_PERMANENT);
//                }
                if (permissionStateCallback != null) {
                    permissionStateCallback.Success(STATUS_REFUSE_PERMANENT);
                }

                if (is_skip) {
                    HdlDialogLogic.getInstance().showSettingPermissionDialog(activity);
                }
                break;
        }
    }
@@ -159,4 +234,60 @@
    }


    // 检查通知权限状态
    public static boolean isNotificationEnabled(Context mContext) {
        if (mContext == null) {
            return false;
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Android 8.0 及以上版本
            NotificationManager notificationManager =
                    (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
            return notificationManager.areNotificationsEnabled();
        } else {
            // Android 7.1 及以下版本
            AppOpsManager appOps = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
            ApplicationInfo appInfo = mContext.getApplicationInfo();
            String packageName = mContext.getApplicationContext().getPackageName();
            int uid = appInfo.uid;
            try {
                Class<?> appOpsClass = Class.forName(AppOpsManager.class.getName());
                Method checkOpNoThrowMethod = appOpsClass.getMethod("checkOpNoThrow", Integer.TYPE,
                        Integer.TYPE, String.class);
                Field opPostNotificationValue = appOpsClass.getDeclaredField("OP_POST_NOTIFICATION");
                int value = (int) opPostNotificationValue.get(Integer.class);
                return ((int) checkOpNoThrowMethod.invoke(appOps, value, uid, packageName)
                        == AppOpsManager.MODE_ALLOWED);
            } catch (Exception e) {
                e.printStackTrace();
                return true;
            }
        }
    }

    // 打开通知权限设置页面
    public static void openNotificationSettings(Context mContext) {
        if (mContext == null) {
            return;
        }
        Intent intent = new Intent();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Android 8.0 及以上版本
            intent.setAction(Settings.ACTION_APP_NOTIFICATION_SETTINGS);
            intent.putExtra(Settings.EXTRA_APP_PACKAGE, mContext.getPackageName());
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            // Android 5.0 及以上版本
            intent.setAction("android.settings.APP_NOTIFICATION_SETTINGS");
            intent.putExtra("app_package", mContext.getPackageName());
            intent.putExtra("app_uid", mContext.getApplicationInfo().uid);
        } else {
            // Android 5.0 以下版本
            intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
            intent.addCategory(Intent.CATEGORY_DEFAULT);
            intent.setData(Uri.parse("package:" + mContext.getPackageName()));
        }
        mContext.startActivity(intent);
    }


}