Android之动态申请权限

最新推荐文章于 2024-04-26 13:21:31 发布
最新推荐文章于 2024-04-26 13:21:31 发布
阅读量3.3k 收藏 12
点赞数 3
分类专栏： Android 文章标签： android android studio java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChenYiRan123456/article/details/123052701
版权

文章目录


Android 6.0 (API 23) 之前应用的权限在安装时全部授予，运行时应用不再需要询问用户。在 Android 6.0 或更高版本对权限进行了分类，对某些涉及到用户隐私的权限可在运行时根据用户的需要动态授予。
Android 6.0以下，在AndroidManifest.xml文件中注册权限即可。
Android 6.0及其以后，既要在AndroidManifest.xml文件中注册，又要动态申请危险权限。

如果没有进行动态申请权限将报下面的权限问题的错
在这里插入图片描述

1.动态申请权限

打电话的动态申请权限例子

package com.example.androidnetwork;

import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import org.jetbrains.annotations.NotNull;

import butterknife.BindView;
import butterknife.ButterKnife;

import static android.os.Build.VERSION_CODES.M;

public class TestActivity extends AppCompatActivity {


    private static final String TAG = "TestActivity";
    private Button mButton;
    //请求码
    private int REQUESTCODE=1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
        ButterKnife.bind(this);
        mButton = findViewById(R.id.buttonTest);
       // getExternalFilesDir(Environment.DIRECTORY_PICTURES);

    }

    private void checkPermission() {
        //1.判断当前手机系统是否大于或等于6.0
        //4.如果有打电话的授权，就直接拨打电话
        //1.判断当前手机系统是否大于或等于6.0
        if(Build.VERSION.SDK_INT>=M){
            //2.如果大于6.0，则检查是否有打电话的权限授权
            int isPermission = ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE);//用于检测程序是否包含某项权限
            //下面的log如果程序第一次运行checkPermission一般是-1，需要下面的ActivityCompat.requestPermissions去动态
            //申请权限，当你动态申请过一次后下次就不是-1了，除非删掉程序。
            Log.d(TAG, "checkPermission: "+isPermission);
            if(isPermission== PackageManager.PERMISSION_GRANTED){
                //4.如果有打电话的授权，就直接拨打电话
                call();
            }else {
                //3.如果没有打电话的授权，就要去申请打电话的权限
                //下面为申请权限的方法，下面的onRequestPermissionsResult方法用于验证此方法申请成功或失败（到时会弹出一个对话框给你选择允许拒绝）
                //也会导致回调onRequestPermissionsResult方法
                ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.CALL_PHONE},REQUESTCODE);
            }
        }else {
            //5.如果当前版本小于6.0，直接拨打电话
            call();
        }
    }

    /*
    此函数为申请权限的回调方法，无论成功或者失败，都会回调这个方法
    requestCode:上文中提到的请求码
    permissions：申请的权限
    grantResults：申请的结果
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull @NotNull String[] permissions, @NonNull @NotNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if(requestCode==REQUESTCODE){
            if(grantResults!=null&&grantResults.length>0){
                //判断用户是否授予了这个权限
                //因为目前只有打电话这一个权限结果所以使用grantResults[0]
                if(grantResults[0]==PackageManager.PERMISSION_GRANTED){
                    call();
                }else {
                    Toast.makeText(this,"您拒绝了拨打电话的权限",Toast.LENGTH_SHORT).show();
                }
            }
        }
    }

    public void call(){
       //下面这个可以使用this的原因是编译时，他没有new一个实现类或者内部类，不然的话就要类名.this
       //Toast.makeText(this,"你好啊",Toast.LENGTH_SHORT).show();
       Intent intent = new Intent(Intent.ACTION_CALL);
       Uri uri = Uri.parse("tel:" + 1008611);
       intent.setData(uri);
       startActivity(intent);
       Log.d(TAG, "text: "+"跳转了");
   }
    public void text(View view){
       checkPermission();
    }
}

PackageManager.PERMISSION_GRANTED 与 PackageManager.PERMISSION_DENIED ，分别代表着有权限与无权限。通常我们会根据当前权限的状态来决定是否去申请相关权限。

具体内容可看程序注释，比较详细

2.动态申请权限工具类的封装

封装工具类

package com.example.androidnetwork.utils;

import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;

import android.provider.Settings;
import android.util.Log;

import android.widget.Toast;


import androidx.core.app.ActivityCompat;

/*
申请多个权限的工具类
 */
