探讨Android 6.0及以上新权限系统的检测与处理

转载自：http://blog.csdn.net/AndrExpert/article/details/53331836?locationNum=8&fps=1

探讨Android 6.0及以上新权限系统的检测与处理 

 

作者：	蒋东国
时间：	2016年11月24日 星期四
应用来源：	lcb APP(测试机型：huawei 4X(6.0)/Samsung Note4(Android 5.0.1))
博客地址：	http://blog.csdn.net/andrexpert/article/details/53331836

      

       情景再现：“最近在开发一个地图导航软件，由于之前的测试都是部署在三星Note4(5.0.1)上，相关功能基本正常。当自己换到荣耀4X(Android 6.0)时，软件虽然没有异常退出，但却无法定位，通过查看Logcat打印出来的日志，发现这是因为APP部署到6.0以上系统后，Android系统没有授予相关位置权限才会报“Could not open database，(OS error -13：Permission denied)”错误。”

 

       从Google官方文档可知，Android系统升级到6.0后，它的权限系统被重新设计。相比原来新安装的APP系统会一次性授予所有权限和用户无法管理APP权限的不足，新的权限系统不再允许新安装的APP一次性获得所有权限，APP必须在运行时一个一个地询问用户授予权限，甚至有时候都不会主动申请用户授权，开发者不得不自己去检测和请求用户授予来获得权限。那么当我们的APP部署到Android 6.0以上系统的终端时，某些功能没有获得相关权限或者用户拒绝授予权限又会出现什么问题呢？这里的异常情况有两种：

      (1)   APP暂时不支持6.0以上系统，即APP的AndroidManifest.xml配置文件<uses-sdk../>

中的android:targetSdkVersion属性值<23时(Android 6.0即SDK版本23)，系统会认为新安装的APP还没有支持新的权限系统而不会异常退出，当然APP相关的功能也不会正常运行。

      (2)   APP已经支持6.0以上系统，即APP的 AndroidManifest.xml配置文件<uses-sdk../>中

android:targetSdkVersion属性值>=23时，如果APP在运行时没有获得相关的权限，将会异常退出。

1. 让你的APP支持新的运行时权限  

     Android权限系统被重新设计后，系统的安全性自然提高不少，用户的相关数据也得到了很好的保护。但是对于开发者而言，如果其APP还没有引入支持新的权限系统，当APP运行在Android6.0以上系统时，很可能导致很多问题，这对于一款APP来说可能是致命的。因此，谷歌在API 23中引入了ContextWrapper.checkSelfPermission和Activity.requestPermissions两个方法分别用来检查所请求权限的授予情况和请求用户授予该权限。当然，之前很多人都认为使用权限的检查都是用checkPermission、checkCallingOrSelfPermission来实现，其实，这两个方法只是检测你的APP是否声明了该权限，只要你声明了运行时请求的权限，它们都将返回PERMISSION_GRANTED，最后自然也无法在APP运行时真正检查到是否拥有该权限。

       为了更好的理解和使用ContextWrapper.checkSelfPermission、Activity.requestPermissions来进行运行时权限的检测和请求，我根据需求将其进行了封装，即是自己的总结，也方便了他人，具体内容如下：

      (1) APP请求单个权限，封装的方法为isPermissionGranted，它需要传递两个参数：

permissionName参数为请求的权限，比如发送短信为Manifest.permission.SEND_SMS；questCode参数为请求标志，将作为该权限的判断标志。

[java]  view plain  copy

1. protectedboolean isPermissionGranted(String permissionName,int questCode){   
2.        //6.0以下系统，取消请求权限  
3.        if(Build.VERSION.SDK_INT< Build.VERSION_CODES.M){  
4.               returntrue;  
5.        }  
6.        //判断是否需要请求允许权限，否则请求用户授权  
7.        inthasPermision = checkSelfPermission(permissionName);  
8.        if(hasPermision != PackageManager.PERMISSION_GRANTED) {  
9.               requestPermissions(newString[] { permissionName}, questCode);  
10.               returnfalse;  
11.        }             
12.        returntrue;  
13.  }  

     (2) APP同时请求多个权限，即批量请求权限，常见于APP第一次安装时需要用户批量授予多个权限，这样能够提高APP后续的用户体验，封装的方法为isPermissionsAllGranted，它需要传递两个参数：permArray参数为批量请求的权限字符串数组，questCode参数为请求标志，将作为这次请求的判断标志。

