shouldShowRequestPermissionRationale和requestPermissions有什么区别? [英] What is the difference between shouldShowRequestPermissionRationale and requestPermissions?
问题描述
我正在构建需要用户位置的应用程序.我正在此处中查看Android培训文档，该文档说:
I am building an app that requires user location. I am following the Android training documentation from here which says:
shouldShowRequestPermissionRationale返回一个布尔值，该布尔值指示我们是否应显示具有请求权限(危险权限，ACCESS_FINE_LOCATION)的UI
shouldShowRequestPermissionRationalereturn the boolean indicating whether or not we should show UI with rationale for requesting a permission (dangerous permission, ACCESS_FINE_LOCATION)
现在在此代码中(取自文档本身):
Now in this code (taken from the documentation itself) :
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 explanation 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.
}
}
[MY DOUBT]不应该将这部分代码(如下)
[MY DOUBT] Shouldn't this part of code (below)
ActivityCompat.requestPermissions(thisActivity,
new String[]{Manifest.permission.READ_CONTACTS},
MY_PERMISSIONS_REQUEST_READ_CONTACTS);
在这里处于'if'条件内.
be inside the 'if' condition here..
if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
Manifest.permission.READ_CONTACTS)) {
//HERE .....
}
我的意思是，如果
ActivityCompat.shouldShowRequestPermissionRationale(thisActivity, Manifest.permission.READ_CONTACTS)
是正确的，那么我们需要显示UI并通过
is true, then we need to show the UI and we will show the UI by
ActivityCompat.requestPermissions(thisActivity,
newString[{Manifest.permission.READ_CONTACTS}, MY_PERMISSIONS_REQUEST_READ_CONTACTS);
请解释我在哪里弄错了.我被困在这里.提前致谢. 一个例子将不胜感激.
Please explain where I am mistaken. I am stuck here. Thanks in advance. An example would be much appreciated.
注意:当然，我正在Android M上运行我的应用程序，目标sdk是> = 23.
Note: Of course, I am running my app on Android M, and my target sdk is >=23.
推荐答案
根据文档，
shouldShowRequestPermissionRationale返回一个布尔值，指示我们是否应该显示具有请求权限的UI.
shouldShowRequestPermissionRationalereturn the boolean indicating whether >or not we should show UI with rationale for requesting a permission.
此用户界面是我们的自定义用户界面(例如，我们可以显示警报对话框)，而不是设备显示的对话框(如下所示):
This UI is our custom UI (we can show an alertdialog, for example), NOT the dialog that our device shows (see below):
Allow SnazzyApp to access your contacts ? //this is NOT our custom UI
现在记住这一点
shouldShowRequestPermissionRationale的返回值如流程图所示.
The return value of shouldShowRequestPermissionRationale is as shown in flowchart.
还请注意，
When that user "denies" your permission by CHECKING "never ask again", ``shouldShowRequestPermissionRationale`` would still return ``false``.
因此，总结
-
shouldShowRequestPermissionRationale仅在应用程序较早启动并且用户拒绝"许可权而不检查不再询问"的情况下才返回true. - 在其他情况下(应用程序首次启动，或者应用程序也较早启动，并且用户通过选中不再询问"来拒绝许可)，返回值为false.
shouldShowRequestPermissionRationalewill return true only if the application was launched earlier and the user "denied" the permission WITHOUT checking "never ask again".- In other cases (app launched first time, or the app launched earlier too and the user denied permission by checking "never ask again"), the return value is false.
实施
让我们创建一个PermissionUtils.java文件，为我们处理不同的情况.
Let's create a PermissionUtils.java file which handles the different cases for us.
public class PermissionUtils {
private static final String TAG = "PermissionUtils";
/*
Inside this shared_preference file, we will just store information
about whether the user had visited our app earlier or not.
*/
private static final String PREFS_FILE_NAME = "preference_permission";
private static final String PREFS_FIRST_TIME_KEY = "is_app_launched_first_time";
//an interface containing 5 methods
//...the scenario in which these callback will be called is written below each method declaration.
public interface PermissionAskListener {
void onPermissionGranted();
/*
User has already granted this permission
The app must had been launched earlier and the user must had "allowed" that permission
*/
void onPermissionRequest();
/*
The app is launched FIRST TIME..
We don't need to show additional dialog, we just request for the permission..
*/
void onPermissionPreviouslyDenied();
/*
The app was launched earlier and the user simply "denied" the permission..
The user had NOT clicked "DO NOT SHOW AGAIN"
We need to show additional dialog in this case explaining how "allowing this permission" would be useful to the user
*/
void onPermissionDisabled();
/*
The app had launched earlier and the user "denied" the permission..
AND ALSO had clicked "DO NOT ASK AGAIN"
We need to show Toask/alertdialog/.. to indicate that the user had denied the permission by checking do not disturb too...
So, you might want to take the user to setting>app>permission page where the user can allow the permission..
*/
}
// preference utility methods
private static boolean getApplicationLaunchedFirstTime(Activity activity) {
SharedPreferences sharedPreferences = activity.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE);
return sharedPreferences.getBoolean(PREFS_FIRST_TIME_KEY, true);
}
private static void setApplicationLaunchedFirstTime(Activity activity) {
SharedPreferences sharedPreferences = activity.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putBoolean(PREFS_FIRST_TIME_KEY, false);
editor.commit();
}
private static boolean isRuntimePermissionRequired() {
return (Build.VERSION.SDK_INT >= 23);
}
public static void checkPermission(Activity activity, String permission, PermissionAskListener permissionAskListener) {
Log.d(TAG, "checkPermission");
if (!isRuntimePermissionRequired()) {
/*
Runtime permission not required,
THE DEVICE IS RUNNING ON < 23, So, no runtime permission required..
Simply call **** permissionAskListener.onPermissionGranted() ****
*/
permissionAskListener.onPermissionGranted();
} else {
//runtime permission required here...
//check if the permission is already granted, i.e the application was launched earlier too, and the user had "allowed" the permission then.
if (ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED) {
/* We don't have permission, two cases arise:
1. App launched first time,
2. App launched earlier too, and the user had denied the permission is last launch
2A. The user denied permission earlier WITHOUT checking "Never ask again"
2B. The user denied permission earlier WITH checking "Never ask again"
*/
if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
/*
shouldShowRequestPermissionRationale returned true
this means Case: 2A
see the flowchart, the only case when shouldShowRequestPermissionRationale returns "true", is when the application was launched earlier too and the user had "denied" the permission in last launch WITHOUT checking "never show again"
*/
permissionAskListener.onPermissionPreviouslyDenied();
} else {
/*
this means, either -
Case: 1 or Case 2B
See Flowchart, shouldShowRequestPermissionRationale returns false, only when app is launched first time (Case: 1) or app was launched earlier too and user HAD checked "Never show again" then (Case: 2B)
*/
if (getApplicationLaunchedFirstTime(activity)) {
//Case: 1
Log.d(TAG, "ApplicationLaunchedFirstTime");
setApplicationLaunchedFirstTime(activity); // ** DON'T FORGET THIS **
permissionAskListener.onPermissionRequest();
} else {
//Case: 2B
Log.d(TAG, "onPermissionDisabled");
permissionAskListener.onPermissionDisabled();
}
}
} else {
Log.d(TAG, "Permission already granted");
permissionAskListener.onPermissionGranted();
}
}
}
}
逻辑
-
我们首先要检查我们是否甚至首先需要运行时权限?这是通过:
We first begin by checking do we even require runtime permission in the first place ? This is done by :
if (!isRuntimePermissionRequired()) {...}
如果确实需要运行时权限，那么我们将检查
If we do require runtime permission, then we check if we had got that permission already earlier by
ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED)
如果没有权限，则需要处理以下两种情况:
If we don't have the permission, then we need to handle two cases which are:
1. App launched first time,
2. App launched earlier too, and the user had denied the permission is last launch
2A. The user denied permission earlier WITHOUT checking "Never ask again".
2B. The user denied permission earlier WITH checking "Never ask again".
因此，底线是:
在我们的
PermissionUtils.java中，我们定义了一个包含5个抽象方法的接口.这些方法是回调，将在上面讨论的不同情况下调用.
Inside our
PermissionUtils.java, we have an defined an interface which contains 5 abstract methods. These methods are the callbacks which will be called in different cases as discussed above.
最后，在我们的活动中，我们通过实现侦听器的回调来处理所有这些情况.
Finally inside our activity, we handle all these cases by implementing the callbacks of the listener.
PermissionUtils.checkPermission(MainActivity.this,
Manifest.permission.ACCESS_FINE_LOCATION,
new PermissionUtils.PermissionAskListener() {
@Override
public void onPermissionGranted() {
updateUI();
}
@Override
public void onPermissionRequest() {
ActivityCompat.requestPermissions(MainActivity.this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
My_PERMISSION_ACCESS_FINE_LOCATION);
}
@Override
public void onPermissionPreviouslyDenied() {
//Show an alert message and "request the permission" in its "setPositiveButton"
//...and in "setOnNegativeButton", just cancel the dialog and do not run the
//...functionality that requires this permission (here, ACCESS_FINE_LOCATION)
new AlertDialog.Builder(MainActivity.this)
.setTitle("Permission required")
.setMessage("Location is required for this application to work ! ")
.setPositiveButton("Allow", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
ActivityCompat.requestPermissions(MainActivity.this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
My_PERMISSION_ACCESS_FINE_LOCATION);
}
})
.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
finish();
}
})
.show();
}
@Override
public void onPermissionDisabled() {
new AlertDialog.Builder(MainActivity.this)
.setTitle("Permission Disabled")
.setMessage("Please enable the permission in \n Settings>Uber>Permission \n and check 'location' permission")
.setPositiveButton("Go to settings", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
startActivity(new Intent(Settings.ACTION_SETTINGS));
}
})
.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
finish();
}
})
.show();
}
});
}
希望这会有所帮助.
这篇关于shouldShowRequestPermissionRationale和requestPermissions有什么区别?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
