it-swarm.com.de

Android M-Berechtigungen: Verwirrt über die Verwendung der shouldShowRequestPermissionRationale () - Funktion

Ich habe das offizielle Dokument über das neue Permissionsmodell in Android M durchgearbeitet. Es spricht von der Funktion shouldShowRequestPermissionRationale(), die true zurückgibt, wenn die App diese Berechtigung zuvor angefordert hat und der Benutzer die Anforderung abgelehnt hat. Wenn der Benutzer die Berechtigungsanforderung in der Vergangenheit abgelehnt und die Option Nicht erneut fragen ausgewählt hat, gibt diese Methode false zurück. 

Aber wie können wir zwischen den beiden folgenden Fällen unterscheiden?

Fall 1: Die App hat keine Berechtigung und der Benutzer wurde zuvor nicht nach der Berechtigung gefragt. In diesem Fall sollte shouldShowRequestPermissionRationale () false zurückgeben, da wir den Benutzer zum ersten Mal fragen.

Fall 2: Der Benutzer hat die Erlaubnis verweigert und "Nicht mehr fragen" ausgewählt. In diesem Fall sollte auchShowRequestPermissionRationale () den Wert false zurückgeben. 

Ich möchte den Benutzer in Fall 2 zur Seite mit den Einstellungen der App senden. Wie gehe ich vor, um diese beiden Fälle zu unterscheiden?

120
akshayt23

Wenn nach M Preview 1 der Dialog zum ersten Mal angezeigt wird zum ersten Mal , gibt es kein Kontrollkästchen Nie erneut fragen.

Wenn der Benutzer die Berechtigungsanforderung ablehnt, wird im Berechtigungsdialogfeld ein Kontrollkästchen Nie wieder fragen angezeigt Beim zweiten Mal wird die Berechtigung angefordert.

Die Logik sollte also so sein:

  1. Um Erlaubnis bitten:

    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...
    }
    
  2. Prüfen Sie, ob die Berechtigung in onRequestPermissionsResult abgelehnt oder erteilt wurde.

    Wenn die Berechtigung zuvor verweigert wurde, wird dieses Mal im Berechtigungsdialogfeld ein Kontrollkästchen Nie erneut fragen angezeigt. 

    Rufen Sie shouldShowRequestPermissionRationale auf, um zu sehen, ob der Benutzer Nie erneut gefragt hat. Die shouldShowRequestPermissionRationale-Methode gibt nur dann false zurück, wenn der Benutzer Nie erneut fragen ausgewählt hat oder die Geräterichtlinie der App die Berechtigung dazu verweigert:

    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...
            }
        }
    }
    

Sie müssen also nicht nachverfolgen, ob ein Benutzer Nie mehr gefragt ausgewählt hat oder nicht.

144
CanC

Ich hatte das gleiche Problem und habe es herausgefunden. Um das Leben viel einfacher zu machen, habe ich eine util-Klasse geschrieben, um Laufzeitberechtigungen zu handhaben.

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();
    }
}

Die PreferenceUtil -Methoden sind wie folgt.

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);
}

Jetzt brauchen Sie nur noch die Methode checkPermission mit den richtigen Argumenten zu verwenden.

Hier ist ein Beispiel,

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();
                        }
                    });

Fall 1: Die App hat keine Berechtigung und der Benutzer hat nicht bat um die Erlaubnis vorher. In diesem Fall, shouldShowRequestPermissionRationale () gibt false zurück, da dies ist das erste Mal, dass wir den Benutzer fragen.

Fall 2: Der Benutzer hat die Berechtigung abgelehnt und "Nicht erneut fragen Erneut" ausgewählt. In diesem Fall sollte auchShowRequestPermissionRationale () falsch zurückgeben.

Ich möchte den Benutzer an die Einstellungsseite der App in Fall 2 senden. Wie unterscheide ich diese beiden Fälle?

Sie erhalten einen Rückruf auf onPermissionAsk für Fall 1 und onPermissionDisabled für Fall 2.

Viel Spaß beim Codieren :)

20
muthuraj

AKTUALISIEREN