[java]  view plain  copy

1. protected boolean isPermissionsAllGranted(String[] permArray,intquestCode){  
2.               //6.0以下系统，取消请求权限  
3. if(Build.VERSION.SDK_INT <Build.VERSION_CODES.M){  
4.       returntrue;  
5. }  
6. //获得批量请求但被禁止的权限列表  
7. List<String> deniedPerms = newArrayList<String>();  
8. for(int i=0;permArray!=null&&i<permArray.length;i++){  
9. if(PackageManager.PERMISSION_GRANTED !=checkSelfPermission(permArray[i])){  
10.              deniedPerms.add(permArray[i]);  
11. }  
12. }  
13. int denyPermNum = deniedPerms.size();  
14. //进行批量请求  
15. if(denyPermNum != 0){  
16.       requestPermissions(deniedPerms.toArray(newString[denyPermNum]),questCode);  
17.       returnfalse;  
18. }  
19. return true;  
20. }  

    注意：在进行权限检测、请求时，需要对当前部署的终端进行系统版本检查，判断是否为Android6.0以上系统，否则会报“method can not reserved”异常，因为checkSelfPermission和requestPermissions是API 23才引入的方法。另外，Android 6.0以下的系统无需进行权限检测，因为它仍然使用老的权限系统，APP安装时会默认授予运行时所有的权限。

    (3) 获得权限用户授予情况

    由上述(1)、(2)可知，通过封装的两个方法，我们可以很容易的检测某个权限或多个权限是否被用于授予，以及去请求某个或多个权限需要用户授予。那么，我们又如何知道用户最终的授权情况，和针对不同的授权情况做相应的处理呢？答案是：onRequestPermissionsResult方法。onRequestPermissionsResult是Activity的一个方法，通过覆写该方法并结合权限标识码requestCode来判断相应权限授予结果，代码如下：

[java]  view plain  copy

1. publicvoid onRequestPermissionsResult(int requestCode,  
2.               String[]permissions, int[] grantResults) {  
3.        if(grantResults.length==0){  
4.               return;  
5.        }  
6.        switch(requestCode) {  
7.        caseConstants.QUEST_CODE_SEND_SMS:  
8.               if(grantResults[0] != PackageManager.PERMISSION_GRANTED) {  
9.                      //用户拒绝授予发送短信权限，弹出一个警告对话框  
10.                      popAlterDialog();  
11.               }  
12.               break;  
13.        caseConstants.QUEST_CODE_ALL:  
14.               //用户拒绝授予请求所有或某一项权限，弹出一个经过对话框  
15.               doPermissionAll(Constants.permArray,grantResults);  
16.               break;  
17.        default:  
18.               super.onRequestPermissionsResult(requestCode,permissions,  
19.                             grantResults);  
20.               break;  
21.        }  
22. }  

2.  Demo实战剖析

    为了进一步理解Android 6.0以上系统新权限系统的检查处理，我写了一个小Demo，也算是对封装的两个方法的演示。整个Demo项目以BaseActivity.class、MainActivity.class、AndroidManifest.xml为核心，代码介绍如下：

(1)  BaseActivity.class

   由于checkSelfPermission、requestPermissions、onRequestPermissionsResult方法属于Activity，为了防止在不同的Activity都要写一个套权限检测方法导致代码冗余，这里封装一个BaseActivity，当我们在某个Activity需要请求某个权限时，只需继承该父Activity即可使用相关的权限检查方法和获得处理，代码如下：

[java]  view plain  copy

