wake-up-neo.com

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

Demnach: http://developer.Android.com/preview/features/runtime-permissions.html#coding Eine App kann Laufzeitberechtigungen und Anforderungsberechtigungen prüfen, wenn sie noch nicht erteilt wurden. Der folgende Dialog wird angezeigt:

enter image description here

Wenn der Benutzer eine wichtige Erlaubnis ablehnt, sollte imo eine App eine Erläuterung anzeigen, warum die Erlaubnis erforderlich ist und welche Auswirkungen das Abnehmen hat. Dieser Dialog hat zwei Optionen:

  1. erneut versuchen (Erlaubnis wird erneut angefordert)
  2. verweigern (App funktioniert ohne diese Erlaubnis).

Wenn der Benutzer jedoch Never ask again überprüft, sollte der zweite Dialog mit der Erläuterung nicht angezeigt werden, insbesondere wenn der Benutzer bereits einmal abgelehnt wurde ..__ Nun stellt sich die Frage: Woher weiß meine App, ob der Benutzer den Never ask again überprüft hat? IMO die onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) gibt mir diese Informationen nicht.

Eine zweite Frage wäre: Hat Google Pläne, eine benutzerdefinierte Nachricht in den Berechtigungsdialog zu integrieren, die erklären würde, warum die App die Berechtigung benötigt? Auf diese Weise würde es niemals einen zweiten Dialog geben, der sicherlich zu einem besseren ux führen würde.

257

Developer Preview 2 bringt einige Änderungen mit sich, wie Berechtigungen von der App angefordert werden (siehe auch http://developer.Android.com/preview/support.html#preview2-notes ).

Der erste Dialog sieht jetzt so aus:

 enter image description here

Es gibt kein Kontrollkästchen "Nie wieder anzeigen" (im Gegensatz zur Entwicklervorschau 1). Wenn der Benutzer die Erlaubnis verweigert und wenn die Erlaubnis für die App wesentlich ist, kann ein weiterer Dialog angezeigt werden, um den Grund zu erläutern, warum die App diese Erlaubnis anfordert, z. so was:

 enter image description here

Wenn der Benutzer erneut ablehnt, sollte die App entweder heruntergefahren werden, wenn diese Berechtigung unbedingt erforderlich ist, oder mit eingeschränkter Funktionalität ausgeführt werden. Wenn der Benutzer dies erneut prüft (und erneuten Versuch wählt), wird die Berechtigung erneut angefordert. Dieses Mal sieht die Aufforderung so aus:

 enter image description here

Beim zweiten Mal wird das Kontrollkästchen "Nie wieder fragen" angezeigt. Wenn der Benutzer erneut ablehnt und das Kontrollkästchen aktiviert ist, sollte nichts mehr passieren. Ob das Kontrollkästchen aktiviert ist oder nicht, kann mit Activity.shouldShowRequestPermissionRationale (String) bestimmt werden, z. so was:

if (shouldShowRequestPermissionRationale(Manifest.permission.WRITE_CONTACTS)) {...

Das sagt die Android-Dokumentation ( https://developer.Android.com/training/permissions/requesting.html ):

Um zu helfen, die Situationen zu finden, in denen Sie zusätzliche .__ angeben müssen. Erklärung liefert das System die Activity.shouldShowRequestPermissionRationale (String) -Methode. Diese Die Methode gibt true zurück, wenn die App diese Berechtigung angefordert hat zuvor und der Benutzer hat die Anfrage abgelehnt. Das zeigt an, dass Sie sollte dem Benutzer wahrscheinlich erklären, warum Sie die Berechtigung benötigen.

Wenn der Benutzer die Berechtigungsanfrage in der Vergangenheit abgelehnt hat und .__ ausgewählt hat. die Option Nicht erneut fragen im Berechtigungsanfrage-Systemdialogfeld Diese Methode gibt false zurück. Die Methode gibt auch false zurück, wenn das Gerät Diese Richtlinie verbietet der App diese Berechtigung. 

Um zu erfahren, ob der Benutzer mit "nie wieder fragen" abgelehnt wurde, können Sie die Methode shouldShowRequestPermissionRationale in Ihrem onRequestPermissionsResult erneut überprüfen, wenn der Benutzer die Berechtigung nicht erteilt hat.

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    if (requestCode == REQUEST_PERMISSION) {
        // for each permission check if the user granted/denied them
        // you may want to group the rationale in a single dialog,
        // this is just an example
        for (int i = 0, len = permissions.length; i < len; i++) {
            String permission = permissions[i];
            if (grantResults[i] == PackageManager.PERMISSION_DENIED) {
            // user rejected the permission
                boolean showRationale = shouldShowRequestPermissionRationale( permission );
                if (! showRationale) {
                    // user also CHECKED "never ask again"
                    // you can either enable some fall back,
                    // disable features of your app
                    // or open another dialog explaining
                    // again the permission and directing to
                    // the app setting
                } else if (Manifest.permission.WRITE_CONTACTS.equals(permission)) {
                    showRationale(permission, R.string.permission_denied_contacts);
                    // user did NOT check "never ask again"
                    // this is a good place to explain the user
                    // why you need the permission and ask if he wants
                    // to accept it (the rationale)
                } else if ( /* possibly check more permissions...*/ ) {
                }
            }
        }
    }
}

Sie können Ihre App-Einstellungen mit diesem Code öffnen:

Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
Uri uri = Uri.fromParts("package", getPackageName(), null);
intent.setData(uri);
startActivityForResult(intent, REQUEST_PERMISSION_SETTING);

Es ist nicht möglich, den Benutzer direkt zur Autorisierungsseite zu senden.

301

Sie können shouldShowRequestPermissionRationale() in Ihrer onRequestPermissionsResult() überprüfen.

 shouldShowRequestPermissionRationale https://youtu.be/C8lUdPVSzDk?t=2m23s

Prüfen Sie in onRequestPermissionsResult(), ob die Berechtigung erteilt wurde oder nicht. Wenn nicht, überprüfen Sie shouldShowRequestPermissionRationale()

  1. Wenn diese Methode true zurückgibt, zeigen Sie eine Erklärung, warum diese bestimmte Berechtigung erforderlich ist. Dann je nach Wahl des Benutzers requestPermissions().
  2. Wenn false zurückgegeben wird, wird eine Fehlermeldung angezeigt, dass die Berechtigung nicht erteilt wurde und die App nicht fortfahren kann oder eine bestimmte Funktion deaktiviert ist.

Unten sehen Sie Beispielcode.

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode) {
        case STORAGE_PERMISSION_REQUEST:
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // permission was granted :)
                downloadFile();
            } else {
                // permission was not granted
                if (getActivity() == null) {
                    return;
                }
                if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                    showStoragePermissionRationale();
                } else {
                    Snackbar snackbar = Snackbar.make(getView(), getResources().getString(R.string.message_no_storage_permission_snackbar), Snackbar.LENGTH_LONG);
                    snackbar.setAction(getResources().getString(R.string.settings), new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            if (getActivity() == null) {
                                return;
                            }
                            Intent intent = new Intent();
                            intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                            Uri uri = Uri.fromParts("package", getActivity().getPackageName(), null);
                            intent.setData(uri);
                            OrderDetailFragment.this.startActivity(intent);
                        }
                    });
                    snackbar.show();
                }
            }
            break;
    }
}

