Android M Permissions: запутался при использовании функции shouldShowRequestPermissionRationale()
Я просматривал официальный документ о новой модели разрешений в Android M. Он говорит о shouldShowRequestPermissionRationale() функция, которая возвращает true если приложение запросило это разрешение ранее, а пользователь отклонил запрос. Если пользователь отклонил запрос на разрешение в прошлом и выбрал опцию "Больше не спрашивать", этот метод возвращает false,
Но как мы можем различить следующие два случая?
Случай 1: приложение не имеет разрешения, и пользователь не запрашивал разрешение раньше. В этом случае shouldShowRequestPermissionRationale() вернет false, потому что это первый раз, когда мы спрашиваем пользователя.
Случай 2: пользователь отказал в разрешении и выбрал "Больше не спрашивать", в этом случае также shouldShowRequestPermissionRationale() вернет false.
Я хотел бы отправить пользователя на страницу настроек приложения в случае 2. Как мне провести различие между этими двумя случаями?
14 ответов
После M Preview 1, если диалоговое окно отображается впервые, флажок " Никогда не спрашивать" отсутствует.
Если пользователь отклоняет запрос на разрешение, во втором запросе разрешения будет установлен флажок " Никогда не спрашивать снова".
Итак, логика должна быть такой:
Просить разрешение:
if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(context, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_CODE); } else { //Do the stuff that requires permission... }Проверьте, было ли разрешение отклонено или предоставлено в
onRequestPermissionsResult,Если ранее было отказано в разрешении, на этот раз в диалоге разрешений будет установлен флажок Никогда не спрашивать.
Вызов
shouldShowRequestPermissionRationaleчтобы увидеть, проверял ли пользователь Никогда больше не спрашивать.shouldShowRequestPermissionRationaleМетод возвращает false только в том случае, если пользователь выбрал " Никогда больше не спрашивать" или политика устройства запрещает приложению иметь такое разрешение:if (grantResults.length > 0){ if(grantResults[0] == PackageManager.PERMISSION_GRANTED) { //Do the stuff that requires permission... }else if (grantResults[0] == PackageManager.PERMISSION_DENIED){ // Should we show an explanation? if (ActivityCompat.shouldShowRequestPermissionRationale(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)) { //Show permission explanation dialog... }else{ //Never ask again selected, or device policy prohibits the app from having that permission. //So, disable that feature, or fall back to another situation... } } }
Таким образом, вам не придется отслеживать, если пользователь установил флажок Никогда не спрашивать или нет.
У меня была такая же проблема, и я понял это. Чтобы упростить жизнь, я написал класс util для обработки разрешений во время выполнения.
public class PermissionUtil {
/*
* Check if version is marshmallow and above.
* Used in deciding to ask runtime permission
* */
public static boolean shouldAskPermission() {
return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M);
}
private static boolean shouldAskPermission(Context context, String permission){
if (shouldAskPermission()) {
int permissionResult = ActivityCompat.checkSelfPermission(context, permission);
if (permissionResult != PackageManager.PERMISSION_GRANTED) {
return true;
}
}
return false;
}
public static void checkPermission(Context context, String permission, PermissionAskListener listener){
/*
* If permission is not granted
* */
if (shouldAskPermission(context, permission)){
/*
* If permission denied previously
* */
if (((Activity) context).shouldShowRequestPermissionRationale(permission)) {
listener.onPermissionPreviouslyDenied();
} else {
/*
* Permission denied or first time requested
* */
if (PreferencesUtil.isFirstTimeAskingPermission(context, permission)) {
PreferencesUtil.firstTimeAskingPermission(context, permission, false);
listener.onPermissionAsk();
} else {
/*
* Handle the feature without permission or ask user to manually allow permission
* */
listener.onPermissionDisabled();
}
}
} else {
listener.onPermissionGranted();
}
}
/*
* Callback on various cases on checking permission
*
* 1. Below M, runtime permission not needed. In that case onPermissionGranted() would be called.
* If permission is already granted, onPermissionGranted() would be called.
*
* 2. Above M, if the permission is being asked first time onPermissionAsk() would be called.
*
* 3. Above M, if the permission is previously asked but not granted, onPermissionPreviouslyDenied()
* would be called.
*
* 4. Above M, if the permission is disabled by device policy or the user checked "Never ask again"
* check box on previous request permission, onPermissionDisabled() would be called.
* */
public interface PermissionAskListener {
/*
* Callback to ask permission
* */
void onPermissionAsk();
/*
* Callback on permission denied
* */
void onPermissionPreviouslyDenied();
/*
* Callback on permission "Never show again" checked and denied
* */
void onPermissionDisabled();
/*
* Callback on permission granted
* */
void onPermissionGranted();
}
}
И методы PreferenceUtil заключаются в следующем.
public static void firstTimeAskingPermission(Context context, String permission, boolean isFirstTime){
SharedPreferences sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE;
sharedPreference.edit().putBoolean(permission, isFirstTime).apply();
}
public static boolean isFirstTimeAskingPermission(Context context, String permission){
return context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE).getBoolean(permission, true);
}
Теперь все, что вам нужно, это использовать метод checkPermission с правильными аргументами.
Вот пример,
PermissionUtil.checkPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE,
new PermissionUtil.PermissionAskListener() {
@Override
public void onPermissionAsk() {
ActivityCompat.requestPermissions(
thisActivity,
new String[]{Manifest.permission.READ_CONTACTS},
REQUEST_EXTERNAL_STORAGE
);
}
@Override
public void onPermissionPreviouslyDenied() {
//show a dialog explaining permission and then request permission
}
@Override
public void onPermissionDisabled() {
Toast.makeText(context, "Permission Disabled.", Toast.LENGTH_SHORT).show();
}
@Override
public void onPermissionGranted() {
readContacts();
}
});
Случай 1: приложение не имеет разрешения, и пользователь не запрашивал разрешение раньше. В этом случае shouldShowRequestPermissionRationale() вернет false, потому что это первый раз, когда мы спрашиваем пользователя.
Случай 2: пользователь отказал в разрешении и выбрал "Больше не спрашивать", в этом случае также shouldShowRequestPermissionRationale() вернет false.
Я хотел бы отправить пользователя на страницу настроек приложения в случае 2. Как мне провести различие между этими двумя случаями?
Вы получите обратный вызов onPermissionAsk для случая 1 и onPermissionDisabled для случая 2.
Удачного кодирования:)
Насколько я понимаю, shouldShowRequestPermissionRationale() запускает несколько вариантов использования под капотом и уведомляет приложение о том, показывать или нет объяснение запрашиваемых разрешений.
Идея, лежащая в основе разрешений времени выполнения, заключается в том, что большую часть времени пользователь будет отвечать "да" на запрос разрешения. Таким образом, пользователь должен будет сделать только один клик. Конечно, запрос должен быть использован в правильном контексте - то есть запрос разрешения камеры при нажатии кнопки "Камера".
Если пользователь отклоняет запрос, но через некоторое время приходит снова и снова нажимает кнопку "Камера", shouldShowRequestPermissionRationale() вернет значение true, поэтому приложение может показать некоторые содержательные объяснения, почему запрашивается разрешение, а почему нет. работать правильно без него. Обычно в этом диалоговом окне отображается кнопка, чтобы снова отказать / принять решение позже, и кнопка для предоставления разрешений. Кнопка предоставления разрешений в диалоговом окне обоснования должна снова запустить запрос на разрешение. На этот раз у пользователя также будет установлен флажок "Больше никогда не показывать". Если он решит выбрать его и снова отклонить разрешение, он уведомит систему Android о том, что пользователь и приложение не на одной странице. Это действие будет иметь два следствия - shouldShowRequestPermissionRationale() всегда будет возвращать false, а метод requestPermissions() не будет показывать никакого диалога, но будет напрямую возвращать отказано в обратный вызов onRequestPermissionsResult.
Но есть и другой возможный сценарий, в котором можно использовать onRequestPermissionsResult. Например, некоторые устройства могут иметь политику устройств, которая отключает камеру (работает для CIA, DARPA и т. Д.). На этих устройствах onRequestPermissionsResult всегда будет возвращать false, а метод requestPermissions() будет молча отклонять запрос.
Это то, что я собрал, слушая подкаст с Беном Поесом - менеджером по продукту на платформе Android.
http://androidbackstage.blogspot.jp/2015/08/episode-33-permission-mission.html
ОБНОВИТЬ
Я считаю, что ответ CanC ниже является правильным, которому следует следовать. Единственный способ узнать наверняка - это проверить это в обратном вызове onRequestPermissionResult с помощью shouldShowPermissionRationale.
==
Мой оригинальный ответ:
Единственный способ, который я нашел, - это самостоятельно отслеживать, является ли это впервые или нет (например, с помощью общих настроек). Если это не первый раз, используйте shouldShowRequestPermissionRationale() различать.
Просто опубликуйте другой вариант, если кому-то захочется. Вы можете использовать EasyPermissions, предоставленную самим Google, чтобы, как сказано, "упростить системные разрешения Android M".
Тогда вам не придется обращаться shouldShowRequestPermissionRationale непосредственно.
Если кто-то заинтересован в решении Kotlin, я реорганизовал ответ @muthuraj, чтобы быть в Kotlin. Также немного модернизировано, чтобы иметь блок завершения вместо слушателей.
PermissionUtil
object PermissionUtil {
private val PREFS_FILE_NAME = "preference"
fun firstTimeAskingPermission(context: Context, permission: String, isFirstTime: Boolean) {
val sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE)
sharedPreference.preferences.edit().putBoolean(permission,
isFirstTime).apply()
}
fun isFirstTimeAskingPermission(context: Context, permission: String): Boolean {
val sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE)
return sharedPreference.preferences.getBoolean(permission,
true)
}
}
PermissionHandler
enum class CheckPermissionResult {
PermissionAsk,
PermissionPreviouslyDenied,
PermissionDisabled,
PermissionGranted
}
typealias PermissionCheckCompletion = (CheckPermissionResult) -> Unit
object PermissionHandler {
private fun shouldAskPermission(context: Context, permission: String): Boolean {
return ContextCompat.checkSelfPermission(context,
permission) != PackageManager.PERMISSION_GRANTED
}
fun checkPermission(context: Context, permission: String, completion: PermissionCheckCompletion) {
// If permission is not granted
if (shouldAskPermission(context, permission)) {
//If permission denied previously
if ((context as Activity).shouldShowRequestPermissionRationale(permission)) {
completion(CheckPermissionResult.PermissionPreviouslyDenied)
} else {
// Permission denied or first time requested
if (PermissionUtil.isFirstTimeAskingPermission(context,
permission)) {
PermissionUtil.firstTimeAskingPermission(context,
permission,
false)
completion(CheckPermissionResult.PermissionAsk)
} else {
// Handle the feature without permission or ask user to manually allow permission
completion(CheckPermissionResult.PermissionDisabled)
}
}
} else {
completion(CheckPermissionResult.PermissionGranted)
}
}
}
Реализация
PermissionHandler.checkPermission(activity,
Manifest.permission.CAMERA) { result ->
when (result) {
CheckPermissionResult.PermissionGranted -> {
// openCamera()
}
CheckPermissionResult.PermissionDisabled -> {
// displayAlert(noPermissionAlert)
}
CheckPermissionResult.PermissionAsk -> {
// requestCameraPermissions()
}
CheckPermissionResult.PermissionPreviouslyDenied -> {
// displayAlert(permissionRequestAlert)
}
}
}
Мы можем сделать это таким образом?
@Retention(RetentionPolicy.SOURCE)
@IntDef({GRANTED, DENIED, NEVER})
public @interface PermissionStatus {
}
public static final int GRANTED = 0;
public static final int DENIED = 1;
public static final int NEVER = 2;
@PermissionStatus
public static int getPermissionStatus(Activity activity, String permission) {
if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
return DENIED;
} else {
if (ActivityCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED) {
return GRANTED;
} else {
return NEVER;
}
}
}
Проверьте эту реализацию. работает довольно хорошо для меня. в основном вы проверяете разрешения в методе checkPermissions(), передавая список разрешений. Вы проверяете результат запроса разрешения на onRequestPermissionsResult(). Реализация позволяет рассмотреть оба случая, когда пользователь выбирает "никогда не спрашивать" или нет. В этой реализации, если se выбирает "никогда больше не спрашивать", в диалоговом окне есть опция, позволяющая перейти к действию "Настройки приложения".
Весь этот код внутри моего фрагмента. Я думал, что было бы лучше создать специальный класс для этого, например, PermissionManager, но я не уверен в этом.
/**
* responsible for checking if permissions are granted. In case permissions are not granted, the user will be requested and the method returns false. In case we have all permissions, the method return true.
* The response of the request for the permissions is going to be handled in the onRequestPermissionsResult() method
* @param permissions list of permissions to be checked if are granted onRequestPermissionsResult().
* @param requestCode request code to identify this request in
* @return true case we already have all permissions. false in case we had to prompt the user for it.
*/
private boolean checkPermissions(List<String> permissions, int requestCode) {
List<String> permissionsNotGranted = new ArrayList<>();
for (String permission : permissions) {
if (ContextCompat.checkSelfPermission(getActivity(), permission) != PackageManager.PERMISSION_GRANTED)
permissionsNotGranted.add(permission);
}
//If there is any permission we don't have (it's going to be in permissionsNotGranted List) , we need to request.
if (!permissionsNotGranted.isEmpty()) {
requestPermissions(permissionsNotGranted.toArray(new String[permissionsNotGranted.size()]), requestCode);
return false;
}
return true;
}
/**
* called after permissions are requested to the user. This is called always, either
* has granted or not the permissions.
* @param requestCode int code used to identify the request made. Was passed as parameter in the
* requestPermissions() call.
* @param permissions Array containing the permissions asked to the user.
* @param grantResults Array containing the results of the permissions requested to the user.
*/
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
switch (requestCode) {
case YOUR_REQUEST_CODE: {
boolean anyPermissionDenied = false;
boolean neverAskAgainSelected = false;
// Check if any permission asked has been denied
for (int i = 0; i < grantResults.length; i++) {
if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
anyPermissionDenied = true;
//check if user select "never ask again" when denying any permission
if (!shouldShowRequestPermissionRationale(permissions[i])) {
neverAskAgainSelected = true;
}
}
}
if (!anyPermissionDenied) {
// All Permissions asked were granted! Yey!
// DO YOUR STUFF
} else {
// the user has just denied one or all of the permissions
// use this message to explain why he needs to grant these permissions in order to proceed
String message = "";
DialogInterface.OnClickListener listener = null;
if (neverAskAgainSelected) {
//This message is displayed after the user has checked never ask again checkbox.
message = getString(R.string.permission_denied_never_ask_again_dialog_message);
listener = new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
//this will be executed if User clicks OK button. This is gonna take the user to the App Settings
startAppSettingsConfigActivity();
}
};
} else {
//This message is displayed while the user hasn't checked never ask again checkbox.
message = getString(R.string.permission_denied_dialog_message);
}
new AlertDialog.Builder(getActivity(), R.style.AlertDialogTheme)
.setMessage(message)
.setPositiveButton(getString(R.string.label_Ok), listener)
.setNegativeButton(getString(R.string.label_cancel), null)
.create()
.show();
}
}
break;
default:
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
/**
* start the App Settings Activity so that the user can change
* settings related to the application such as permissions.
*/
private void startAppSettingsConfigActivity() {
final Intent i = new Intent();
i.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
i.addCategory(Intent.CATEGORY_DEFAULT);
i.setData(Uri.parse("package:" + getActivity().getPackageName()));
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
i.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
i.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
getActivity().startActivity(i);
}
Может быть кому-то пригодится: -
Что я заметил, так это то, что если мы проверяем флаг mustShowRequestPermissionRationale() в методе обратного вызова onRequestPermissionsResult(), он показывает только два состояния.
Состояние 1:-Возврат истины: - Каждый раз, когда пользователь нажимает кнопку "Запретить" (включая самый первый раз).
Состояние 2:- Возвращает false: - если пользователь выбирает "никогда больше не спрашивать".
Правильное использование shouldShowRequestPermissionRationale — это onRequestPermissionsResult .
Activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.appcompat.widget.LinearLayoutCompat
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity"
android:gravity="center">
<androidx.appcompat.widget.AppCompatButton
android:id="@+id/btn_camera"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Camera"
android:textAllCaps="false"
android:background="@color/purple_200"
android:layout_marginTop="20dp"
>
</androidx.appcompat.widget.AppCompatButton>
<androidx.appcompat.widget.AppCompatButton
android:id="@+id/btn_storage"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Storage"
android:textAllCaps="false"
android:background="@color/purple_200"
android:layout_marginTop="30dp"
>
</androidx.appcompat.widget.AppCompatButton>
</androidx.appcompat.widget.LinearLayoutCompat>
enter code here
MainActivity.kt
package com.example.myapplication
import android.Manifest
import android.content.pm.PackageManager
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.Toast
import androidx.appcompat.app.AlertDialog
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
class MainActivity : AppCompatActivity() {
private val TAG = "MainActivity"
lateinit var btnCamera: Button
private val cameraRequestCode = 100
lateinit var btnStorage: Button
private val storageRequestCode = 200
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btnCamera = findViewById(R.id.btn_camera)
btnStorage = findViewById(R.id.btn_storage)
btnCamera.setOnClickListener {
checkPermission(android.Manifest.permission.CAMERA, cameraRequestCode)
}
btnStorage.setOnClickListener {
checkPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE, storageRequestCode)
}
}
private fun checkPermission(permissionName: String, requestCode: Int) {
/**
* if the permission is given means it will give the permissionNumber = 0
* if the permission is not given means it will give the permissionNumber =-1
* It s same as we are checking for PackageManager.PERMISSION_DENIED =-1 & PackageManager.GRANTED=0
*/
val permissionNumber: Int =
ContextCompat.checkSelfPermission(this@MainActivity, permissionName)
if (permissionNumber == PackageManager.PERMISSION_GRANTED) {
} else if (permissionNumber == PackageManager.PERMISSION_DENIED) {
askpermission(permissionName, requestCode, permissionNumber)
}
}
private fun askpermission(permissionName: String, permissionCode: Int, permissionNumner: Int) {
ActivityCompat.requestPermissions(
this@MainActivity,
arrayOf(permissionName),
permissionCode
)
}
override fun onRequestPermissionsResult(
requestCode: Int,
permissions: Array<out String>,
grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
if (requestCode == cameraRequestCode) {
if (permissions.size > 0) {
if (permissions[0].toString().equals(Manifest.permission.CAMERA, ignoreCase = true)) {
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Toast.makeText(applicationContext,"Permission Granted",Toast.LENGTH_SHORT).show()
}else{
if (grantResults[0] == PackageManager.PERMISSION_DENIED) {
var permissionDeniedStatus= checkDeniedPermissionStatus(permissions[0]);
if(permissionDeniedStatus){
/**
* Permission Denied
*/
Toast.makeText(applicationContext,"Permission Denied",Toast.LENGTH_SHORT).show()
}else{
/**
* Permission Denied and Selected Don t ask again.
*/
showDialog("Permission Denied","Permission Denied Permanently\nOpen Setting to allow")
}
}
}
}
}
}else if (requestCode == storageRequestCode) {
if(permissions[0].toString().equals(Manifest.permission.READ_EXTERNAL_STORAGE, ignoreCase = true)){
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Toast.makeText(applicationContext,"Permission Granted",Toast.LENGTH_SHORT).show()
}
}else{
if (grantResults[0] == PackageManager.PERMISSION_DENIED) {
var permissionDeniedStatus= checkDeniedPermissionStatus(permissions[0]);
if(permissionDeniedStatus){
/**
* Permission Denied
*/
Toast.makeText(applicationContext,"Permission Denied",Toast.LENGTH_SHORT).show()
}else{
/**
* Permission Denied and Selected Don t ask again.
*/
showDialog("Permission Denied","Permission Denied Permanently\nOpen Setting to allow")
}
}
}
}
}
}
private fun checkDeniedPermissionStatus(permissionName: String) :Boolean{
val permissionDeniedStatus: Boolean = ActivityCompat.shouldShowRequestPermissionRationale(this@MainActivity, permissionName)
return permissionDeniedStatus
}
private fun showDialog(title: String, message: String) {
val builder = AlertDialog.Builder(this)
builder.setTitle(title)
builder.setMessage(message)
builder.setPositiveButton(android.R.string.yes) { dialog, which ->
}
builder.setNegativeButton(android.R.string.no) { dialog, which ->
}
builder.show()
}
}
public void requestPermission(View view){
if(ContextCompat.checkSelfPermission(this,Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED){
if(ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,Manifest.permission.ACCESS_FINE_LOCATION)){
//The Alert Dialog before asking for the second time to help the user understand why he needs to give permission.
AlertDialog alert = new AlertDialog.Builder(this).setMessage("Without the permissions you cannot run the application")
.setCancelable(false)
.setPositiveButton("Okay, I understand", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
ActivityCompat.requestPermissions(MainActivity.this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_FINE_LOCATION);
}
}).setNegativeButton("No, Exit the App", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
System.exit(2);
}
}).create();
alert.setTitle("ALERTY");
alert.show();
//End of the alert Dialog
}
else{
ActivityCompat.requestPermissions(MainActivity.this,
new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_FINE_LOCATION);
}
}
else {
textView.setText("Permission Is Already Granted");
}
}
/*
The shouldShowRequestPermissionRationale() function returns true if the app has requested this permission
previously and the user denied the request.If the user turned down the permission request in the past and chose
the Don't ask again option, this method returns false.
*/
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
if(requestCode == REQUEST_FINE_LOCATION) {
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
textView.setText("Hooray! on Request Permissions Grantred");
}
else{
//Since the user has choosen the don't ask again option,
if(!ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this, Manifest.permission.ACCESS_FINE_LOCATION)){
//Alert Dialog that will take user to settings where he can manually give the permissions
AlertDialog alert = new AlertDialog.Builder(this).setMessage("You have permanently disabled the permission ")
.setPositiveButton("Go to Settings", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
openSettings();
}
}).setNegativeButton("Don't Go",null).setCancelable(false).create();
alert.setTitle("Give permission manually");
alert.show();
// End of the Alert Dialog
}
else{
textView.setText("Permission has been denied the 1st time");
}
}
}
}
Это метод openSettings.
public void openSettings(){
Intent intent = new Intent();
Uri uri = Uri.fromParts("package",this.getPackageName(),null);
intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).setData(uri);
startActivity(intent);
}
shouldShowRequestPermissionRationale для СПЕЦИАЛЬНОГО разрешения всегда возвращайте значение ИСТИНА ТОЛЬКО после того, как пользователь отклонил его без флажка
Мы заинтересованы в ложном значении
Таким образом, есть 3 случая, потерянные с ложным значением:
1. ранее не было таких действий, и теперь пользователь решает согласиться или отказаться.
Просто определите предпочтение ASKED_PERMISSION_* который не существует сейчас и будет правдой в onRequestPermissionsResult на это начать в любом случае согласиться или отрицать
Так что, хотя это предпочтение не существует, нет причин для проверки shouldShowRequestPermissionRationale
2. пользователь нажал согласиться.
Просто сделайте:
checkCallingOrSelfPermission(permission) == PackageManager.PERMISSION_GRANTED
Который вернет истину и нет причин проверять shouldShowRequestPermissionRationale
3. пользователь нажал кнопку "Отклонить с флажком" (второй или более раз)
Это время работать с shouldShowRequestPermissionRationale который вернет ЛОЖЬ
(предпочтение существует, и у нас нет разрешения)
Google отклонил мое приложение, потому что я использовал один из ответов. Итак, вот моя версия:
import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.os.Build;
import androidx.core.app.ActivityCompat;
public class PermissionUtil {
static final String PREFS_NAME = "AppsPermissions";
private static boolean shouldAskPermission(Context context, String permission) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
int permissionResult = ActivityCompat.checkSelfPermission(context, permission);
if (permissionResult != PackageManager.PERMISSION_GRANTED) {
return true;
}
}
return false;
}
public static void checkPermission(Activity activity, String permission, PermissionAskListener listener) {
// If permission is not granted
if (shouldAskPermission(activity, permission)) {
// If permission denied previously without "Don't ask again"
if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
listener.onPermissionAsk();
} else {
SharedPreferences sharedPreference = activity.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
if (sharedPreference.getBoolean(permission, true)) {
// Permission first time requested.
sharedPreference.edit().putBoolean(permission, false).apply();
listener.onPermissionAsk();
}
else {
// Handle the feature without permission or ask user to manually allow permission
listener.onPermissionDenied();
}
}
}
else {
listener.onPermissionGranted();
}
}
/// Callback on checking permission.
public interface PermissionAskListener {
/// Callback to ask permission
void onPermissionAsk();
/// Callback on permission denied
void onPermissionDenied();
/// Callback on permission granted
void onPermissionGranted();
}
}
Этот код запрашивает у пользователя запрашивать разрешение во время выполнения, если пользователь разрешает, он выполняет метод результата, если пользователь отказывает, он запрашивает снова с описанием с отклонением пользователя (он запрашивает снова с инструкциями), но если пользователь выбирает, никогда не спрашивать снова. он обрабатывает никогда не спрашивать, отображать опцию открытых настроек с инструкциями.
public String storagePermissions = Manifest.permission.READ_EXTERNAL_STORAGE;
private static final int REQUEST_ACCESS =101;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
if(checkSelfPermission(storagePermissions)== PackageManager.PERMISSION_GRANTED){
result(); // result is your block of code
}else {
requestPermissions(new String[]{storagePermissions},REQUEST_ACCESS);
}
}
else{
result(); //so if user is lower than api verison M, no permission is requested
}
}
private void showMessageOKCancel(String message, DialogInterface.OnClickListener okListener) {
new AlertDialog.Builder(MainActivity.this)
.setMessage(message)
.setTitle("Hi User..")
.setPositiveButton("Ok", okListener)
.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) { //idea calling showMessage funtion again
Snackbar mySnackbar = Snackbar.make( findViewById(R.id.coordinatorlayout),"You Press Cancel.. ", Snackbar.LENGTH_INDEFINITE);
mySnackbar.setAction("Exit", new cancelButton());
mySnackbar.show();
}
})
.create()
.show();
}
private void result(){
//your code
}
@RequiresApi(api = Build.VERSION_CODES.M)
public class NeverAskAgain implements View.OnClickListener{
@Override
public void onClick(View view)
{
goToSettings();
}
}
@RequiresApi(api = Build.VERSION_CODES.M)
private void goToSettings() {
Intent myAppSettings = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:" + getPackageName()));
finish();
myAppSettings.addCategory(Intent.CATEGORY_DEFAULT);
myAppSettings.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivityForResult(myAppSettings, REQUEST_APP_SETTINGS);
}
public class cancelButton implements View.OnClickListener{
@Override
public void onClick(View view){
Toast.makeText(MainActivity.this,"To use this app , you must grant storage permission",Toast.LENGTH_SHORT);
finish();
}
}
@Override
@RequiresApi(api = Build.VERSION_CODES.M)
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode,permissions,grantResults);
switch(requestCode) {
case REQUEST_ACCESS:
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// permission is granted
result();
break;
}
else if (!shouldShowRequestPermissionRationale(permissions[0])){
showMessageOKCancel("You choose Never Ask Again,option",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Snackbar mySnackbar = Snackbar.make(findViewById(R.id.coordinatorlayout), "Permission=>Storage=>On", Snackbar.LENGTH_INDEFINITE);
mySnackbar.setAction("Settings", new NeverAskAgain());
mySnackbar.show();
}
});
break;
}
else {
showMessageOKCancel("You Denid permission Request..",
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
requestPermissions(new String[]{storagePermissions}, REQUEST_ACCESS);
}
});
break;
}
}
}