Android 6.0 之前我们申请权限直接在配置文件中配置一下即可,但是6.0之后,谷歌官方将权限分为普通权限和危险权限。对于危险权限来说,我们就需要进行动态设置了。本文主要讲解为什么要进行Android 6.0 动态权限的设置、动态权限的使用、以及一个页面中需要同时申请多个危险权限的情况。非常感谢郭霖大牛的讲解,把平时不太注意的点都讲得很不错。最后,我们采用相对优雅的方式对其进行封装,方便使用。
因为对于危险权限我们需要动态设置,不然应用会崩溃的,首先我们要清楚哪些是危险权限?看下面这张图
值得一说的是:同一组的权限不用重复授权,也就是说,同一组的权限只要有一个授权了,那么同一组的其它权限也都就授权了。
当你的应用中用到上面这些权限时,你就需要动态设置了。首先,你需要像以前一样把用到的权限依旧在配置文件中配置一下,然后,在你需要该权限的地方开撸代码进行动态设置了。下面以打电话为例来加以说明
首先,我们需要保证我们得有一台6.0的手机,targetSdkVersion的版本在23或者以上。其中需要注意一点,当我们的应用是升上来的时候,也就是说之前是23以下,现在我们让targetSdkVersion等于23或者以上时,即使不去动态设置这些危险权限,应用依旧不会崩溃掉,对于这种情况,谷歌会默认将所用到的这些危险权限自动授权。也就是说已经授权了,应用肯定不会崩溃啊。
单个权限的处理
按照上面分析的,我们先来一步步实现。首先我们在配置文件中配置打电话的权限
<uses-permission android:name="android.permission.CALL_PHONE"/>
- 1
- 1
MainActivity
public class MainActivity extends AppCompatActivity {
private Button btn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//初始化控件
iniViews();
}
private void iniViews() {
btn = (Button) findViewById(R.id.btn_call);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
call();
}
});
}
private void call(){
try {
Intent intent = new Intent(Intent.ACTION_CALL);
Uri uri = Uri.parse("tel:" + "10086");
intent.setData(uri);
startActivity(intent);
}catch (SecurityException e){
e.printStackTrace();
}
}
}
- 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
- 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
点击打电话,尴尬的情况发生了…
接下来就是去动态设置了,在文章最开始展示的那张危险权限表中可以知道,打电话属于危险权限。所以,我们在打电话时,先要判断用户是否授权了打电话功能,如果授权了,则继续打电话的逻辑,用户如果没有授权,会弹出一个对话框。用户可以根据对话框上面提示的 同意 / 拒绝 来设置权限,用户的这一操作我们可以通过回调在onRequestPermissionsResult()方法中获悉。为了达到向下兼容,我们使用v4兼容库下面的ContextCompat以及ActivityCompat。这样就可以兼容了,我们就不用代码判断版本了。
我们再来看看修改之后的代码
public class MainActivity extends AppCompatActivity {
private Button btn;
private static final int PERMISSION_REQUESTCODE = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//初始化控件
iniViews();
}
private void iniViews() {
btn = (Button) findViewById(R.id.btn_call);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
permission();
}
});
}
private void permission(){
if(ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED){
//没有授权
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, PERMISSION_REQUESTCODE);
}else{
//已经授权
call();
}
}
public void call(){
try {
Intent intent = new Intent(Intent.ACTION_CALL);
Uri uri = Uri.parse("tel:" + "10086");
intent.setData(uri);
startActivity(intent);
}catch (SecurityException e){
e.printStackTrace();
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode){
case PERMISSION_REQUESTCODE:
if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){
//用户点击了同意授权
call();
}else{
//用户拒绝了授权
Toast.makeText(this,"权限被拒绝",Toast.LENGTH_SHORT).show();
}
break;
default:
break;
}
}
}
- 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
- 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
代码比较简单,再来看看效果图
细心的你肯定会发现,当我们首次选择了拒绝后,再次点击打电话会出现不再询问选项,如果勾选了此选项,再点击拒绝的话,那么当我们再次执行打电话时,就不会再出现提示的弹窗了。显然这样对用户来说体验并不是很友好,你可以在用户点击拒绝后进行弹窗引导用户去设置中打开此权限等。具体的需求具体对待。这里我们稍微修改下代码,实现刚才所说的效果
private void permission(){
if(ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED){
if(ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE)){
//当拒绝了授权后,为提升用户体验,可以以弹窗的方式引导用户到设置中去进行设置
new AlertDialog.Builder(MainActivity.this)
.setMessage("需要开启权限才能使用此功能")
.setPositiveButton("设置", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
//引导用户到设置中去进行设置
Intent intent = new Intent();
intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
intent.setData(Uri.fromParts("package", getPackageName(), null));
startActivity(intent);
}
})
.setNegativeButton("取消", null)
.create()
.show();
}else{
//没有授权
ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, PERMISSION_REQUESTCODE);
}
}else{
//已经授权
call();
}
}
- 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
- 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
效果图
接下来我们来处理多个权限的情况
多个权限的处理
比较优雅的写法是,我们创建一个List集合,用于存放用户没有授权的权限。当我们拒绝其中的某一个权限时,再次点击申请时,弹出的对话框中只会出现被用户拒绝的权限申请,用户已经授权过的则不再显示。看下代码
public class MainActivity extends AppCompatActivity {
private Button btn;
private static final int PERMISSION_REQUESTCODE = 1;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//初始化控件
iniViews();
}
private void iniViews() {
btn = (Button) findViewById(R.id.btn_call);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
permission();
}
});
}
private void permission(){
List<String> permissionLists = new ArrayList<>();
if(ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED){
permissionLists.add(Manifest.permission.CALL_PHONE);
}
if(ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED){
permissionLists.add(Manifest.permission.CAMERA);
}
if(!permissionLists.isEmpty()){//说明肯定有拒绝的权限
ActivityCompat.requestPermissions(this, permissionLists.toArray(new String[permissionLists.size()]), PERMISSION_REQUESTCODE);
}else{
Toast.makeText(this, "权限都授权了,可以搞事情了", Toast.LENGTH_SHORT).show();
}
}
public void call(){
try {
Intent intent = new Intent(Intent.ACTION_CALL);
Uri uri = Uri.parse("tel:" + "10086");
intent.setData(uri);
startActivity(intent);
}catch (SecurityException e){
e.printStackTrace();
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode){
case PERMISSION_REQUESTCODE:
if(grantResults.length > 0){
for(int grantResult : grantResults){
if(grantResult != PackageManager.PERMISSION_GRANTED){
Toast.makeText(this, "某一个权限被拒绝了", Toast.LENGTH_SHORT).show();
return;
}
}
//其他逻辑(这里当权限都同意的话就执行打电话逻辑)
call();
}
break;
default:
break;
}
}
}
- 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
- 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
来张效果图
接下来,我们开始对其进行封装处理
对权限进行封装,让使用变得更加简洁
假如,我们有好几个页面都需要动态申请权限,那么我们岂不是要每个页面都写这些类似的代码。显然,我们可以将这些相似代码抽出来封装到我们的BaseActivity中。这样,使用起来就清爽多了
下面直接给出BaseActivity中的代码
/**
* 封装动态权限
*/
public class BaseActivity extends AppCompatActivity{
private PermissionListener mListener;
private static final int PERMISSION_REQUESTCODE = 100;
@Override
public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onCreate(savedInstanceState, persistentState);
}
public void requestRunPermisssion(String[] permissions, PermissionListener listener){
mListener = listener;
List<String> permissionLists = new ArrayList<>();
for(String permission : permissions){
if(ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED){
permissionLists.add(permission);
}
}
if(!permissionLists.isEmpty()){
ActivityCompat.requestPermissions(this, permissionLists.toArray(new String[permissionLists.size()]), PERMISSION_REQUESTCODE);
}else{
//表示全都授权了
mListener.onGranted();
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode){
case PERMISSION_REQUESTCODE:
if(grantResults.length > 0){
//存放没授权的权限
List<String> deniedPermissions = new ArrayList<>();
for(int i = 0; i < grantResults.length; i++){
int grantResult = grantResults[i];
String permission = permissions[i];
if(grantResult != PackageManager.PERMISSION_GRANTED){
deniedPermissions.add(permission);
}
}
if(deniedPermissions.isEmpty()){
//说明都授权了
mListener.onGranted();
}else{
mListener.onDenied(deniedPermissions);
}
}
break;
default:
break;
}
}
}
- 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
- 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
我们定义的处理已授权、以及未授权的回调接口
/**
* 已授权、未授权的接口回调
*/
public interface PermissionListener {
void onGranted();//已授权
void onDenied(List<String> deniedPermission);//未授权
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
再看看我们的MainActivity是如何调用的。只需要继承我们的BaseActivity即可
public class MainActivity extends BaseActivity {
private Button btn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//初始化控件
iniViews();
}
private void iniViews() {
btn = (Button) findViewById(R.id.btn_call);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
permission();
}
});
}
private void permission(){
requestRunPermisssion(new String[]{Manifest.permission.CALL_PHONE, Manifest.permission.CAMERA}, new PermissionListener() {
@Override
public void onGranted() {
//表示所有权限都授权了
Toast.makeText(MainActivity.this, "所有权限都授权了,可以搞事情了", Toast.LENGTH_SHORT).show();
//我们可以执行打电话的逻辑
call();
}
@Override
public void onDenied(List<String> deniedPermission) {
for(String permission : deniedPermission){
Toast.makeText(MainActivity.this, "被拒绝的权限:" + permission, Toast.LENGTH_SHORT).show();
}
}
});
}
public void call(){
try {
Intent intent = new Intent(Intent.ACTION_CALL);
Uri uri = Uri.parse("tel:" + "10086");
intent.setData(uri);
startActivity(intent);
}catch (SecurityException e){
e.printStackTrace();
}
}
}
- 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
- 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
最后再来张效果图
上面的封装是针对Activity页面的,如果我们想在其他类中也是用此权限封装的方法,我们可以这么干,修改BaseActivity中的代码
public class BaseActivity extends AppCompatActivity{
private static PermissionListener mListener;
private static final int PERMISSION_REQUESTCODE = 100;
@Override
public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onCreate(savedInstanceState, persistentState);
ActivityUtil.addActivity(this);
}
@Override
protected void onDestroy() {
super.onDestroy();
ActivityUtil.removeActivity(this);
}
public static void requestRunPermisssion(String[] permissions, PermissionListener listener){
Activity topActivity = ActivityUtil.getTopActivity();
if(topActivity == null){
return;
}
mListener = listener;
List<String> permissionLists = new ArrayList<>();
for(String permission : permissions){
if(ContextCompat.checkSelfPermission(topActivity, permission) != PackageManager.PERMISSION_GRANTED){
permissionLists.add(permission);
}
}
if(!permissionLists.isEmpty()){
ActivityCompat.requestPermissions(topActivity, permissionLists.toArray(new String[permissionLists.size()]), PERMISSION_REQUESTCODE);
}else{
//表示全都授权了
mListener.onGranted();
}
}
- 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
- 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
Activity的管理工具类
/**
* 管理Activity的工具类
*/
public class ActivityUtil {
private static List<Activity> activityList = new ArrayList<>();
public static void addActivity(Activity activity){
activityList.add(activity);
}
public static void removeActivity(Activity activity){
activityList.remove(activity);
}
public static Activity getTopActivity(){
if(activityList.isEmpty()){
return null;
}else{
return activityList.get(activityList.size() - 1);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
在其他类中调用的话直接通过BaseActivity.requestRunPermisssion()即可。然而这种方式下,如果activity被意外销毁了,就会导致内存溢出等问题。如果想避免这种问题,我们可以使用上面的介绍,只在activity页面中使用即可。如果既想能在其他类中使用,又想尽量没有别的错误,我们可以到github上找一些写的不错的第三方框架。用起来也十分方便
最后非常感谢郭霖大神,郭大牛还推荐了一个比较不错的管理权限的第三方框架RxPermissions,另外还有PermissionsDispatcher