Anscheinend macht Google Maps genau das für die Standorterlaubnis.

84
Abhinav Chauhan

Hier ist eine nette und einfache Methode zum Überprüfen des aktuellen Berechtigungsstatus:

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({GRANTED, DENIED, BLOCKED_OR_NEVER_ASKED })
    public @interface PermissionStatus {}

    public static final int GRANTED = 0;
    public static final int DENIED = 1;
    public static final int BLOCKED_OR_NEVER_ASKED = 2;

    @PermissionStatus 
    public static int getPermissionStatus(Activity activity, String androidPermissionName) {
        if(ContextCompat.checkSelfPermission(activity, androidPermissionName) != PackageManager.PERMISSION_GRANTED) {
            if(!ActivityCompat.shouldShowRequestPermissionRationale(activity, androidPermissionName)){
                return BLOCKED_OR_NEVER_ASKED;
            }
            return DENIED;
        }
        return GRANTED;
    }

Achtung: Gibt BLOCKED_OR_NEVER_ASKED beim ersten Start der Anwendung zurück, bevor der Benutzer die Berechtigung über die Benutzeraufforderung (auf Sdk 23+ -Geräten) akzeptiert/abgelehnt hat}

Update:

Die Android-Support-Bibliothek scheint nun auch eine sehr ähnliche Klasse Android.support.v4.content.PermissionChecker zu haben, die eine checkSelfPermission() enthält, die Folgendes zurückgibt:

public static final int PERMISSION_GRANTED = 0;
public static final int PERMISSION_DENIED = -1;
public static final int PERMISSION_DENIED_APP_OP = -2;
33
patrickf

Sie können feststellen , ob die Berechtigung als Begründung angezeigt werden soll die onRequestPermissionsResult() Rückrufmethode. Und wenn Sie eine Berechtigung finden, die auf eingestellt ist, fragen Sie nie wieder , können Sie Benutzer auffordern, Berechtigungen aus den Einstellungen zu erteilen.

Meine vollständige Implementierung wäre wie folgt. Es funktioniert sowohl für einzelne als auch mehrere Berechtigungsanforderungen. Verwenden Sie die folgenden oder direkt meine Bibliothek verwenden.

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if(permissions.length == 0){
        return;
    }
    boolean allPermissionsGranted = true;
    if(grantResults.length>0){
        for(int grantResult: grantResults){
            if(grantResult != PackageManager.PERMISSION_GRANTED){
                allPermissionsGranted = false;
                break;
            }
        }
    }
    if(!allPermissionsGranted){
        boolean somePermissionsForeverDenied = false;
        for(String permission: permissions){
            if(ActivityCompat.shouldShowRequestPermissionRationale(this, permission)){
                //denied
                Log.e("denied", permission);
            }else{
                if(ActivityCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED){
                    //allowed
                    Log.e("allowed", permission);
                } else{
                    //set to never ask again
                    Log.e("set to never ask again", permission);
                    somePermissionsForeverDenied = true;
                }
            }
        }
        if(somePermissionsForeverDenied){
            final AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
            alertDialogBuilder.setTitle("Permissions Required")
                    .setMessage("You have forcefully denied some of the required permissions " +
                            "for this action. Please open settings, go to permissions and allow them.")
                    .setPositiveButton("Settings", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                                    Uri.fromParts("package", getPackageName(), null));
                            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                            startActivity(intent);
                        }
                    })
                    .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                        }
                    })
                    .setCancelable(false)
                    .create()
                    .show();
        }
    } else {
        switch (requestCode) {
            //act according to the request code used while requesting the permission(s).
        }
    }
}
24
Nabin Bhandari

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 Status 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 zum detaillierten Arbeitsbeispiel