1. /** 
2.  *@dscrible Activity基类 
3.  * 
4.  * Created by jiangdongguo on 2016-11-25 上午9:42:08 
5.  */  
6. public abstract class BaseActivity extends Activity {  
7.   
8.     @Override  
9.     protected void onCreate(Bundle savedInstanceState) {  
10.         super.onCreate(savedInstanceState);  
11.         onCreateView();  
12.         init();  
13.     }  
14.   
15.     abstract void onCreateView();  
16.       
17.     abstract  void init();  
18.   
19.     protected boolean isPermissionGranted(String permissionName,int questCode){  
20.         if(Build.VERSION.SDK_INT < Build.VERSION_CODES.M){  
21.             return true;  
22.         }  
23.         //判断是否需要请求允许权限  
24.         int hasPermision = checkSelfPermission(permissionName);  
25.         if (hasPermision != PackageManager.PERMISSION_GRANTED) {  
26.             requestPermissions(new String[] { permissionName }, questCode);  
27.             return false;  
28.         }         
29.         return true;  
30.      }  
31.       
32.     protected boolean isPermissionsAllGranted(String[] permArray,int questCode){  
33.         if(Build.VERSION.SDK_INT < Build.VERSION_CODES.M){  
34.             return true;  
35.         }  
36.         //获得批量请求但被禁止的权限列表  
37.         List<String> deniedPerms = new ArrayList<String>();  
38.         for(int i=0;permArray!=null&&i<permArray.length;i++){  
39.             if(PackageManager.PERMISSION_GRANTED != checkSelfPermission(permArray[i])){  
40.                 deniedPerms.add(permArray[i]);  
41.             }  
42.         }  
43.         //进行批量请求  
44.         int denyPermNum = deniedPerms.size();  
45.         if(denyPermNum != 0){  
46.             requestPermissions(deniedPerms.toArray(new String[denyPermNum]),questCode);  
47.             return false;  
48.         }  
49.         return true;  
50.     }  
51.       
52.     @Override  
53.     public void onRequestPermissionsResult(int requestCode,  
54.             String[] permissions, int[] grantResults) {  
55.         if(grantResults.length==0){  
56.             return;  
57.         }  
58.         switch (requestCode) {  
59.         case Constants.QUEST_CODE_LOCTION:  
60.             if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {  
61.                 popAlterDialog("位置","位置信息权限被禁止，将导致定位失败。。是否开启该权限？(步骤：应用信息->权限->'勾选'位置)");  
62.             }else{  
63.                 showShortMsg("恭喜，用户已经授予位置权限");  
64.             }  
65.             break;  
66.         case Constants.QUEST_CODE_CAMERA:  
67.             if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {  
68.                 popAlterDialog("相机","摄像头使用权限被禁止，手电筒无法正常使用。是否开启该权限？(步骤：应用信息->权限->'勾选'相机)");  
69.             }else{  
70.                 showShortMsg("恭喜，用户已经授予相机权限");  
71.             }  
72.             break;  
73.         case Constants.QUEST_CODE_SEND_SMS:  
74.             if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {  
75.                 popAlterDialog("短信","发送短信权限被禁止，无法使用反馈/建议功能。是否开启该权限？(步骤：应用信息->权限->'勾选'短信)");  
76.             }else{  
77.                 showShortMsg("恭喜，用户已经授予短信权限");  
78.             }  
79.             break;  
80.         case Constants.QUEST_CODE_ALL:  
81.             doPermissionAll(Constants.permArray,grantResults);  
82.             break;  
83.         case Constants.QUEST_CODE_CALL_PHONE:  
84.             if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {  
85.                 popAlterDialog("拨打电话","拨打电话权限被禁止，无法使用拨打电话功能。是否开启该权限？(步骤：应用信息->权限->'勾选'电话)");  
86.             }else{  
87.                 showShortMsg("恭喜，用户已经授予所有权限");  
88.             }  
89.             break;  
90.         default:  
91.             super.onRequestPermissionsResult(requestCode, permissions,  
92.                     grantResults);  
93.             break;  
94.         }  
95.     }  
96.       
97.     private void doPermissionAll(String[] permissions, int[] grantResults) {  
98.         int grantedPermNum = 0;  
99.         int totalPermissons = permissions.length;  
100.         int totalResults = grantResults.length;  
101.         if(totalPermissons == 0 || totalResults == 0){  
102.             return;  
103.         }  
104.         Map<String,Integer> permResults = new HashMap<String,Integer>();  
105.         //初始化Map容器，用于判断哪些权限被授予  
106.         for(String perm:Constants.permArray){  
107.             permResults.put(perm,PackageManager.PERMISSION_DENIED);  
108.         }         
109.         //根据授权的数目和请求授权的数目是否相等来判断是否全部授予权限  
110.         for(int i=0;i<totalResults;i++){  
111.             permResults.put(permissions[i],grantResults[i]);  
112.             if(permResults.get(permissions[i]) == PackageManager.PERMISSION_GRANTED){  
113.                 grantedPermNum ++;  
114.             }  
115.             Log.d("Debug","权限："+permissions[i]+"-->"+grantResults[i]);  
116.         }  
117.         if (grantedPermNum == totalPermissons) {  
118.             //用于授予全部权限  
119.         }else{  
120.             showShortMsg( "批量申请权限失败，将会影响正常使用！");  
121.         }  
122.     }  
123.       
124.     private void showShortMsg(String msg) {  
125.         Toast.makeText(this,msg, Toast.LENGTH_SHORT).show();  
126.     }  
127.   
128.     private void popAlterDialog(final String msgFlg, String msgInfo) {  
129.         new AlertDialog.Builder(BaseActivity.this)  
130.         .setTitle("使用警告")  
131.         .setMessage(msgInfo)  
132.         .setNegativeButton("取消", new DialogInterface.OnClickListener(){  
133.             @Override  
134.             public void onClick(DialogInterface dialog, int which) {  
135.                 dialog.dismiss();  
136.             }         
137.         })  
138.         .setPositiveButton("设置",new DialogInterface.OnClickListener() {               
139.             @Override  
140.             public void onClick(DialogInterface dialog, int which) {  
141.                 //前往应用详情界面  
142.                 try {  
143.                     Uri packUri = Uri.parse("package:"+getPackageName());  
144.                     Intent intent = new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,packUri);  
145.                     intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
146.                     BaseActivity.this.startActivity(intent);  
147.                 } catch (Exception e) {  
148.                     showShortMsg("跳转失败");  
149.                 }  
150.                 dialog.dismiss();  
151.             }  
152.         }).create().show();  
153.     }  
154. }  