public class PermissionUtils {
    //请求码
    public final static int CODE_RECERD_AUDIO = 0;
    public final static int CODE_GET_ACCOUNTS = 1;
    public final static int CODE_READ_PHONE_STATE = 2;
    public final static int CODE_CALL_PHONE = 3;
    public final static int CODE_CAMERA = 4;
    public final static int CODE_ACCESS_FINE_LOCATION = 5;
    public final static int CODE_ACCESS_COARSE_LOCATION = 6;
    public final static int CODE_READ_EXTERNAL_STORAGE = 7;
    public final static int CODE_WRITE_EXTERNAL_STORAGE = 8;

    //权限的名称
    public static final String PERMISSION_RECERD_AUDIO = Manifest.permission.RECORD_AUDIO;
    public static final String PERMISSION_GET_ACCOUNTS = Manifest.permission.GET_ACCOUNTS;
    public static final String PERMISSION_READ_PHONE_STATE = Manifest.permission.READ_PHONE_STATE;
    public static final String PERMISSION_CALL_PHONE = Manifest.permission.CALL_PHONE;
    public static final String PERMISSION_CAMERA = Manifest.permission.CAMERA;
    public static final String PERMISSION_ACCESS_FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
    public static final String PERMISSION_ACCESS_COARSE_LOCATION = Manifest.permission.ACCESS_COARSE_LOCATION;
    public static final String PERMISSION_READ_EXTERNAL_STORAGE = Manifest.permission.READ_EXTERNAL_STORAGE;
    public static final String PERMISSION_WRITE_EXTERNAL_STORAGE = Manifest.permission.WRITE_EXTERNAL_STORAGE;

    //放进数组进行管理
    private static final String[]requestPermissions = {
            PERMISSION_RECERD_AUDIO,PERMISSION_GET_ACCOUNTS,PERMISSION_READ_PHONE_STATE,
            PERMISSION_CALL_PHONE,PERMISSION_CAMERA,PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_ACCESS_COARSE_LOCATION,PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };
    private static final String TAG = "PermissionUtils";