19
Nicks

Nachdem der Benutzer die Option "Nicht mehr fragen" markiert hat, kann die Frage nicht erneut angezeigt werden. Es kann jedoch dem Benutzer erklärt werden, dass er zuvor die Berechtigung abgelehnt hat und die Berechtigung in den Einstellungen erteilen muss. Verweisen Sie ihn auf die Einstellungen mit folgendem Code:

@Override
public void onRequestPermissionsResult(int permsRequestCode, String[] permissions, int[] grantResults) {

    if (grantResults.length > 0
            && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        // now, you have permission go ahead
        // TODO: something

    } else {

        if (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                Manifest.permission.READ_CALL_LOG)) {
            // now, user has denied permission (but not permanently!)

        } else {

            // now, user has denied permission permanently!

            Snackbar snackbar = Snackbar.make(findViewById(Android.R.id.content), "You have previously declined this permission.\n" +
                "You must approve this permission in \"Permissions\" in the app settings on your device.", Snackbar.LENGTH_LONG).setAction("Settings", new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                startActivity(new Intent(Android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:" + BuildConfig.APPLICATION_ID)));

            }
        });
        View snackbarView = snackbar.getView();
        TextView textView = (TextView) snackbarView.findViewById(Android.support.design.R.id.snackbar_text);
        textView.setMaxLines(5);  //Or as much as you need
        snackbar.show();

        }

    }
    return;
}
11

Wenn Sie alle "Zustände" erkennen möchten (erstmalig abgelehnt, nur abgelehnt, nur mit "Never Ask Again" oder dauerhaft abgelehnt), können Sie Folgendes tun:

Erstellen Sie 2 Booleans

private boolean beforeClickPermissionRat;
private boolean afterClickPermissionRat;

Stellen Sie den ersten ein, bevor Sie um Erlaubnis fragen:

beforeClickPermissionRat = shouldShowRequestPermissionRationale(Manifest.permission.READ_EXTERNAL_STORAGE);

Setzen Sie die zweite in Ihrer onRequestPermissionsResult-Methode:

afterClickPermissionRat = shouldShowRequestPermissionRationale(Manifest.permission.READ_EXTERNAL_STORAGE);

Verwenden Sie die folgende "Tabelle", um zu tun, was Sie in onRequestPermissionsResult () benötigen (nachdem Sie überprüft haben, dass Sie noch keine Berechtigung haben):

// before after
// FALSE  FALSE  =  Was denied permanently, still denied permanently --> App Settings
// FALSE  TRUE   =  First time deny, not denied permanently yet --> Nothing
// TRUE   FALSE  =  Just been permanently denied --> Changing my caption to "Go to app settings to edit permissions"
// TRUE   TRUE   =  Wasn't denied permanently, still not denied permanently --> Nothing
9
mVck

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

woher weiß meine App, ob der Benutzer das Kontrollkästchen "Nie wieder fragen" aktiviert hat?

Wenn der Benutzer Nie mehr gefragt ausgewählt hat, erhalten Sie einen Rückruf bei onPermissionDisabled.

Viel Spaß beim Codieren :)

8
muthuraj

Vollständige Erklärung für jeden Erlaubnisfall

/**
 *    Case 1: User doesn't have permission
 *    Case 2: User has permission
 *
 *    Case 3: User has never seen the permission Dialog
 *    Case 4: User has denied permission once but he din't clicked on "Never Show again" check box
 *    Case 5: User denied the permission and also clicked on the "Never Show again" check box.
 *    Case 6: User has allowed the permission
 *
 */
public void handlePermission() {
    if (ContextCompat.checkSelfPermission(MainActivity.this,
            Manifest.permission.WRITE_EXTERNAL_STORAGE)
            != PackageManager.PERMISSION_GRANTED) {
        // This is Case 1. Now we need to check further if permission was shown before or not

        if (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)) {

            // This is Case 4.
        } else {
            // This is Case 3. Request for permission here
        }

    } else {
        // This is Case 2. You have permission now you can do anything related to it
    }
}

public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {

    if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        // This is Case 2 (Permission is now granted)
    } else {
        // This is Case 1 again as Permission is not granted by user

        //Now further we check if used denied permanently or not
        if (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
            // case 4 User has denied permission but not permanently

        } else {
            // case 5. Permission denied permanently.
            // You can open Permission setting's page from here now.
        }

    }
}
3
saksham

