Android6.0权限系统

最新推荐文章于 2024-08-15 11:22:27 发布
置顶 最新推荐文章于 2024-08-15 11:22:27 发布
阅读量5k 收藏 1
点赞数 1
分类专栏： Android 文章标签： android perimissio Android6-0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Charon_Chui/article/details/51684240
版权

Android6.0权限系统

Android权限系统是一个非常重要的安全问题，因为它只有在安装时会询问一次。一旦软件本安装之后，应用程序可以在用户毫不知情的情况下使用这些权限来获取所有的内容。

很多坏蛋会通过这个安全缺陷来收集用户的个人信息并使用它们来做坏事的情况就不足为奇了。

Android团队也意识到了这个问题。在经过了7年后，权限系统终于被重新设置了。从Anroid 6.0(API Level 23)开始，应用程序在安装时不会被授予任何权限，取而代之的是在运行时应用回去请求用户授予对应的权限。这样可以让用户能更好的去控制应用功能。例如，一个用户可能会同一个拍照应用使用摄像头的权限，但是不同授权它获取设备位置的权限。用户可以在任何时候通过去应用的设置页面来撤销授权。

image

注意:上面请求权限的对话框不会自动弹出。开发者需要手动的调用。如果开发者调用了一些需要权限的功能，但是用户又拒绝授权的话，应用就会crash。