Ich glaube, dass CanCs answer below die richtige ist, die befolgt werden sollte. Der einzige Weg, um sicher zu gehen, besteht darin, dies im onRequestPermissionResult-Callback mit shouldShowPermissionRationale zu überprüfen. 

==

Meine ursprüngliche Antwort:

Die einzige Möglichkeit, die ich gefunden habe, ist, auf eigene Faust zu verfolgen, ob dies das erste Mal ist oder nicht (z. B. gemeinsame Voreinstellungen). Wenn es nicht das erste Mal ist, verwenden Sie zur Differenzierung shouldShowRequestPermissionRationale()

Siehe auch: Android M - Laufzeitberechtigung prüfen - Wie kann festgestellt werden, ob der Benutzer die Option "Nie wieder fragen" aktiviert hat?

8
Alex Florescu

So wie ich es verstehe, sollte shouldShowRequestPermissionRationale () eine Reihe von Anwendungsfällen unter der Haube ausführen und die App darüber informieren, ob eine Erklärung zu den angeforderten Berechtigungen angezeigt werden soll oder nicht.

Die Idee hinter den Laufzeitberechtigungen ist, dass der Benutzer die Berechtigungsanfrage meistens mit Ja sagt. Auf diese Weise muss der Benutzer nur einen Klick machen. Natürlich sollte die Anfrage im richtigen Kontext verwendet werden - d. H. Um die Erlaubnis der Kamera bitten, wenn die Taste "Camera" gedrückt wird. 

Wenn der Benutzer die Anfrage ablehnt, aber nach einiger Zeit wieder auf die Schaltfläche "Camera" klickt, sollte shouldShowRequestPermissionRationale () den Wert "true" zurückgeben, sodass die App eine aussagekräftige Erklärung für die Anforderung der Berechtigung und für die Anwendung der App anzeigen kann ohne es richtig funktionieren. Normalerweise würden Sie in diesem Dialogfenster eine Schaltfläche anzeigen, die Sie später erneut ablehnen/entscheiden sollen, und eine Schaltfläche, um die Berechtigungen zu erteilen. Die Schaltfläche zum Erteilen von Berechtigungen im Rational-Dialogfeld sollte die Berechtigungsanfrage erneut starten. Dieses Mal hat der Benutzer auch ein Kontrollkästchen "Nie wieder anzeigen". Sollte er sich für die Auswahl entscheiden und die Berechtigung erneut ablehnen, wird das Android-System darüber informiert, dass sich der Benutzer und die App nicht auf derselben Seite befinden. Diese Aktion hätte zwei Konsequenzen - shouldShowRequestPermissionRationale () gibt immer false zurück, und die requestPermissions () - Methode zeigt kein Dialogfeld an, gibt jedoch direkt den onRequestPermissionsResult-Rückruf zurück. 

Es gibt jedoch auch ein anderes Szenario, in dem onRequestPermissionsResult verwendet werden könnte. Einige Geräte verfügen beispielsweise über eine Geräterichtlinie, die die Kamera deaktiviert (für CIA, DARPA usw.). Auf diesen Geräten gibt onRequestPermissionsResult immer false zurück, und die requestPermissions () -Methode verweigert die Anforderung automatisch.

Das habe ich erfahren, als ich den Podcast mit Ben Poiesz - einem Produktmanager im Android-Framework - angehört habe.
http://androidbackstage.blogspot.jp/2015/08/episode-33-permission-mission.html

6
Shumoapp

Poste einfach eine andere Option, wenn jemand Lust dazu hat. Sie können EasyPermissions verwenden, das von Google selbst bereitgestellt wurde, um, wie gesagt, "Android M-Systemberechtigungen zu vereinfachen".

Dann müssen Sie shouldShowRequestPermissionRationale nicht direkt behandeln.

6
Wei WANG