Ich habe eine Abkürzung für die Erlaubnisanfrage in Android M geschrieben. Dieser Code behandelt auch die Abwärtskompatibilität mit älteren Android-Versionen.

Der gesamte hässliche Code wird in ein Fragment extrahiert, das an die Aktivität angehängt wird, die die Berechtigungen anfordert. Sie können PermissionRequestManager wie folgt verwenden:

new PermissionRequestManager()
        // We need a AppCompatActivity here, if you are not using support libraries you will have to slightly change 
        // the PermissionReuqestManager class
        .withActivity(this)

        // List all permissions you need
        .withPermissions(Android.Manifest.permission.CALL_PHONE, Android.Manifest.permission.READ_CALENDAR)

        // This Runnable is called whenever the request was successfull
        .withSuccessHandler(new Runnable() {
            @Override
            public void run() {
                // Do something with your permissions!
                // This is called after the user has granted all 
                // permissions, we are one a older platform where 
                // the user does not need to grant permissions 
                // manually, or all permissions are already granted

            }
        })

        // Optional, called when the user did not grant all permissions
        .withFailureHandler(new Runnable() {
            @Override
            public void run() {
                // This is called if the user has rejected one or all of the requested permissions
                L.e(this.getClass().getSimpleName(), "Unable to request permission");

            }
        })

        // After calling this, the user is prompted to grant the rights
        .request();

Werfen Sie einen Blick: https://Gist.github.com/crysxd/385b57d74045a8bd67c4110c34ab74aa

2
crysxd

Eine nützliche Funktion, um festzustellen, ob eine willkürliche Berechtigung für die Anforderung (in Kotlin) blockiert wurde:

private fun isPermissionBlockedFromAsking(activity: Activity, permission: String): Boolean {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        return ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED
            && !activity.shouldShowRequestPermissionRationale(permission)
            && PreferenceManager.getDefaultSharedPreferences(activity).getBoolean(permission, false)
    }
    return false
}

Wenn Sie dies verwenden, müssen Sie eine gemeinsam genutzte Voreinstellung mit dem Namen der gewünschten Berechtigung (z. B. Android.Manifest.permission.READ_PHONE_STATE) auf btrue setzen, wenn Sie erstmals eine Berechtigung anfordern. 


Erläuterung:

Build.VERSION.SDK_INT >= Build.VERSION_CODES.M als Teil des Codes darf nur auf API-Ebene 23+ ausgeführt werden.

ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED Um zu überprüfen, haben wir noch keine Berechtigung.

!activity.shouldShowRequestPermissionRationale(permission), um zu überprüfen, ob der Benutzer die App erneut abgelehnt hat. Aufgrund von Macken dieser Funktion ist auch die folgende Zeile erforderlich.

PreferenceManager.getDefaultSharedPreferences(activity).getBoolean(permission, false) Dies wird verwendet (zusammen mit dem Setzen des Werts auf true bei der ersten Berechtigungsanforderung), um zwischen den Zuständen "Niemals gefragt" und "Nie mehr Fragen" zu unterscheiden, da die vorherige Zeile diese Informationen nicht zurückgibt.

2
JakeSteam

Die Methode shouldShowRequestPermissionRationale () kann vom Benutzer überprüft werden, ob der Benutzer die Option "nie mehr gefragt" ausgewählt und die Berechtigung verweigert hat ..__ Es gibt viele Codebeispiele, daher möchte ich lieber erläutern, wie er verwendet wird ein Zweck, weil ich denke, dass sein Name und seine Implementierung dies komplizierter macht, als es tatsächlich ist.

Wie in Anfordern von Berechtigungen zur Laufzeit erläutert, gibt diese Methode true zurück, wenn die Option 'never ask gefragt' sichtbar ist, andernfalls false. Wenn also ein Dialog das erste Mal angezeigt wird, wird der Wert false zurückgegeben. Wenn der Benutzer die Berechtigung verweigert, die Option zu wählen, gibt er an diesem Punkt erneut den Wert false zurück.

Um einen solchen Fall zu erkennen, können Sie entweder die Sequenz falsch-wahr-falsch-falsch erkennen oder (einfacher) Sie können ein Flag haben, das den Anfangszeitpunkt des Dialogs aufzeichnet. Danach gibt diese Methode entweder "true" oder "false" zurück, wobei Sie mit "false" erkennen können, wann die Option ausgewählt ist.

2
Alessio

Probieren Sie diese einfache Berechtigungsbibliothek aus. Alle Vorgänge im Zusammenhang mit der Genehmigung werden in drei einfachen Schritten ausgeführt. Es hat mir Zeit gespart. Sie können alle mit der Erlaubnis zusammenhängenden Arbeiten in 15 Minuten abschließen.

Es kann mit Verweigern umgehen. Es kann mit Nie wieder abfragen. Es kann App-Einstellungen zur Berechtigung aufrufen. Es kann eine Rational-Nachricht ausgegeben werden. Es kann eine Denial-Nachricht gegeben werden. Es kann eine Liste der akzeptierten Berechtigungen angegeben werden Berechtigungen und etc.