    //表示授权成功的接口
    public interface PermissionGrant{
        void onPermissionGranted(int requestCode);
    }
    /*
    封装请求权限的函数
     */
    public  static void requestPermission(Activity activity,int requestCode,PermissionGrant permissionGrant){
        if(activity==null){
            return;
        }
        //排除不存在的请求码
        if(requestCode<0||requestCode>=requestPermissions.length){
            return;
        }
        String requestPermission = requestPermissions[requestCode];
        //小于6.0的默认授权状态
        if(Build.VERSION.SDK_INT<23){
            return;
        }
        //大于6.0申请授权
        int checkSelfPermission ;
        try {
            checkSelfPermission= ActivityCompat.checkSelfPermission(activity,requestPermission);
        }catch (Exception e){
            Toast.makeText(activity,"请打开这个权限："+requestPermission,Toast.LENGTH_SHORT).show();
            return;
        }
        //判断是否被授权了
        if(checkSelfPermission!= PackageManager.PERMISSION_GRANTED){
            //没有被授权，需要进行申请
            if(ActivityCompat.shouldShowRequestPermissionRationale(activity,requestPermission)){
                //判断申请的权限是否需要弹出对话框
                shouldShowRationale(activity,requestCode,requestPermission);
            }else {
                ActivityCompat.requestPermissions(activity,new String[]{requestPermission},requestCode);
            }
        }else {
            //用户授权了，可以直接调用相关功能
            Toast.makeText(activity,"opened："+requestPermission,Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(requestCode);
        }
    }

    private static void shouldShowRationale(Activity activity, int requestCode, String requestPermission) {
        showMessageOKCancel(activity, "Rationale" + requestPermission, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                ActivityCompat.requestPermissions(activity,new String[]{requestPermission},requestCode);
            }
        });
    }

    /*
    申请权限结果的方法
     */
    public static void requestPermissionsResult(Activity activity,int requestCode,
                                                String[] permissions, int[] grantResults,PermissionGrant permissionGrant){
        if(activity==null){
            return;
        }
        if(requestCode<0||requestCode>=requestPermissions.length){
            Toast.makeText(activity,"illegar requestCode:"+requestCode, Toast.LENGTH_SHORT).show();
            return;
        }
        if(grantResults.length==1&&grantResults[0]==PackageManager.PERMISSION_GRANTED){
            //授权成功了(也就是点击允许了)
            permissionGrant.onPermissionGranted(requestCode);
        }else {
            //获取请求码对应的请求信息
            String permissionError =requestPermissions[requestCode];
            openSettingActivity(activity,"Result"+permissionError);
        }
    }
    //打开设置页面
    private static void openSettingActivity(Activity activity, String msg) {
        showMessageOKCancel(activity, msg, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Intent intent = new Intent();
                intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                Uri uri = Uri.fromParts("package", activity.getPackageName(), null);
                intent.setData(uri);
                activity.startActivity(intent);
            }
        });
    }
    //弹出是否打开的对话框
    private static void showMessageOKCancel(Activity activity, String msg, DialogInterface.OnClickListener oklistener){
        new AlertDialog.Builder(activity)
                .setMessage(msg)
                .setPositiveButton("OK",oklistener)
                .setNegativeButton("Cancel",null)
                .create().show();
    }
}

使用工具类

package com.example.androidnetwork;

import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import com.example.androidnetwork.utils.PermissionUtils;

import org.jetbrains.annotations.NotNull;

import butterknife.BindView;
import butterknife.ButterKnife;

import static android.os.Build.VERSION_CODES.M;

public class TestActivity extends AppCompatActivity {


    private static final String TAG = "TestActivity";
    private Button mButton;
    //请求码
    private int REQUESTCODE=1;
   PermissionUtils.PermissionGrant permissionGrant= new PermissionUtils.PermissionGrant() {

       @Override
       public void onPermissionGranted(int requestCode) {
           //onPermissionGranted方法里面执行你需要申请动态权限的内容
           call();
       }

   };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
        ButterKnife.bind(this);
        mButton = findViewById(R.id.buttonTest);
       // getExternalFilesDir(Environment.DIRECTORY_PICTURES);
        PermissionUtils.requestPermission(this, PermissionUtils.CODE_CALL_PHONE, permissionGrant);

    }

 
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull @NotNull String[] permissions, @NonNull @NotNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        Log.d(TAG, "onRequestPermissionsResult: "+permissions.length);
        PermissionUtils.requestPermissionsResult(this,requestCode,permissions,grantResults,permissionGrant);
    }

    public void call(){
       //下面这个可以使用this的原因是编译时，他没有new一个实现类或者内部类，不然的话就要类名.this
       //Toast.makeText(this,"你好啊",Toast.LENGTH_SHORT).show();
       Intent intent = new Intent(Intent.ACTION_CALL);
       Uri uri = Uri.parse("tel:" + 1008611);
       intent.setData(uri);
       startActivity(intent);
       Log.d(TAG, "text: "+"跳转了");
   }
    public void text(View view){
      // checkPermission();
       call();

    }
}

在这里插入图片描述
在这里插入图片描述

