wjc
2025-05-23 8e8ea8be5c20c37a5619691701aa5f3bf814b941
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
package com.hdl.photovoltaic.utils;
 
import android.app.Activity;
import android.app.AppOpsManager;
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.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;
 
 
public class PermissionUtils {
    /**
     * 获取权限成功
     */
    public static final int STATUS_SUCCESS = 0;
    /**
     * 申请权限拒绝, 但是下次申请权限还会弹窗
     */
    public static final int STATUS_REFUSE = 1;
    /**
     * 申请权限拒绝,并且是永久,不会再弹窗
     */
    public static final int STATUS_REFUSE_PERMANENT = 2;
    /**
     * 默认未请求授权状态
     */
    public static final int STATUS_DEFAULT = 3;
 
    /**
     * 只有activity才可以申请
     *
     * @param activity -
     * @param 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) {
                boolean flag = checkPermission(activity, permission);
                if (!flag) {
                    newList.add(permission);
                }
            }
            if (newList.size() > 0) {
                ActivityCompat.requestPermissions(activity, newList.toArray(new String[0]), STATUS_SUCCESS);
            }
        }
    }
 
    /**
     * 检查一个权限
     *
     * @param activity   -
     * @param permission -
     * @return -
     */
    public static boolean checkPermission(Activity activity, String permission) {
        //first we need check this Drive has? CAMERA Permission
        return ContextCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED;
    }
 
    /**
     * 检查一个权限
     *
     * @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  -权限的数据
     * @return -
     */
    public static String[] checkPermission(Activity activity, String[] strings) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            List<String> newList = new ArrayList<>();
            for (String permission : strings) {
                boolean flag = checkPermission(activity, permission);
                if (!flag) {
                    newList.add(permission);
                }
            }
            return newList.toArray(new String[0]);
        }
        return new String[]{};
    }
 
    /**
     * 获取权限状态
     */
    public static int getPermissionState(Activity activity, String authorize) {
        int flag = ActivityCompat.checkSelfPermission(activity, authorize);
        boolean isShould = ActivityCompat.shouldShowRequestPermissionRationale(activity, authorize);
        if (isShould) {
            return STATUS_REFUSE;
        }
        if (flag == PackageManager.PERMISSION_GRANTED) {
            //获取到权限
            return STATUS_SUCCESS;
        }
        if (!SharedPreUtils.contains(authorize)) {
            return STATUS_DEFAULT;
        }
        return STATUS_REFUSE_PERMANENT;
    }
 
 
    /**
     * 申请权限有回调
     *
     * @param activity                -
     * @param permission              -
     * @param permissionStateCallback -
     * @param is_skip                 拒绝权限后是否引导到设置那里打开(true=引导)
     */
    public static void requestPermissionsResultCallback(Activity activity, String permission, PermissionState permissionStateCallback, boolean is_skip) {
//        String permission = Manifest.permission.WRITE_EXTERNAL_STORAGE;
        int status = PermissionUtils.getPermissionState(activity, permission);
        switch (status) {
            case PermissionUtils.STATUS_SUCCESS:
                if (permissionStateCallback != null) {
                    permissionStateCallback.Success(STATUS_SUCCESS);
                }
                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_SUCCESS);
                        }
                    }
 
                    @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;
        }
    }
 
    public interface PermissionState {
        void Success(int value);
 
    }
 
 
    // 检查通知权限状态
    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);
    }
 
 
}