https://github.com/ParkSangGwon/TedPermission

Schritt 1: füge deine Abhängigkeit hinzu

dependencies {
     compile 'gun0912.ted:tedpermission:2.1.1'
     //check the above link for latest libraries
}

Step2: Berechtigungen fragen

TedPermission.with(this)
    .setPermissionListener(permissionlistener)
    .setDeniedMessage("If you reject permission,you can not use this service\n\nPlease turn on permissions at [Setting] > [Permission]")
    .setPermissions(Manifest.permission.READ_CONTACTS, Manifest.permission.ACCESS_FINE_LOCATION)
    .check();

Schritt 3: Berechtigungsantwort bearbeiten

PermissionListener permissionlistener = new PermissionListener() {
    @Override
    public void onPermissionGranted() {
        Toast.makeText(MainActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onPermissionDenied(ArrayList<String> deniedPermissions) {
        Toast.makeText(MainActivity.this, "Permission Denied\n" + deniedPermissions.toString(), Toast.LENGTH_SHORT).show();
    }
};
2
Vignes

Sie können verwenden 

shouldShowRequestPermissionRationale()

innerhalb 

onRequestPermissionsResult()

Siehe das Beispiel unten:

Prüfen Sie, ob die Berechtigung vorhanden ist, wenn der Benutzer auf die Schaltfläche klickt:

@Override
public void onClick(View v) {
    if (v.getId() == R.id.appCompatBtn_changeProfileCoverPhoto) {
        if (Build.VERSION.SDK_INT < 23) { // API < 23 don't need to ask permission
            navigateTo(MainActivity.class); // Navigate to activity to change photos
        } else {
            if (ContextCompat.checkSelfPermission(SettingsActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    != PackageManager.PERMISSION_GRANTED) {
                // Permission is not granted yet. Ask for permission...
                requestWriteExternalPermission();
            } else {
                // Permission is already granted, good to go :)
                navigateTo(MainActivity.class);
            }
        } 
    }
}

Wenn der Benutzer das Berechtigungsdialogfeld antwortet, gelangen Sie zu onRequestPermissionResult:

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);

    if (requestCode == WRITE_EXTERNAL_PERMISSION_REQUEST_CODE) {
        // Case 1. Permission is granted.  
        if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {  
            if (ContextCompat.checkSelfPermission(SettingsActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    == PackageManager.PERMISSION_GRANTED) {
                // Before navigating, I still check one more time the permission for good practice.
                navigateTo(MainActivity.class);
            }
        } else { // Case 2. Permission was refused
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                // Case 2.1. shouldShowRequest... returns true because the
                // permission was denied before. If it is the first time the app is running we will 
                // end up in this part of the code. Because he need to deny at least once to get 
                // to onRequestPermissionsResult. 
                Snackbar snackbar = Snackbar.make(findViewById(R.id.relLayout_container), R.string.you_must_verify_permissions_to_send_media, Snackbar.LENGTH_LONG);
                snackbar.setAction("VERIFY", new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        ActivityCompat.requestPermissions(SettingsActivity.this
                                , new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}
                                , WRITE_EXTERNAL_PERMISSION_REQUEST_CODE);
                    }
                });
                snackbar.show();
            } else {
                // Case 2.2. Permission was already denied and the user checked "Never ask again". 
                // Navigate user to settings if he choose to allow this time.
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setMessage(R.string.instructions_to_turn_on_storage_permission)
                        .setPositiveButton(getString(R.string.settings), new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                Intent settingsIntent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                                Uri uri = Uri.fromParts("package", getPackageName(), null);
                                settingsIntent.setData(uri);
                                startActivityForResult(settingsIntent, 7);
                            }
                        })
                        .setNegativeButton(getString(R.string.not_now), null);
                Dialog dialog = builder.create();
                dialog.show();
            }
        }
    }

}
1
Soon Santos

Bitte werfen Sie mir keine Steine ​​für diese Lösung. 

Das funktioniert, ist aber etwas "hacky".

Wenn Sie requestPermissions aufrufen, registrieren Sie die aktuelle Uhrzeit.

        mAskedPermissionTime = System.currentTimeMillis();

Dann in onRequestPermissionsResult 

wenn das Ergebnis nicht gewährt wird, überprüfen Sie die Uhrzeit erneut.

 if (System.currentTimeMillis() - mAskedPermissionTime < 100)

Da der Benutzer möglicherweise nicht so schnell auf die Ablehnungsschaltfläche geklickt hat, wissen wir, dass er "nie wieder fragen" ausgewählt hat, da der Rückruf sofort erfolgt.

Gebrauch auf eigene Gefahr.

1
Antzi

sie können hübsch zuhören.

Zuhörer

interface PermissionListener {
    fun onNeedPermission()
    fun onPermissionPreviouslyDenied(numberDenyPermission: Int)
    fun onPermissionDisabledPermanently(numberDenyPermission: Int)
    fun onPermissionGranted()
}

MainClass für die Erlaubnis

class PermissionUtil {

    private val PREFS_FILENAME = "permission"
    private val TAG = "PermissionUtil"