系统权限被分为两类，normal和dangerous:

  • Normal Permissions不需要用户直接授权，如果你的应用在清单文件中声明了Normal Permissions`，系统会自动授权该权限。
  • Dangerous Permissions可以让应用获取用户的私人数据。如果你的应用在清单文件中申请了Dangerous Permissions，那就必须要用户来授权给应用。

Normal Permissions:
Normal Permission是当用户安装或更新应用时，系统将授予应用所请求的权限，又称为PROTECTION_NORMAL（安装时授权的一类基本权限）。该类权限只需要在manifest文件中声明即可，安装时就授权，不需要每次使用时进行检查，而且用户不能取消以上授权。

  • ACCESS_LOCATION_EXTRA_COMMANDS
  • ACCESS_NETWORK_STATE
  • ACCESS_NOTIFICATION_POLICY
  • ACCESS_WIFI_STATE
  • BLUETOOTH
  • BLUETOOTH_ADMIN
  • BROADCAST_STICKY
  • CHANGE_NETWORK_STATE
  • CHANGE_WIFI_MULTICAST_STATE
  • CHANGE_WIFI_STATE
  • DISABLE_KEYGUARD
  • EXPAND_STATUS_BAR
  • GET_PACKAGE_SIZE
  • INSTALL_SHORTCUT
  • INTERNET
  • KILL_BACKGROUND_PROCESSES
  • MODIFY_AUDIO_SETTINGS
  • NFC
  • READ_SYNC_SETTINGS
  • READ_SYNC_STATS
  • RECEIVE_BOOT_COMPLETED
  • REORDER_TASKS
  • REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
  • REQUEST_INSTALL_PACKAGES
  • SET_ALARM
  • SET_TIME_ZONE
  • SET_WALLPAPER
  • SET_WALLPAPER_HINTS
  • TRANSMIT_IR
  • UNINSTALL_SHORTCUT
  • USE_FINGERPRINT
  • VIBRATE
  • WAKE_LOCK
  • WRITE_SYNC_SETTINGS

下图为Dangerous permissions and permission groups:

image

在所有的Android版本中，你的应用都需要在manifest文件中声明normal和dangerous权限。然而声明所影响的效果会因系统版本和你应用的target SDK lever有关:

  • 如果设备运行的是Android 5.1或者之前的系统，或者应用的targetSdkVersion是22或者之前版本：如果你在manifest中声明了dangerous permission，用户需要在安装应用时授权这些权限。如果用户不授权这些权限，系统就不会安装该应用。(我试了下发现即使targetSdkVersion是22及以下，在6.0的手机上时，如果你安装时你不同意一些权限，也仍然可以安装的)
  • 如果设备运行的是Android 6.0或者更高的系统，并且你应用的targetSdkVersion是23或者更高:应用必须在manifest文件中申请这些权限，而且必须要在运行时对所需要的dangerous permission申请授权。用户可以统一或者拒绝授权，并且及时用户拒绝了授权，应用在无法使用一些功能的情况下也要保证能继续运行。

也就是说新的运行时权限仅当我们设置targetSdkVersion是23及以上时才会起作用。
如果你的targtSdkVersion低于23，那将被认为该应用没有经过android 6.0的测试，当该应用被安装到了6.0的手机上时，仍然会使用之前的旧权限规则，在安装时会提示所有需要的权限(这样做是有道理的，不然对于之前开发的应用，我们都要立马去修改让它适应6.0，来不及的话就导致6.0的手机都无法使用了，显然Android开发团队不会考虑不到这种情况)，当然用户可以在安装的界面不允许一些权限，那当程序使用到了这些权限时，会崩溃吗？答案是在Android 6.0及以上的手机会直接crash，但是在23之前的手机上不会crash。

所以如果你的应用没有支持运行时权限的功能，那千万不要讲targetSdkVersion设置为23，否则就麻烦了。

注意:从Android 6.0(API Level 23)开始，即使应用的targetSdkVersion是比较低的版本，但是用户仍然可以在任何时候撤销对应用的授权。所以不管应用的targetSdkVerison是什么版本，你都要测试你的应用在不能获取权限时能不能正常运行。

下面介绍下如何使用Android Support Library来检查和请求权限。Android框架在6.0开始也提供了相同的方法。然而使用support包会比较简单，因为这样你就不需要在请求方法时判断当前的系统版本。(后面说的这几个类都是android.support.v4中的)

检查权限

如果应用需要使用dangerous permission，在任何时候执行需要该权限的操作时你都需要检查是否已经授权。用户可能会经常取消授权，所以即使昨天应用已经使用了摄像头，这也不能保证今天仍然有使用摄像头的权限。

为了检查是否可以使用该权限，调用ContextCompat.checkSelfPermission()。
例如: 

// Assume thisActivity is the current activity
int permissionCheck = ContextCompat.checkSelfPermission(thisActivity,
        Manifest.permission.WRITE_CALENDAR);

如果应用有该权限，该方法将返回PackageManager.PERMISSION_GRANTED，应用可以进行相关的操作。如果应用不能使用该权限，该方法将返回PERMISSION_DENIED，这是应用将必须要向用户申请该权限。

申请使用权限

如果应用需要使用清单文件中申明的dangerous permission，它必须要向用户申请来授权。Android提供了几种申请授权的方法。使用这些方法时将会弹出一个标准的系统对话框，该对话框不能自定义。

说明为什么应用需要使用这些权限

在一些情况下，你可能需要帮助用力理解为什么需要该权限。例如，一个用户使用了一个照相的应用，用户不会奇怪为什么应用申请使用摄像头的权限，但是用户可能会不理解为什么应用需要获取位置或者联系人的权限。在请求一个权限之前，你需要该用户一个说明。一定要切记不要通过说明来压倒用户。如果你提供了太多的说明，用户可能会感觉沮丧并且会卸载它。

一个你需要提供说明的合适时机就是在用户之前已经不同意授权该权限的情况下。如果一个用户继续尝试使用需要权限的功能时，但是之前确禁止了该权限的请求，这就可能是因为用户不理解为什么该功能需要使用该权限。在这种情况下，提供一个说明是非常合适的。

为了能找到用户可能需要说明的情况，android提供了一个工具类方法ActivityCompat.shouldShowRequestPermissionRationale().。如果应用之前申请了该权限但是用户拒绝授权后该方法会返回true。(在Android 6.0之前调用的时候会直接返回false)

注意：如果用户之前拒绝了权限申请并且选择了请求权限对话框中的Don’t ask again选项，该方法就会返回false。如果设备策略禁止了该应用使用该权限，该方法也会返回false。(我测试的时候发现请求权限的对话框中并没有Don’t asdk again这一项)
image

申请需要的权限

如果应用没有所需的权限时，应用必须调用ActivityCompat.requestPermissions (Activity activity,
String[] permissions,
int requestCode)方法来申请对用的权限。参数传递对应所需的权限以及一个整数型的request code来标记该权限申请。 该方法是异步的:该方法会立即返回，在用户响应了请求权限的对话框之后，系统会调用对用的回调方法来通知结果，并且会传递在reqeustPermissions()方法中的request code。(在Android 6.0之前调用的时候会直接去调用onRequestPermissionsResult()的回调方法)
如图:
image

下面是检查是否读取联系人权限，并且在必要时申请权限的代码: 

// Here, thisActivity is the current activity
if (ContextCompat.checkSelfPermission(thisActivity,
                Manifest.permission.READ_CONTACTS)
        != PackageManager.PERMISSION_GRANTED) {

    // Should we show an explanation?
    if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
            Manifest.permission.READ_CONTACTS)) {

        // Show an expanation to the user *asynchronously* -- don't block
        // this thread waiting for the user's response! After the user
        // sees the explanation, try again to request the permission.

    } else {

        // No explanation needed, we can request the permission.

        ActivityCompat.requestPermissions(thisActivity,
                new String[]{Manifest.permission.READ_CONTACTS},
                MY_PERMISSIONS_REQUEST_READ_CONTACTS);

        // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
        // app-defined int constant. The callback method gets the
        // result of the request.
    }
}

注意：当调用requestPermissions()方法时，系统会显示一个标准的对话框。应用不能指定或者改变该对话框。如果你想提供一些信息或者说明给用户，你需要在调用requestPermissions()之前处理。

处理请求权限的的结果

如果应用申请权限，系统会显示一个对话框。当用户相应后，系统会调用应用中的onRequestPermissionsResult (int requestCode,
String[] permissions,
int[] grantResults)方法并传递用户的操作结果。在应用中必须要重写该方法来查找授权了什么权限。该回调方法会传递你在requestPermisssions()方法中传递的request code。直接在Activity或者Fragment中重写onRequestPermissionsResult()方法即可。例如，申请READ_CONTACTS的权限可能会有下面的回到方法: 

@Override
public void onRequestPermissionsResult(int requestCode,
        String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_READ_CONTACTS: {
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                // permission was granted, yay! Do the
                // contacts-related task you need to do.

            } else {

                // permission denied, boo! Disable the
                // functionality that depends on this permission.
            }
            return;
        }

        // other 'case' lines to check for other
        // permissions this app might request
    }
}

系统提示的对话框会描述应用所需的permission groud。它不会列出特定的权限。例如，如果你申请了READ_CONTACTS权限，系统的对话框只会说你的应用需要获取设备的联系人信息。用户只需要授权每个permission group一次。如果你应用需要申请其他任何一个在该permission group中的权限时，系统会自动授权。在申请这些授权时，系统会像用户明确通过系统对话框统一授权时一样去调用onRequestPermissionsResult()方法并且传递PERMISSION_GRANTED参数。

注意：虽然用户已经授权了同一permission group中其他的任何权限，但是应用仍然需要明确申请每个需要的权限。例外，permission group中的权限在以后可能会发生变化。

例如，假设在应用的manifest文件中同时声明了READ_CONTACTS和WRITE_CONTACTS权限。如果你申请READ_CONTACTS权限而且用户同意了该权限，如果你想继续申请WRITE_CONTACTS权限，系统不会与用户有任何交互就会直接进行授权。

如果用户拒绝了一个权限申请，你的应用进行合适的处理。例如，你的应用可能显示一个对话框来表明无法执行用户请求的需要该权限的操作。

如果系统向用户申请权限授权，用户选择了让系统以后不要再申请该权限。 在这种情况下，应用在任何时间调用reqeustPermissions()方法来再次申请权限时，系统都会直接拒绝该请求。系统会直接调用onRequestPermissionResult()回调方法并且传递PERMISSION_DENIED参数，和用户明确拒绝应用申请该权限时一样。 这就意味着在你调用requestPermissions()方法是，你无法确定是否会和用户有直接的交互操作。

示例代码: 


final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;

private void insertDummyContactWrapper() {
    List<String> permissionsNeeded = new ArrayList<String>();

    final List<String> permissionsList = new ArrayList<String>();
    if (!addPermission(permissionsList, Manifest.permission.ACCESS_FINE_LOCATION))
        permissionsNeeded.add("GPS");
    if (!addPermission(permissionsList, Manifest.permission.READ_CONTACTS))
        permissionsNeeded.add("Read Contacts");
    if (!addPermission(permissionsList, Manifest.permission.WRITE_CONTACTS))
        permissionsNeeded.add("Write Contacts");

    if (permissionsList.size() > 0) {
        if (permissionsNeeded.size() > 0) {
            // Need Rationale
            String message = "You need to grant access to " + permissionsNeeded.get(0);
            for (int i = 1; i < permissionsNeeded.size(); i++)
                message = message + ", " + permissionsNeeded.get(i);
            showMessageOKCancel(message,
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                                    REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
                        }
                    });
            return;
        }
        requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
        return;
    }

    insertDummyContact();
}

private boolean addPermission(List<String> permissionsList, String permission) {
    if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
        permissionsList.add(permission);
        // Check for Rationale Option
        if (!shouldShowRequestPermissionRationale(permission))
            return false;
    }
    return true;
}

上面讲到的都是Activity中的使用方法，那Fragment中怎么授权呢？
如果在Fragment中使用，用v13包中的FragmentCompat.requestPermissions()和FragmentCompat.shouldShowRequestPermissionRationale()。

在Fragment中申请权限，不要使用ActivityCompat.requestPermissions, 直接使用Fragment.requestPermissions方法，
否则会回调到Activity的onRequestPermissionsResult。但是虽然你使用Fragment.requestPermissions方法，也照样回调不到Fragment.onRequestPermissionsResult中。这是Android的Bug,详见，Google已经在23.3.0修复了该问题，所以要尽快升级。

所以升级到23.3.0及以上就没问题了。如果不升级该怎么处理呢？就是在Activity.onRequestPermissionsResult方法中去手动调用每个Fragment的方法(当然你要判断下权限个数，不然申请一个权限的情况下会重复调用). 

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    List<Fragment> fragments = getSupportFragmentManager().getFragments();
    if (fragments != null) {
        for (Fragment fragment : fragments) {
            fragment.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }
}

我简单的写了一个工具类: 

public class PermissionUtil {
    /**
     * 在调用需要权限的功能时使用该方法进行检查。
     *
     * @param activity
     * @param requestCode
     * @param iPermission
     * @param permissions
     */
    public static void checkPermissions(Activity activity, int requestCode, IPermission iPermission, String... permissions) {
        handleRequestPermissions(activity, requestCode, iPermission, permissions);
    }

    public static void checkPermissions(Fragment fragment, int requestCode, IPermission iPermission, String... permissions) {
        handleRequestPermissions(fragment, requestCode, iPermission, permissions);
    }

    public static void checkPermissions(android.app.Fragment fragment, int requestCode, IPermission iPermission, String... permissions) {
        handleRequestPermissions(fragment, requestCode, iPermission, permissions);
    }

    /**
     * 在Actvitiy或者Fragment中重写onRequestPermissionsResult方法后调用该方法。
     *
     * @param activity
     * @param requestCode
     * @param permissions
     * @param grantResults
     * @param iPermission
     */
    public static void onRequestPermissionsResult(Activity activity, int requestCode, String[] permissions,
                                                  int[] grantResults, IPermission iPermission) {
        requestResult(activity, requestCode, permissions, grantResults, iPermission);

    }

    public static void onRequestPermissionsResult(Fragment fragment, int requestCode, String[] permissions,
                                                  int[] grantResults, IPermission iPermission) {
        requestResult(fragment, requestCode, permissions, grantResults, iPermission);
    }

    public static void onRequestPermissionsResult(android.app.Fragment fragment, int requestCode, String[] permissions,
                                                  int[] grantResults, IPermission iPermission) {
        requestResult(fragment, requestCode, permissions, grantResults, iPermission);
    }

    public static <T> void requestPermission(T t, int requestCode, String... permission) {
        List<String> permissions = new ArrayList<>();
        for (String s : permission) {
            permissions.add(s);
        }
        requestPermissions(t, requestCode, permissions);
    }

    /**
     * 在检查权限后自己处理权限说明的逻辑后调用该方法，直接申请权限。
     *
     * @param t
     * @param requestCode
     * @param permissions
     * @param <T>
     */
    public static <T> void requestPermission(T t, int requestCode, List<String> permissions) {
        if (permissions == null || permissions.size() == 0) {
            return;
        }
        requestPermissions(t, requestCode, permissions);
    }

    public static boolean checkSelfPermission(Context context, String permission) {
        if (context == null || TextUtils.isEmpty(permission)) {
            throw new IllegalArgumentException("invalidate params: the params is null !");
        }

        context = context.getApplicationContext();

        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            int result = ContextCompat.checkSelfPermission(context, permission);
            if (PackageManager.PERMISSION_DENIED == result) {
                return false;
            }
        }

        return true;
    }

    private static <T> void handleRequestPermissions(T t, int requestCode, IPermission iPermission, String... permissions) {
        if (t == null || permissions == null || permissions.length == 0) {
            throw new IllegalArgumentException("invalidate params");
        }
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            Activity activity = getActivity(t);
            List<String> deniedPermissions = getDeniedPermissions(activity, permissions);
            if (deniedPermissions != null && deniedPermissions.size() > 0) {

                List<String> rationalPermissions = new ArrayList<>();
                for (String deniedPermission : deniedPermissions) {
                    if (ActivityCompat.shouldShowRequestPermissionRationale(activity,
                            deniedPermission)) {
                        rationalPermissions.add(deniedPermission);
                    }
                }

                boolean showRational = false;
                if (iPermission != null) {
                    showRational = iPermission.showRational(requestCode);
                }

                if (rationalPermissions.size() > 0 && showRational) {
                    if (iPermission != null) {
                        iPermission.onRational(requestCode, deniedPermissions);
                    }
                } else {
                    requestPermissions(t, requestCode, deniedPermissions);
                }
            } else {
                if (iPermission != null) {
                    iPermission.onGranted(requestCode);
                }
            }
        } else {
            if (iPermission != null) {
                iPermission.onGranted(requestCode);
            }
        }
    }

    @Nullable
    private static <T> Activity getActivity(T t) {
        Activity activity = null;
        if (t instanceof Activity) {
            activity = (Activity) t;
        } else if (t instanceof Fragment) {
            activity = ((Fragment) t).getActivity();
        } else if (t instanceof android.app.Fragment) {
            activity = ((android.app.Fragment) t).getActivity();
        }
        return activity;
    }

    @TargetApi(Build.VERSION_CODES.M)
    private static <T> void requestPermissions(T t, int requestCode, List<String> deniedPermissions) {
        if (deniedPermissions == null || deniedPermissions.size() == 0) {
            return;
        }
        // has denied permissions
        if (t instanceof Activity) {
            ((Activity) t).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
        } else if (t instanceof Fragment) {
            ((Fragment) t).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
        } else if (t instanceof android.app.Fragment) {
            ((android.app.Fragment) t).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
        }
    }

    private static List<String> getDeniedPermissions(Context context, String... permissions) {
        if (context == null || permissions == null || permissions.length == 0) {
            return null;
        }
        List<String> denyPermissions = new ArrayList<>();
        for (String permission : permissions) {
            if (!checkSelfPermission(context, permission)) {
                denyPermissions.add(permission);
            }
        }
        return denyPermissions;
    }


    private static <T> void requestResult(T t, int requestCode, String[] permissions,
                                          int[] grantResults, IPermission iPermission) {
        List<String> deniedPermissions = new ArrayList<>();
        for (int i = 0; i < grantResults.length; i++) {
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                deniedPermissions.add(permissions[i]);
            }
        }
        if (deniedPermissions.size() > 0) {
            if (iPermission != null) {
                iPermission.onDenied(requestCode);
            }
        } else {
            if (iPermission != null) {
                iPermission.onGranted(requestCode);
            }
        }
    }

}

interface IPermission {
    void onGranted(int requestCode);

    void onDenied(int requestCode);

    void onRational(int requestCode, List<String> permissions);

    /**
     * 是否需要提示用户该权限的作用，提示后需要再调用requestPermission()方法来申请。
     *
     * @return true 为提示，false为不提示
     */
    boolean showRational(int requestCode);
}

使用方法: 

public class MainFragment extends Fragment implements View.OnClickListener {
    private Button mReqCameraBt;
    private Button mReqContactsBt;
    private Button mReqMoreBt;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_main, container, false);
        findView(view);
        initView();
        return view;
    }

    private void findView(View view) {
        mReqCameraBt = (Button) view.findViewById(R.id.bt_requestCamera);
        mReqContactsBt = (Button) view.findViewById(R.id.bt_requestContacts);
        mReqMoreBt = (Button) view.findViewById(R.id.bt_requestMore);
    }

    private void initView() {
        mReqCameraBt.setOnClickListener(this);
        mReqContactsBt.setOnClickListener(this);
        mReqMoreBt.setOnClickListener(this);
    }


    public static final int REQUEST_CODE_CAMERA = 0;
    public static final int REQUEST_CODE_CONTACTS = 1;
    public static final int REQUEST_CODE_MORE = 2;

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        PermissionUtil.onRequestPermissionsResult(this, requestCode, permissions, grantResults, mPermission);
    }

    public void requestCamera() {
        PermissionUtil.checkPermissions(this, REQUEST_CODE_CAMERA, mPermission, Manifest.permission.CAMERA);
    }

    public void requestReadContacts() {
        PermissionUtil.checkPermissions(this, REQUEST_CODE_CONTACTS, mPermission, Manifest.permission.READ_CONTACTS);
    }

    public void requestMore() {
        PermissionUtil.checkPermissions(this, REQUEST_CODE_MORE, mPermission, Manifest.permission.READ_CONTACTS, Manifest.permission.READ_CALENDAR, Manifest.permission.CALL_PHONE);
    }

    private void showPermissionTipDialog(final int requestCode, final List<String> permissions) {
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setMessage("I want you permissions");
        builder.setTitle("Hello Permission");
        builder.setPositiveButton("确认", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
                PermissionUtil.requestPermission(MainFragment.this, requestCode, permissions);
            }
        });
        builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                dialog.dismiss();
            }
        });
        builder.create().show();
    }

    public IPermission mPermission = new IPermission() {
        @Override
        public void onGranted(int requestCode) {
            Toast.makeText(getActivity(), "onGranted :" + requestCode, Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onDenied(int requestCode) {
            Toast.makeText(getActivity(), "onDenied :" + requestCode, Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onRational(int requestCode, List<String> permission) {
            showPermissionTipDialog(requestCode, permission);
        }

        @Override
        public boolean showRational(int requestCode) {
            switch (requestCode) {
                case REQUEST_CODE_MORE:
                    return true;

                default:
                    break;
            }
            return false;
        }
    };

    @Override
    public void onClick(View v) {
        int id = v.getId();
        switch (id) {
            case R.id.bt_requestCamera:
                requestCamera();
                break;
            case R.id.bt_requestContacts:
                requestReadContacts();
                break;
            case R.id.bt_requestMore:
                requestMore();
                break;
        }
    }
}

参考:

更多文章请参考AndroidNote，欢迎Start

CharonChui
关注
专栏目录
android 6.0 权限授权方法
08-27
在Android 6.0（API级别23）及以上版本，系统引入了运行时权限管理机制，这改变了以往在安装应用时一次性授予所有权限的方式。现在，应用需要在运行时请求用户的许可，以便在需要的时候使用特定的敏感功能。以下是两...
vue在调用摄像头扫码(vue-qrcode-reader)
热门推荐
wzp20092009的博客
09-12 1万+
在浏览器端html中有一款依赖可以直接调用摄像头扫码，。分别提供vue-qrcode-reader用来识别二维码。
Qt 之相机Camera预览、拍照
一个老菜鸟的学习分享
03-28 4955
概述 项目中使用到相机的预览和拍照功能，在嵌入式下由于是第三方提供的平台，不是标准的，在qml下，Camera拿不到相机信息，只能通过底层适配，但是目前适配的流程是每次控制相机都要去遍历所有相机，然后根据某些规则去找到是自己要控制的相机，所以导致相机的预览、开关、拍照等操作均反应迟缓，作为Qt开发者来说，去做了三方面的尝试： 只能说被这个第三方嵌入式平台坑惨了- - 1 纯Qml控制，通过qt的mutimedia 模块中的Camera配合VideoOutput来实现； 2 通过QCamera 和 QAbst
QML类型说明-Camera
杞櫹椅桐的专栏
08-29 4769
Camera   ImportStatement:   import QtMultimedia 5.0 Inherits:      Item   Properties availability: enumeration cameraState: enumeration cameraStatus: enumeration captureMode: enumeration dig
Android M运行时权限详解
LWK 的专栏
06-16 4361
好久之前在网上看到国外一篇关于M的权限机制详解，由于是英文的，刚好最近闲的没事做，顺手翻译一下。 英文原文地址：https://inthecheesefactory.com/blog/things-you-need-to-know-about-android-m-permission-developer-edition/en 翻译水平有限，凑合着看吧。 前几天官方公布了Andro
Android6.0-14的兼容性
03-04 1054
android不同版本的兼容性
android 6.0权限申请封装
08-30
在Android 6.0（API级别23）中，谷歌引入了运行时权限管理系统，这是一项重要的安全更新，改变了之前版本中对应用权限的传统处理方式。在此系统下，应用程序不再在安装时获得所有请求的权限，而是需要在运行时根据...
Android6.0权限处理 示例
07-06
在`Android6.0 权限处理.md`文件中，详细记录了这个Demo的实现步骤和代码示例，包括如何初始化RxPermissions，何时何地请求权限，以及如何处理权限结果。而`PermissionHandler`可能是示例代码中的一个关键类，负责...
android 6.0权限申请
07-05
首先，我们需要理解Android 6.0权限系统的运作方式。在新的模型下，危险权限（如访问联系人、短信或位置等敏感信息）不再在安装时自动授予，而是需要在应用需要使用这些功能时动态请求。应用必须通过`ActivityCompat...
Android6.0权限工具类
10-11
以下是对"Android6.0权限工具类"的详细解释和相关知识点。 1. **运行时权限**：在Android 6.0之前，应用在安装时会自动获得清单文件中声明的所有权限。但在6.0之后，针对如读取联系人、访问位置等敏感权限，应用...
uni-app 获取移动设备的MAC地址
污妖王的博客
10-20 4970
getMacAddress() { var macAddress = ''; if (plus.os.name == 'Android') { console.log("plus.os.version", plus.os.version) // 6.0以上版本获取MAX地址的方法 if(plus.os.version >= 6.0){ var StringBuffer = plus.android.importClass("java.lang.Str...
原生Vue实现二维码扫一扫，兼容PC、安卓、IOS
FuSh1
11-09 6394
原生Vue实现二维码扫一扫 通过使用 vue-qrcode-reader 进行实现 文章目录原生Vue实现二维码扫一扫vue-qrcode-reader使用步骤1.引入库(全局引入)2.使用 vue-qrcode-reader yarn add vue-qrcode-reader --save 使用步骤 1.引入库(全局引入) 代码如下（示例）main.js： import VueQrcodeReader from "vue-qrcode-reader"; Vue.use(VueQrcodeRea
深入理解Android系统权限
2402_82733375的博客
03-14 727
**系统权限**：具有特殊保护级别的权限，通常只有系统应用或拥有特殊权限的应用才能使用。2. **权限管理复杂性**：从Android 6.0开始引入的运行时权限使得用户需要对每一项权限请求做出选择，增加了用户的操作负担。3. **灵活性**：开发者可以根据应用的需求灵活地申请所需的权限，而不必过度索取无关的权限，这有助于最小化应用对用户隐私的侵入。4. **潜在的滥用风险**：尽管有权限申请过程，但部分应用可能会在不明确告知用户的情况下索取不必要的权限，存在滥用风险。
Android的权限机制
KuLinin的博客
03-13 2214
AppOps全称是Application Operations，类似我们平时常说的应用程序的操作权限管理，AppOps是Google原生Android包含的功能，但是Google在每次版本更新时都会隐藏掉AppOps的入口，Google高管Hiroshi Lockheimer的原话：“App ops发布的时机不太对头，我们需要全面解决问题，而不是单独地发布Appops”。
Android6.0动态权限
Waruler的博客
12-25 4774
翻译自: http://inthecheesefactory.com/blog/things-you-need-to-know-about-android-m-permission-developer-edition/en https://developer.android.com/training/permissions/declaring.html 欢迎大家指正讨论 在Andr
Android 权限(一)：权限大全
u012514113的专栏
02-06 1万+
Android 权限大全
Android权限实现和执行
最新发布
SouthernNights的博客
08-15 1105
安卓权限介绍、权限等级分类、权限动态/静态注册/申请使用、四大组件权限执行
Android的权限管理系统工作原理详解
06-22 322
其次，系统需要能够处理权限的动态请求和撤销，以应对不同应用场景下的用户需求。此外，由于Android系统的开放性和碎片化问题，不同版本的Android系统可能在权限管理上存在差异，这要求开发者在编写应用时考虑兼容性问题。下面从技术难点、面试官关注点、回答吸引力以及代码举例四个方面，对Android的权限管理系统进行详细描述。回答这些问题时，应聘者需要清晰地阐述Android权限管理系统的基本原理和工作流程，并结合实际项目经验展示自己处理权限请求和兼容性问题的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值