shouldShowRequestPermissionRationale，回到最初的解释“应不应该解释下请求这个权限的目的”。
1.都没有请求过这个权限，用户不一定会拒绝你，所以你不用解释，故返回false;
2.请求了但是被拒绝了，此时返回true，意思是你该向用户好好解释下了；
（也就是你第一次进行申请的时候弹出的对话框你选择了拒绝，那么就会返回true）
3.请求权限被禁止了，也不给你弹窗提醒了，所以你也不用解释了，故返回fasle;
4.请求被允许了，都给你权限了，还解释个啥，故返回false。
Google的初衷大概就是第一次requestPermissions的时候被拒绝时给你一次解释的机会，所以是让你在请求权限的回调中使用的。

3.一次申请多个权限的方法

 //    申请多个权限的请求码
    public final static int CODE_MULTI_PERMISSION = 100;
  /* 一次申请多个权限*/
    public static void requestMultiPermissions(final Activity activity, PermissionGrant grant){
        //获取没有被授权的权限
        ArrayList<String> permissionList = getNoGrantedPermission(activity, false);
        final ArrayList<String> shouldRationalePermissionList = getNoGrantedPermission(activity, true);
        if(permissionList==null||shouldRationalePermissionList==null){
            return;
        }

        if (permissionList.size()>0) {
            ActivityCompat.requestPermissions(activity,permissionList.toArray(new String[permissionList.size()]),
                    CODE_MULTI_PERMISSION);
        }else if (shouldRationalePermissionList.size()>0){
            showMessageOKCancel(activity, "should open those permissions", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    ActivityCompat.requestPermissions(activity,
                            shouldRationalePermissionList.toArray(new String[shouldRationalePermissionList.size()]),CODE_MULTI_PERMISSION);
                }
            });
        }else {
            grant.onPermissionGranted(CODE_MULTI_PERMISSION);
        }
    }

    /*
    * 获取没有被授权的权限列表
    * */
    private static ArrayList<String> getNoGrantedPermission(Activity activity,boolean isShouldRationale) {
        ArrayList<String>permissions = new ArrayList<>();
        for (int i=0;i<requestPermissions.length;i++){
           String requestPermission =  requestPermissions[i];
           int checkSelfPermission = -1;
           try {
               checkSelfPermission = ActivityCompat.checkSelfPermission(activity,requestPermission);
           }catch (Exception e){
               Toast.makeText(activity,"please open those permission",Toast.LENGTH_SHORT).show();
               return null;
           }

           if (checkSelfPermission!=PackageManager.PERMISSION_GRANTED){
//               没有被授权需要去申请
               if (ActivityCompat.shouldShowRequestPermissionRationale(activity,requestPermission)) {
                   if (isShouldRationale) {
                       permissions.add(requestPermission);
                   }
               }else {
                   if (!isShouldRationale){
                       permissions.add(requestPermission);
                   }
               }
           }
        }

        return permissions;
    }
     /*
    * 获取申请多个权限的结果
    * */
    public static void requestMultiResult(Activity activity,@NonNull String[] permissions, @NonNull int[] grantResults,
                                          PermissionGrant permissionGrant){
        if (activity == null) {
            return;
        }
        Map<String,Integer>perms = new HashMap<>();
        ArrayList<String> notGranted = new ArrayList<>();
        for (int i = 0; i < permissions.length; i++) {
            perms.put(permissions[i],grantResults[i]);
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                notGranted.add(permissions[i]);
            }
        }
        if (notGranted.size() == 0) {
            Toast.makeText(activity,"all permission succewss",Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(CODE_MULTI_PERMISSION);
        }else {
            openSettingActivity(activity,"those permission need granted!");
        }

    }

4.最终整个工具类

package com.animee.loadweb;
import android.Manifest;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