    private fun shouldAskPermission(context: Context, permission: String): Boolean {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val permissionResult = ActivityCompat.checkSelfPermission(context, permission)
            if (permissionResult != PackageManager.PERMISSION_GRANTED) {
                return true
            }
        }
        return false
    }

    fun checkPermission(context: Context, permission: String, listener: PermissionListener) {

        Log.i(TAG, "CheckPermission for $permission")

        if (shouldAskPermission(context, permission)) {

            // Load history permission
            val sharedPreference = context.getSharedPreferences(PREFS_FILENAME, 0)
            val numberShowPermissionDialog = sharedPreference.getInt(permission, 0)

            if (numberShowPermissionDialog == 0) {

                (context as? Activity)?.let {
                    if (ActivityCompat.shouldShowRequestPermissionRationale(it, permission)) {
                        Log.e(TAG, "User has denied permission but not permanently")
                        listener.onPermissionPreviouslyDenied(numberShowPermissionDialog)
                    } else {
                        Log.e(TAG, "Permission denied permanently.")
                        listener.onPermissionDisabledPermanently(numberShowPermissionDialog)
                    }
                } ?: kotlin.run {
                    listener.onNeedPermission()
                }

            } else {
                // Is FirstTime
                listener.onNeedPermission()
            }


            // Save history permission
            sharedPreference.edit().putInt(permission, numberShowPermissionDialog + 1).apply()


        } else {
            listener.onPermissionGranted()
        }

    }
}

Auf diese Weise verwendet  

      PermissionUtil().checkPermission(this, Manifest.permission.ACCESS_FINE_LOCATION,
                object : PermissionListener {
                    override fun onNeedPermission() {
                        log("---------------------->onNeedPermission")

//                            ActivityCompat.requestPermissions([email protected],
//                                    Array(1) { Manifest.permission.ACCESS_FINE_LOCATION },
//                                    118)

                    }

                    override fun onPermissionPreviouslyDenied(numberDenyPermission: Int) {
                        log("---------------------->onPermissionPreviouslyDenied")
                    }

                    override fun onPermissionDisabledPermanently(numberDenyPermission: Int) {
                        log("---------------------->onPermissionDisabled")
                    }

                    override fun onPermissionGranted() {
                        log("---------------------->onPermissionGranted")
                    }

                })

überschreiben onRequestPermissionsResult in Aktivität oder fragmnet

override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
 if (requestCode == 118) {
        if (permissions[0] == Manifest.permission.ACCESS_FINE_LOCATION && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            getLastLocationInMap()
        }
        }
    }
1
Rasoul Miri
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
    switch (requestCode) {
        case PERMISSIONS_REQUEST_EXTERNAL_STORAGE: {
            if (grantResults.length > 0) {
                if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                    // Denied
                } else {
                    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
                        // To what you want
                    } else {
                       // Bob never checked click
                    }
                }
            }
        }
    }
}
0
Vinod Ranga

Wenn Sie die Antwort von mVck oben erweitern, bestimmt die folgende Logik, ob "Nie wieder fragen" für eine gegebene Berechtigungsanfrage geprüft wurde:

bool bStorage = grantResults[0] == Permission.Granted;
bool bNeverAskForStorage =
    !bStorage && (
        _bStorageRationaleBefore == true  && _bStorageRationaleAfter == false ||
        _bStorageRationaleBefore == false && _bStorageRationaleAfter == false
    );

welches von unten entnommen ist (für das vollständige Beispiel siehe Antwort )

private bool _bStorageRationaleBefore;
private bool _bStorageRationaleAfter;        
private const int Android_PERMISSION_REQUEST_CODE__SDCARD = 2;
//private const int Android_PERMISSION_REQUEST_CODE__CAMERA = 1;
private const int Android_PERMISSION_REQUEST_CODE__NONE = 0;

public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Permission[] grantResults)
{
    base.OnRequestPermissionsResult(requestCode, permissions, grantResults);

    switch (requestCode)
    {
        case Android_PERMISSION_REQUEST_CODE__SDCARD:               
            _bStorageRationaleAfter = ShouldShowRequestPermissionRationale(Android.Manifest.Permission.WriteExternalStorage);
            bool bStorage = grantResults[0] == Permission.Granted;
            bool bNeverAskForStorage =
                !bStorage && (
                    _bStorageRationaleBefore == true  && _bStorageRationaleAfter == false ||
                    _bStorageRationaleBefore == false && _bStorageRationaleAfter == false
                );      
            break;                
    }
}

private List<string> GetRequiredPermissions(out int requestCode)
{
    // Android v6 requires explicit permission granting from user at runtime for security reasons            
    requestCode = Android_PERMISSION_REQUEST_CODE__NONE; // 0
    List<string> requiredPermissions = new List<string>();

    _bStorageRationaleBefore = ShouldShowRequestPermissionRationale(Android.Manifest.Permission.WriteExternalStorage);
    Permission writeExternalStoragePerm = ApplicationContext.CheckSelfPermission(Android.Manifest.Permission.WriteExternalStorage);
    //if(extStoragePerm == Permission.Denied)
    if (writeExternalStoragePerm != Permission.Granted)
    {
        requestCode |= Android_PERMISSION_REQUEST_CODE__SDCARD;
        requiredPermissions.Add(Android.Manifest.Permission.WriteExternalStorage);
    }

    return requiredPermissions;
}

