Android 6.0动态权限及跳转GPS设置界面的方法

1
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//动态申请权限的测试方法
public void test() {
 // 要申请的权限 数组 可以同时申请多个权限
 String[] permissions = {Manifest.permission.ACCESS_COARSE_LOCATION};

 if (Build.VERSION.SDK_INT >= 23) {
  //如果超过6.0才需要动态权限，否则不需要动态权限
  //如果同时申请多个权限，可以for循环遍历
  int check = ContextCompat.checkSelfPermission(this,permissions[0]);
  // 权限是否已经 授权 GRANTED---授权 DINIED---拒绝
  if (check == PackageManager.PERMISSION_GRANTED) {
   //写入你需要权限才能使用的方法
   run();
  } else {
   //手动去请求用户打开权限(可以在数组中添加多个权限) 1 为请求码 一般设置为final静态变量
   requestPermissions(new String[]{Manifest.permission.ACCESS_COARSE_LOCATION}, 1);
  }
 } else {
  //写入你需要权限才能使用的方法
  run();
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
          @NonNull int[] grantResults) {
 super.onRequestPermissionsResult(requestCode, permissions, grantResults);
 //回调，判断用户到底点击是还是否。
 //如果同时申请多个权限，可以for循环遍历
 if (requestCode == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  //写入你需要权限才能使用的方法
  run();
 } else {
  // 没有获取 到权限，从新请求，或者关闭app
  Toast.makeText(this,"需要获得XXX权限",Toast.LENGTH_SHORT).show();
 }
}

1
2
3
4
5
<string name="notifyTitle">提示</string>
<string name="notifyMsg">当前应用缺少必要权限。nn请点击"设置"-"权限"-打开所需权限。</string>
<string name="gpsNotifyMsg">当前应用需要打开定位功能。nn请点击"设置"-"定位服务"-打开定位功能。</string>
<string name="setting">设置</string>
<string name="cancel">取消</string>

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
private int GPS_REQUEST_CODE = 10;

/**
 * 检测GPS是否打开
 *
 * @return
 */
private boolean checkGPSIsOpen() {
 boolean isOpen;
 LocationManager locationManager = (LocationManager) this
   .getSystemService(Context.LOCATION_SERVICE);
 isOpen = locationManager.isProviderEnabled(android.location.LocationManager.GPS_PROVIDER);
 return isOpen;
}

/**
 * 跳转GPS设置
 */
private void openGPSSettings() {
 if (checkGPSIsOpen()) {
  initLocation(); //自己写的定位方法
 } else {
  //没有打开则弹出对话框
  new AlertDialog.Builder(this)
    .setTitle(R.string.notifyTitle)
    .setMessage(R.string.gpsNotifyMsg)
    // 拒绝, 退出应用
    .setNegativeButton(R.string.cancel,
      new DialogInterface.OnClickListener() {
       @Override
       public void onClick(DialogInterface dialog, int which) {
        finish();
       }
      })

    .setPositiveButton(R.string.setting,
      new DialogInterface.OnClickListener() {
       @Override
       public void onClick(DialogInterface dialog, int which) {
        //跳转GPS设置界面
        Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
        startActivityForResult(intent, GPS_REQUEST_CODE);
       }
      })

    .setCancelable(false)
    .show();

 }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 super.onActivityResult(requestCode, resultCode, data);
 if (requestCode == GPS_REQUEST_CODE) {
  //做需要做的事情，比如再次检测是否打开GPS了 或者定位
  openGPSSettings();
 }
}

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
public class CheckPermissionsActivity extends Activity implements
  ActivityCompat.OnRequestPermissionsResultCallback {
 /**
  * 需要进行检测的权限数组
  */
 protected String[] needPermissions = {
   Manifest.permission.ACCESS_COARSE_LOCATION,
   Manifest.permission.ACCESS_FINE_LOCATION,
   Manifest.permission.WRITE_EXTERNAL_STORAGE,
   Manifest.permission.READ_EXTERNAL_STORAGE,
   Manifest.permission.READ_PHONE_STATE
 };

 private static final int PERMISSON_REQUESTCODE = 0;
 private static final int SETTING_REQUESTCODE = 1;

 /**
  * 判断是否需要检测，防止不停的弹框
  */
 private boolean isNeedCheck = true;

 @Override
 protected void onResume() {
  super.onResume();
  if (isNeedCheck) {
   checkPermissions(needPermissions);
  }
 }

 /**
  * @param permissions
  * @since 2.5.0
  */
 private void checkPermissions(String... permissions) {
  List<String> needRequestPermissonList = findDeniedPermissions(permissions);
  if (null != needRequestPermissonList
    && needRequestPermissonList.size() > 0) {
   ActivityCompat.requestPermissions(this,
     needRequestPermissonList.toArray(
       new String[needRequestPermissonList.size()]),
     PERMISSON_REQUESTCODE);
  }
 }

 /**
  * 获取权限集中需要申请权限的列表
  *
  * @param permissions
  * @return
  * @since 2.5.0
  */
 private List<String> findDeniedPermissions(String[] permissions) {
  List<String> needRequestPermissonList = new ArrayList<String>();
  for (String perm : permissions) {
   if (ContextCompat.checkSelfPermission(this,
     perm) != PackageManager.PERMISSION_GRANTED
     || ActivityCompat.shouldShowRequestPermissionRationale(
     this, perm)) {
    needRequestPermissonList.add(perm);
   }
  }
  return needRequestPermissonList;
 }

 /**
  * 检测是否说有的权限都已经授权
  *
  * @param grantResults
  * @return
  * @since 2.5.0
  */
 private boolean verifyPermissions(int[] grantResults) {
  for (int result : grantResults) {
   if (result != PackageManager.PERMISSION_GRANTED) {
    return false;
   }
  }
  return true;
 }

 @Override
 public void onRequestPermissionsResult(int requestCode,
           String[] permissions, int[] paramArrayOfInt) {
  if (requestCode == PERMISSON_REQUESTCODE) {
   if (!verifyPermissions(paramArrayOfInt)) {
    showMissingPermissionDialog();
    isNeedCheck = false;
   }
  }
 }

 /**
  * 显示提示信息
  *
  * @since 2.5.0
  */
 private void showMissingPermissionDialog() {
  AlertDialog.Builder builder = new AlertDialog.Builder(this);
  builder.setTitle(R.string.notifyTitle);
  builder.setMessage(R.string.notifyMsg);

  // 拒绝, 退出应用
  builder.setNegativeButton(R.string.cancel,
    new DialogInterface.OnClickListener() {
     @Override
     public void onClick(DialogInterface dialog, int which) {
      finish();
     }
    });

  builder.setPositiveButton(R.string.setting,
    new DialogInterface.OnClickListener() {
     @Override
     public void onClick(DialogInterface dialog, int which) {
      startAppSettings();
     }
    });

  builder.setCancelable(false);

  builder.show();
 }

 /**
  * 启动应用的设置
  *
  * @since 2.5.0
  */
 private void startAppSettings() {
  Intent intent = new Intent(
    Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
  intent.setData(Uri.parse("package:" + getPackageName()));
  startActivityForResult(intent, SETTING_REQUESTCODE);
 }

 @Override
 public boolean onKeyDown(int keyCode, KeyEvent event) {
  if (keyCode == KeyEvent.KEYCODE_BACK) {
   this.finish();
   return true;
  }
  return super.onKeyDown(keyCode, event);
 }

 @Override
 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode == SETTING_REQUESTCODE) {
   checkPermissions(needPermissions);
  }
 }
}