(2) MainActivity.class：继承于BaseActivity，发起权限检测

[java]  view plain  copy

1. /** 
2.  *@dscrible 分别请求短信、位置等权限 
3.  * 
4.  * Created by jiangdongguo on 2016-11-25 上午9:45:20 
5.  */  
6. public class MainActivity extends BaseActivity implements OnClickListener{  
7.     private Button mCheckContactBtn;  
8.     private Button mCheckLocationBtn;  
9.     private Button mCheckAllBtn;  
10.     @Override  
11.     void onCreateView() {  
12.         setContentView(R.layout.activity_main);  
13.         initLayout();  
14.     }  
15.   
16.     private void initLayout() {  
17.         mCheckContactBtn = (Button)findViewById(R.id.check_contacts_btn);  
18.         mCheckLocationBtn = (Button)findViewById(R.id.check_location_btn);  
19.         mCheckAllBtn = (Button)findViewById(R.id.check_all_permission_btn);  
20.         mCheckContactBtn.setOnClickListener(this);    
21.         mCheckLocationBtn.setOnClickListener(this);  
22.         mCheckAllBtn.setOnClickListener(this);  
23.     }  
24.   
25.     @Override  
26.     void init() {  
27.           
28.     }  
29.   
30.     @Override  
31.     public void onClick(View v) {  
32.         int vId = v.getId();  
33.         switch (vId) {  
34.         case R.id.check_contacts_btn:  
35.             //检测发送短信权限  
36.             isPermissionGranted(Manifest.permission.WRITE_CONTACTS,  
37. Constants.QUEST_CODE_SEND_SMS);  
38.             break;  
39.         case R.id.check_location_btn:  
40. //检测位置信息权限                   isPermissionGranted(Manifest.permission.ACCESS_COARSE_LOCATION,  
41. Constants.QUEST_CODE_LOCTION);  
42.             break;  
43.         case R.id.check_all_permission_btn:  
44.             //批量检测短信、位置、相机、电话使用权限  
45.             isPermissionsAllGranted(Constants.permArray,Constants.QUEST_CODE_ALL);  
46.             break;  
47.         default:  
48.             break;  
49.         }  
50.     }  
51. }  