protected override void OnCreate(Bundle savedInstanceState)
{
    base.OnCreate(savedInstanceState);

        // Android v6 requires explicit permission granting from user at runtime for security reasons
        int requestCode;
        List<string> requiredPermissions = GetRequiredPermissions(out requestCode);
        if (requiredPermissions != null && requiredPermissions.Count > 0)
        {
            if (requestCode >= Android_PERMISSION_REQUEST_CODE__SDCARD)                    
            {
                _savedInstanceState = savedInstanceState;
                RequestPermissions(requiredPermissions.ToArray(), requestCode);
                return;
            }
        }
    }            

    OnCreate2(savedInstanceState);
}
0
samis

Stattdessen erhalten Sie einen Rückruf auf onRequestPermissionsResult() als PERMISSION_DENIED, wenn Sie erneut eine Erlaubnis anfordern, während Sie in einen falschen Zustand von shouldShowRequestPermissionRationale() fallen.

Aus dem Android-Dokument:

Wenn das System den Benutzer auffordert, eine Berechtigung zu erteilen, hat der Benutzer die Möglichkeit, das System anzuweisen, diese Berechtigung nicht erneut anzufordern. In diesem Fall verweigert das System die Anforderung sofort, wenn eine App erneut requestPermissions() verwendet, um diese Berechtigung erneut abzufragen. Das System ruft Ihre onRequestPermissionsResult()-Rückmeldemethode auf und übergibt PERMISSION_DENIED, genauso wie dies der Fall wäre, wenn der Benutzer Ihre Anforderung erneut explizit abgelehnt hätte. Das bedeutet, dass Sie beim Aufruf von requestPermissions() nicht davon ausgehen können, dass eine direkte Interaktion mit dem Benutzer stattgefunden hat.

0
Farhan

Um die Frage genau zu beantworten: Was passiert, wenn der Benutzer "Nie wieder fragen" drückt?

Die überschriebene Methode/Funktion

onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray)

Das grantResult-Array ist leer, also können Sie dort vielleicht etwas unternehmen? Aber nicht die beste Praxis.

Wie gehe ich mit "Nie wieder fragen" um?

Ich arbeite mit Fragment, für das die Berechtigung READ_EXTERNAL_STORAGE erforderlich war.

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        when {
            isReadPermissionsGranted() -> {

                /**
                 * Permissions has been Granted
                 */

                getDirectories()
            }

            isPermissionDeniedBefore() -> {

                /**
                 * User has denied before, explain why we need the permission and ask again
                 */

                updateUIForDeniedPermissions()
                checkIfPermissionIsGrantedNow()

            }
            else -> {

                /**
                 * Need to ask For Permissions, First Time
                 */

                checkIfPermissionIsGrantedNow()

                /**
                 * If user selects, "Dont Ask Again" it will never ask again! so just update the UI for Denied Permissions
                 */

                updateUIForDeniedPermissions()

            }
        }
    }

Die anderen Funktionen sind trivial.

// Is Read Write Permissions Granted
fun isReadWritePermissionGranted(context: Context): Boolean {
    return (ContextCompat.checkSelfPermission(
        context as Activity,
        Manifest.permission.READ_EXTERNAL_STORAGE
    ) == PackageManager.PERMISSION_GRANTED) and
            (ContextCompat.checkSelfPermission(
                context,
                Manifest.permission.WRITE_EXTERNAL_STORAGE
            ) == PackageManager.PERMISSION_GRANTED)
}

fun isReadPermissionDenied(context: Context) : Boolean {
    return ActivityCompat.shouldShowRequestPermissionRationale(
        context as Activity,
        PermissionsUtils.READ_EXTERNAL_STORAGE_PERMISSIONS)
}
0
devDeejay

sie können das offizielle Dokument von Android .__ lesen. App-Berechtigungen anfordern

sie können viele beliebte Android-Berechtigungsbibliotheken auf Github finden

0
shellhub

Ich möchte auch die Information erhalten, ob der Benutzer "nie mehr fragen" gewählt hat oder nicht. Ich habe eine "beinahe Lösung" mit einer hässlich aussehenden Flagge erreicht, aber bevor ich Ihnen erzähle, wie es geht, werde ich Ihnen meine Motivation erzählen:

Ich möchte zunächst die Berechtigungsreferenzfunktion anbieten. Wenn der Benutzer es verwendet und keine Rechte hat, erhält er entweder den 1. Dialog von oben oder sowohl den 2. als auch den 3. Dialog. Wenn der Benutzer "Nie wieder fragen" gewählt hat, möchte ich die Funktionalität deaktivieren und anders anzeigen. - Meine Aktion wird durch einen Spinner-Texteintrag ausgelöst. Ich möchte auch dem angezeigten Beschriftungstext "(Berechtigung widerrufen)" hinzufügen. Dies zeigt dem Benutzer: 'Es gibt Funktionen, die ich jedoch aufgrund meiner Berechtigungseinstellungen nicht verwenden kann.' Dies scheint jedoch nicht möglich zu sein, da ich nicht prüfen kann, ob "Nie wieder fragen" ausgewählt wurde oder nicht.