Überprüfen Sie diese Implementierung. arbeitet ziemlich gut für mich. Im Grunde prüfen Sie die Berechtigungen in der checkPermissions () -Methode, indem Sie eine Liste von Berechtigungen übergeben. Sie überprüfen das Ergebnis der Berechtigungsanforderung in onRequestPermissionsResult (). Die Implementierung lässt Sie beide Fälle ansprechen, wenn der Benutzer "nie mehr fragen" wählt oder nicht. In dieser Implementierung hat der Dialog eine Option, falls er "Nie wieder fragen" auswählt, um ihn zur Aktivität "App-Einstellungen" zu bringen. 

Der ganze Code ist in meinem Fragment. Ich dachte, es wäre besser, eine spezialisierte Klasse zu erstellen, wie einen PermissionManager, aber ich bin mir nicht sicher.

/**
     * 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);
    }
3
Thiago Saraiva

Kann für jemanden nützlich sein: -

Was mir aufgefallen ist, wenn wir die shouldShowRequestPermissionRationale () -Flag in der onRequestPermissionsResult () - Callback-Methode markieren, werden nur zwei Zustände angezeigt.

Status 1: -Return true: - Jedes Mal, wenn der Benutzer auf Berechtigungen verweigern klickt (auch beim allerersten Mal).

Zustand 2: -Returns false: - Wenn der Benutzer wählt "Nie wieder fragen".

Link für detailliertes Arbeitsbeispiel .

2
Nicks

Wenn sich jemand für eine Kotlin-Lösung interessiert, habe ich die @ muthuraj-Antwort in Kotlin geändert. Auch ein bisschen modernisiert, um einen Abschlussblock anstelle von Hörern zu haben.

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)
        }
    }
}

Implementierung

PermissionHandler.checkPermission(activity,
                    Manifest.permission.CAMERA) { result ->
                when (result) {
                    CheckPermissionResult.PermissionGranted -> {
                        // openCamera()
                    }
                    CheckPermissionResult.PermissionDisabled -> {
                        // displayAlert(noPermissionAlert)
                    }
                    CheckPermissionResult.PermissionAsk -> {
                        // requestCameraPermissions()
                    }
                    CheckPermissionResult.PermissionPreviouslyDenied -> {
                        // displayAlert(permissionRequestAlert)
                    }
                }
            }
1
bmjohns

Wir können es auf diese Weise tun?

@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;
        }
    }
}
1
Dr. aNdRO

Dieser Code fordert den Benutzer auf, zur Laufzeit um Erlaubnis zu bitten. Wenn er dies zulässt, führt er die Ergebnismethode aus. Wenn der Benutzer deny ablehnt, fragt er erneut mit der Beschreibung mit dem Benutzer deny (es fragt erneut mit Anweisungen), wenn Benutzer wählt nie erneut fragen . Er behandelt nie wieder Fragen und zeigt die Option zum Öffnen der Einstellungen mit Anweisungen an.

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;
                }
        }
}
0
Abhiode

shouldShowRequestPermissionRationalefür die SPECIAL-Berechtigung gibt immer NUR zurück, nachdem der Benutzer dies verweigert hat ohne Kontrollkästchen

Wir interessieren uns für FALSE value

Es gibt also 3 Fälle mit false - Wert verloren: 

1. zuvor gab es keine solche Aktion und der Benutzer beschließt nun, zuzustimmen oder abzulehnen. 

Definieren Sie einfach eine Präferenz ASKED_PERMISSION_*, die jetzt nicht existiert und in onRequestPermissionsResulttrue wäre, wenn sie auf jeden Fall übereinstimmt oder ablehnt

Während diese Voreinstellung nicht existiert, gibt es keinen Grund, shouldShowRequestPermissionRationale zu überprüfen.

2. Benutzer hat zugestimmt. 

Einfach machen:

checkCallingOrSelfPermission(permission) == PackageManager.PERMISSION_GRANTED

Was wird true zurückgeben und es gibt keinen Grund, shouldShowRequestPermissionRationale zu überprüfen

3. Benutzer hat Ablehnen mit Kontrollkästchen angeklickt (zweite oder mehrmalige Abfrage)

Es ist TIME, um mit shouldShowRequestPermissionRationale zu arbeiten, was FALSE zurückgibt.

(Präferenz ist vorhanden und wir haben keine Erlaubnis)

0
V. Kalyuzhnyu