/* 申请多个权限的工具类*/
public class PermissonUtils {
    public final static int CODE_RECERD_AUDIO = 0;
    public final static int CODE_GET_ACCOUNTS = 1;
    public final static int CODE_READ_PHONE_STATE = 2;
    public final static int CODE_CALL_PHONE = 3;
    public final static int CODE_CAMERA = 4;
    public final static int CODE_ACCESS_FINE_LOCATION = 5;
    public final static int CODE_ACCESS_COARSE_LOCATION = 6;
    public final static int CODE_READ_EXTERNAL_STORAGE = 7;
    public final static int CODE_WRITE_EXTERNAL_STORAGE = 8;
//    申请多个权限的请求码
    public final static int CODE_MULTI_PERMISSION = 100;

    public static final String PERMISSION_RECERD_AUDIO = Manifest.permission.RECORD_AUDIO;
    public static final String PERMISSION_GET_ACCOUNTS = Manifest.permission.GET_ACCOUNTS;
    public static final String PERMISSION_READ_PHONE_STATE = Manifest.permission.READ_PHONE_STATE;
    public static final String PERMISSION_CALL_PHONE = Manifest.permission.CALL_PHONE;
    public static final String PERMISSION_CAMERA = Manifest.permission.CAMERA;
    public static final String PERMISSION_ACCESS_FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
    public static final String PERMISSION_ACCESS_COARSE_LOCATION = Manifest.permission.ACCESS_COARSE_LOCATION;
    public static final String PERMISSION_READ_EXTERNAL_STORAGE = Manifest.permission.READ_EXTERNAL_STORAGE;
    public static final String PERMISSION_WRITE_EXTERNAL_STORAGE = Manifest.permission.WRITE_EXTERNAL_STORAGE;