Ich kam zu einer Lösung, mit der ich leben kann, indem meine Funktionalität immer mit einer aktiven Berechtigungsprüfung aktiviert wird. Ich zeige eine Toast-Nachricht in onRequestPermissionsResult () für den Fall einer negativen Antwort, aber nur, wenn ich mein benutzerdefiniertes Popup nicht angezeigt habe. Wenn der Benutzer "Nie wieder fragen" gewählt hat, erhält er nur eine Toastnachricht. Wenn der Benutzer nur ungern fragt, "nie wieder fragen" zu wählen, erhält er vom Betriebssystem nur die benutzerdefinierten Gründe und die Berechtigungsanforderung, aber kein Toast, da drei Benachrichtigungen in Folge zu große Schmerzen verursachen würden.

0
ChristianKoelle

Ich muss eine dynamische Erlaubnis für die Kamera implementieren. Wo 3 mögliche Fälle auftreten: 1. Erlauben, 2. Abgelehnt, 3. Nicht mehr fragen.

 @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {

    for (String permission : permissions) {
        if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(), permission)) {
            //denied
            Log.e("denied", permission);
        } else {
            if (ActivityCompat.checkSelfPermission(getActivity(), permission) == PackageManager.PERMISSION_GRANTED) {
                //allowed
                Log.e("allowed", permission);
            } else {
                //set to never ask again
                Log.e("set to never ask again", permission);
                //do something here.
            }
        }
    }
    if (requestCode != MaterialBarcodeScanner.RC_HANDLE_CAMERA_PERM) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        return;
    }
    if (grantResults.length != 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        mScannerView.setResultHandler(this);
        mScannerView.startCamera(mCameraId);
        mScannerView.setFlash(mFlash);
        mScannerView.setAutoFocus(mAutoFocus);
        return;
    } else {
        //set to never ask again
        Log.e("set to never ask again", permissions[0]);
    }
    DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int id) {
            dialog.cancel();
        }
    };
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle("Error")
            .setMessage(R.string.no_camera_permission)
            .setPositiveButton(Android.R.string.ok, listener)
            .show();


}

private void insertDummyContactWrapper() {
        int hasWriteContactsPermission = checkSelfPermission(Manifest.permission.CAMERA);
        if (hasWriteContactsPermission != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(new String[]{Manifest.permission.CAMERA},
                    REQUEST_CODE_ASK_PERMISSIONS);
            return;
        }
        mScannerView.setResultHandler(this);
        mScannerView.startCamera(mCameraId);
        mScannerView.setFlash(mFlash);
        mScannerView.setAutoFocus(mAutoFocus);
    }

private int checkSelfPermission(String camera) {
    if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.CAMERA)
            != PackageManager.PERMISSION_GRANTED) {
        return REQUEST_CODE_ASK_PERMISSIONS;
    } else {
        return REQUEST_NOT_CODE_ASK_PERMISSIONS;
    }
}
0
hitesh141

Sie können die if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)-Methode verwenden, um festzustellen, ob niemals fragen aktiviert ist oder nicht.

Für mehr Referenz: Überprüfen Sie dies

Um nach mehreren Berechtigungen zu suchen, verwenden Sie Folgendes:

  if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)
                                || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                                || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)
                                || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.RECORD_AUDIO)) {
                            showDialogOK("Service Permissions are required for this app",
                                    new DialogInterface.OnClickListener() {
                                        @Override
                                        public void onClick(DialogInterface dialog, int which) {
                                            switch (which) {
                                                case DialogInterface.BUTTON_POSITIVE:
                                                    checkAndRequestPermissions();
                                                    break;
                                                case DialogInterface.BUTTON_NEGATIVE:
                                                    // proceed with logic by disabling the related features or quit the app.
                                                    finish();
                                                    break;
                                            }
                                        }
                                    });
                        }
                        //permission is denied (and never ask again is  checked)
                        //shouldShowRequestPermissionRationale will return false
                        else {
                            explain("You need to give some mandatory permissions to continue. Do you want to go to app settings?");
                            //                            //proceed with logic by disabling the related features or quit the app.
                        }

erklären () Methode

private void explain(String msg){
        final Android.support.v7.app.AlertDialog.Builder dialog = new Android.support.v7.app.AlertDialog.Builder(this);
        dialog.setMessage(msg)
                .setPositiveButton("Yes", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                        //  permissionsclass.requestPermission(type,code);
                        startActivity(new Intent(Android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:com.exampledemo.parsaniahardik.marshmallowpermission")));
                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                        finish();
                    }
                });
        dialog.show();
    }

Der obige Code zeigt auch ein Dialogfeld, in dem der Benutzer zum Bildschirm mit den App-Einstellungen weitergeleitet wird, von dem aus er die Erlaubnis erteilen kann, wenn die Schaltfläche "Nicht fragen" erneut aktiviert wurde.

0
user6435056