(3) AndroidManifest.xml：声明要请求的权限，设置android:targetSdkVersion支持Android6.0+新权限系统，即android:targetSdkVersion="23"。

[html]  view plain  copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.     package="com.example.mandroidpermissiondemo"  
4.     android:versionCode="1"  
5.     android:versionName="1.0" >  
6.     <uses-permission android:name="android.permission.WRITE_CONTACTS"/>   
7.     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />  
8.     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />  
9.     <uses-permission android:name="android.permission.READ_SMS"/>  
10.     <uses-permission android:name="android.permission.CALL_PHONE"/>  
11.     <uses-sdk  
12.         android:minSdkVersion="18"  
13.         android:targetSdkVersion="23" />  
14.   
15.     <application  
16.         android:allowBackup="true"  
17.         android:icon="@drawable/ic_launcher"  
18.         android:label="@string/app_name"  
19.         android:theme="@style/AppTheme" >  
20.         <activity  
21.             android:name=".MainActivity "  
22.             android:label="@string/app_name" >  
23.             <intent-filter>  
24.                 <action android:name="android.intent.action.MAIN" />  
25.   
26.                 <category android:name="android.intent.category.LAUNCHER" />  
27.             </intent-filter>  
28.         </activity>  
29.     </application>  
30. </manifest>  

(4) Constants.class：常量类

[java]  view plain  copy

1. /** 
2.  *@dscrible 常量和临时变量类 
3.  * 
4.  * Created by jiangdongguo on 2016-10-31 上午11:10:27 
5.  */  
6. public class Constants {  
7.     /**位置信息权限请求标志*/  
8.     public static final int QUEST_CODE_LOCTION = 1;  
9.     /**发送短信权限请求标志*/  
10.     public static final int QUEST_CODE_SEND_SMS = 2;  
11.     /**摄像头权限标志*/  
12.     public static final int QUEST_CODE_CAMERA = 3;  
13.     /**批量请求权限*/  
14.     public static final int QUEST_CODE_ALL  = 4;  
15.     /**拨打电话权限*/  
16.     public static final int QUEST_CODE_CALL_PHONE = 5;  
17.     //要申请的权限  
18.     public static final  String[] permArray =  
19. { Manifest.permission.ACCESS_COARSE_LOCATION,  
20.           Manifest.permission.SEND_SMS, Manifest.permission.CAMERA,  
21. Manifest.permission.CALL_PHONE};  
22. }  

效果演示：

      

码字不容易，转载请注明出处：http://blog.csdn.net/andrexpert/article/details/53331836

 

最后的话：“实际上，Android的权限系统中涵盖了两类权限：PROTECTION_NORMAL、非PROTECTION_NORMAL。其中，PROTECTION_NORML类权限在AndroidManifest.xml中声明后，在APP安装时，系统将无需检查权限而直接授予，且用户不可取消，如蓝牙、网络、闪光灯、NFC、WIFI等等；非PROTECTION_NORMAL类权限在AndroidManifest.xml中声明，在安装APP时，系统将会询问APP每次请求的权限，用户可取消此类权限。系统有时候不会弹出权限授权对话框，需要APP主动检查有没有该类权限，并弹出授权提示对话框，我们处理的就是这类权限。另外，Android权限系统是以组的形式管理权限，比如发送短信、接收短信同属一组权限，一旦其他一个获得授予，其他同组组员都得到了授权。”

 

关于资料与Demo：Android6.0新权限系统Demo