    private static final String[]requestPermissions = {
            PERMISSION_RECERD_AUDIO,PERMISSION_GET_ACCOUNTS,PERMISSION_READ_PHONE_STATE,
            PERMISSION_CALL_PHONE,PERMISSION_CAMERA,PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_ACCESS_COARSE_LOCATION,PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };
// 表示授权成功的接口
    public  interface PermissionGrant{
        void onPermissionGranted(int requestCode);
    }
    /*
    * 封装请求权限的函数
    * */
    public static void requestPermission(Activity activity,int requestCode,PermissionGrant permissionGrant){
        if (activity == null) {
            return;
        }
//        排除不存在的请求码
        if(requestCode< 0||requestCode>=requestPermissions.length){
            return;
        }

        String requestPermission = requestPermissions[requestCode];
//       小于6.0默认授权状态
        if(Build.VERSION.SDK_INT<23){
            return;
        }
        int checkSelfPermission;
        try {
            checkSelfPermission = ActivityCompat.checkSelfPermission(activity,requestPermission);
        }catch (Exception e){
            Toast.makeText(activity,"请打开这个权限："+requestPermission,Toast.LENGTH_SHORT).show();
            return;
        }
        //判断是否被授权了
        if (checkSelfPermission!= PackageManager.PERMISSION_GRANTED) {
            // 没有被授权，需要进行申请
            if(ActivityCompat.shouldShowRequestPermissionRationale(activity,requestPermission)){
                shouldShowRationale(activity,requestCode,requestPermission);
            }else {
                ActivityCompat.requestPermissions(activity,new String[]{requestPermission},requestCode);
            }
        }else {
            //用户授权了，可以直接调用相关功能
            Toast.makeText(activity,"opened："+requestPermission,Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(requestCode);
        }
    }

    private static void shouldShowRationale(final Activity activity, final int requestCode, final String requestPermission) {
        showMessageOKCancel(activity, "Rationale:" + requestPermission, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                ActivityCompat.requestPermissions(activity,new String[]{requestPermission},requestCode);
            }
        });
    }

    /*
    * 申请权限结果的方法
    * */
    public static void requestPermissionsResult(Activity activity, int requestCode,
                                                @NonNull String[] permissions, @NonNull int[] grantResults,PermissionGrant permissionGrant){
        if (activity == null) {
            return;
        }
        if(requestCode<0||requestCode>=requestPermissions.length){
            Toast.makeText(activity,"illegal requestCode:"+requestCode,Toast.LENGTH_SHORT).show();
            return;
        }

        if(grantResults.length==1&&grantResults[0]==PackageManager.PERMISSION_GRANTED){
//            授权成功了
            permissionGrant.onPermissionGranted(requestCode);
        }else {
            String permissionError = permissions[requestCode];
            openSettingActivity(activity,"Result:"+permissionError);
        }
    }
    /*
    * 获取申请多个权限的结果
    * */
    public static void requestMultiResult(Activity activity,@NonNull String[] permissions, @NonNull int[] grantResults,
                                          PermissionGrant permissionGrant){
        if (activity == null) {
            return;
        }
        Map<String,Integer>perms = new HashMap<>();
        ArrayList<String> notGranted = new ArrayList<>();
        for (int i = 0; i < permissions.length; i++) {
            perms.put(permissions[i],grantResults[i]);
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                notGranted.add(permissions[i]);
            }
        }
        if (notGranted.size() == 0) {
            Toast.makeText(activity,"all permission succewss",Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(CODE_MULTI_PERMISSION);
        }else {
            openSettingActivity(activity,"those permission need granted!");
        }

    }
    /*打开设置界面*/
    private static void openSettingActivity(final Activity activity, String msg) {
        showMessageOKCancel(activity, msg, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Intent intent = new Intent();
                intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                Uri uri = Uri.fromParts("package", activity.getPackageName(), null);
                intent.setData(uri);
                activity.startActivity(intent);
            }
        });
    }

    /* 弹出是否打开的对话框*/
    private static void showMessageOKCancel(Activity activity, String msg, DialogInterface.OnClickListener oklistener){
        new AlertDialog.Builder(activity)
                .setMessage(msg)
                .setPositiveButton("OK",oklistener)
                .setNegativeButton("Cancel",null)
                .create().show();
    }

    /* 一次申请多个权限*/
    public static void requestMultiPermissions(final Activity activity, PermissionGrant grant){
        //获取没有被授权的权限
        ArrayList<String> permissionList = getNoGrantedPermission(activity, false);
        final ArrayList<String> shouldRationalePermissionList = getNoGrantedPermission(activity, true);
        if(permissionList==null||shouldRationalePermissionList==null){
            return;
        }

        if (permissionList.size()>0) {
            ActivityCompat.requestPermissions(activity,permissionList.toArray(new String[permissionList.size()]),
                    CODE_MULTI_PERMISSION);
        }else if (shouldRationalePermissionList.size()>0){
            showMessageOKCancel(activity, "should open those permissions", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    ActivityCompat.requestPermissions(activity,
                            shouldRationalePermissionList.toArray(new String[shouldRationalePermissionList.size()]),CODE_MULTI_PERMISSION);
                }
            });
        }else {
            grant.onPermissionGranted(CODE_MULTI_PERMISSION);
        }
    }

    /*
    * 获取没有被授权的权限列表
    * */
    private static ArrayList<String> getNoGrantedPermission(Activity activity,boolean isShouldRationale) {
        ArrayList<String>permissions = new ArrayList<>();
        for (int i=0;i<requestPermissions.length;i++){
           String requestPermission =  requestPermissions[i];
           int checkSelfPermission = -1;
           try {
               checkSelfPermission = ActivityCompat.checkSelfPermission(activity,requestPermission);
           }catch (Exception e){
               Toast.makeText(activity,"please open those permission",Toast.LENGTH_SHORT).show();
               return null;
           }

           if (checkSelfPermission!=PackageManager.PERMISSION_GRANTED){
//               没有被授权需要去申请
               if (ActivityCompat.shouldShowRequestPermissionRationale(activity,requestPermission)) {
                   if (isShouldRationale) {
                       permissions.add(requestPermission);
                   }
               }else {
                   if (!isShouldRationale){
                       permissions.add(requestPermission);
                   }
               }
           }
        }

        return permissions;
    }
}
Mr YiRan
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Android权限申请之动态申请权限
qq_46653910的博客
08-02 1万+
对于一些危险权限在AndroidManifest清单文件中申请之后，还需要得到用户的许可并打开，才算是真正的开启了这个权限。所以可以使用动态申请权限，对于某个功能，如果需要开启某个权限，在用户使用它之前，弹窗提示用户是否要开启这个权限。检查权限是否开启，如果开启了则不需要再执行下面的步骤，直接使用功能即可。如果没有开启，那么就申请开启权限。在AndroidManifest清单文件中声明要开启的权限。下面以申请写入外存权限为例。接受申请开启权限的结果。......
Android系统应用权限异常检测技术研究
04-16
在安卓系统中，一个应用的申请的权限往往能反应出这个应用的行为模式。而一个恶意应用的出现，是需要多个权限配合的。本文针对Android平台恶意应用泛滥的问题，通过对Apriroi算法进行研究改进，寻找恶意应用申请权限之间的关联性，挖掘它们之间的关系，判断应用的恶意性，为Android用户提供安全保障。并通大量实验数据以及与其它方法进行比较得出，本文提出的方法的准确率高达78.6%，能够较为准确的判断出一个应用是否是恶意应用。
android studio开发——android11版本以上权限动态申请问题，包括文件读写、图片、相机的调用
热门推荐
m0_59799878的博客
05-21 1万+
下面是第二种情况在Fragment中动态申请权限，因为Fragment是相当于依附在Activity中的页面，所以Fragment中没有回调函数处理，因此需要用到它所在的Activity的activity对象，例如Fragment的定义如下。那么权限数组可能就不一样了，android13以下的申请读写权限就好了，而android13则可能需要动态申请这3个权限，所以代码如下，这里我用Fragment申请权限。第一种情况就比较直接，按照android11之前的权限申请如下。2.相册、相机权限申请情况。
动态申请 相机权限，2024Android通用流行框架大全
m0_60607289的博客
03-20 1107
2>如果没有CAMERA权限，进行如下判断，当第一次申请权限时 shouldShowRequestPermissionRationale返回false，第一次用户拒绝，再次申请的时候返回true，在此判断中提示用户为什么要申请这个权限。2>当多次（两次或两次以上）请求操作时，会有不再提示的选择框，如果用户选择了不再提示，shouldShowRequestPermissionRationale为false，在此判断中提示用户权限已被禁止，需要在应用管理中自行打开。"相机权限已被禁止""相机权限已被禁止"
Android中不支持动态申请权限的原因
09-03
主要介绍了Android中不支持动态申请权限的原因,本文列举了几个不支持动态申请权限的原因,需要的朋友可以参考下
android6.0动态权限申请
07-19
android6.0动态权限在进入MainActivity之前集体申请，一条龙解决，使用方便，也可自己在当前模块在手动申请
Android-6.0动态申请权限工具类
08-13
动态申请权限工具类 android 6.0 以上需要动态申请权限, 而动态申请权限一般比较繁琐, 所以该工具类应运而生
Android---动态权限申请
qq_44950283的博客
03-18 7075
Google 在 Android开始引入了权限申请机制，将所有权限分成了和。App 每次在使用危险权限时需要动态的申请并得到用户的授权才能使用。和：不会直接给用户隐私带来危险。如果你在其清单中列出了正常权限，系统将自动授予该权限。：授予应用访问用户机密数据的权限。如果你在清单文件中列出了危险权限，则用户必须明确批准你的应用使用这些权限。那么危险权限有那些？和等。申请以上权限时，除了要在清单文件中添加权限，还需要通过代码动态申请。
安卓动态申请权限
qq_45649553的博客
07-05 1172
app动态权限申请
从源码角度看Android如何完成动态权限申请
m0_56144365的博客
06-19 2667
伙伴们应该都了解，在Android6.0之后，对于部分权限，例如Camera、读写存储权限等，都需要用户授权才可以使用，除非你的应用为系统应用，否则这些“危险权限”将不会自动授予，那么为什么Google在Android 6.0之后会推出动态权限申请，主要是避免一些“流氓”软件在后台获取用户隐私，从而将责任从技术侧转移到用户侧，既然用户选择了允许这些权限使用，那么责任就由用户承担了。那么我们在动态申请权限时，系统是如何处理并保存这些状态，接下来我们深入源码一看究竟。
Android 动态申请应用权限
晨曦的博客
05-03 7391
一、概述 Android 6.0 (API 23) 之前应用的权限在安装时全部授予，运行时应用不再需要询问用户。在 Android 6.0 或更高版本对权限进行了分类，对某些涉及到用户隐私的权限可在运行时根据用户的需要动态授予。这样就不需要在安装时被强迫同意某些权限。 二、Android系统权限 两个最重要保护级别是正常权限和危险权限： （1）正常权限：涵盖应用需要访问其沙盒外部数据或资源，但对用户隐私或其他应用操作风险很小的区域。这些权限在应用安装时授予，运行时不再询问用户。例如: 网络访问...
Android 如何实现动态申请权限
08-19
主要介绍了Android 如何实现动态申请权限。具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
android 6.0权限申请封装
08-30
android 6.0权限申请封装
Qt for android 动态权限申请
01-30
Qt for android 动态权限申请工具类
android 动态申请权限封装
09-25
Android动态权限申请封装总结。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Android --- 英文单引号用&apos；替换报错：does not contain a valid string resource
梁同学与Android
04-23 181
Android --- 英文单引号用&apos;替换报错：does not contain a valid string resource
Android使用ProtoBuf 适配 gradle7.5 gradle8.0
最新发布
wsdxho的博客
04-26 463
android 配置 protobuf插件 (gradle7.5 gradle8.0 适配)
TP8 利用jwt 生成token
m0_69254007的博客
04-26 155
使用Composer安装依赖库，终端切换到项目根目录输入如下。
OceanBase OLAP collation utf8mb4_bin 优先
余璜的技术博客
04-23 343
utf8mb4_bin是一种二进制的排序规则，比较字符串时直接比较字符串的二进制值，不需要进行复杂的字符比较和排序运算，这样可以有效减少CPU的使用，提高查询效率，特别是在涉及到大量数据操作时，性能优势更为明显。在大数据系统中，如无特别需要，建议 collation 指定为 utf8mb4_bin。
Android 动态申请权限
05-25
在 Android 应用中，有一些需要用户授权才能访问的敏感权限，比如读取联系人、摄像头、定位等权限。在 Android 6.0（API Level 23）及以上版本中，系统引入了动态权限申请机制，应用需要在运行时动态申请这些权限。 以下是 Android 动态申请权限的基本流程： 1. 在 AndroidManifest.xml 文件中声明需要申请的权限，例如： ``` <uses-permission android:name="android.permission.CAMERA" /> ``` 2. 在应用中检查是否拥有该权限，如果没有则向用户申请该权限。 ``` if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, MY_PERMISSIONS_REQUEST_CAMERA); } ``` 3. 实现回调方法 onRequestPermissionsResult()，处理用户的权限选择结果。 ``` @Override public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { if (requestCode == MY_PERMISSIONS_REQUEST_CAMERA) { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { // 权限已授予，执行相应操作 } else { // 权限被拒绝，提示用户并做相应处理 } return; } } ``` 以上就是 Android 动态申请权限的基本流程。需要注意的是，在申请权限前需要先检查是否已经授权，如果已经授权则可以直接执行相应操作，否则需要向用户申请权限。此外，在处理用户的权限选择结果时，需要根据 requestCode 参数进行判断，以确定是哪个权限的申请结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值