shouldShowRequestPermissionRationale funktioniert nicht wie erwartet

Question

Ich arbeite an der Überprüfung und Erlangung der Erlaubnis von Benutzer mit API-Ebene 23 und höher. Also hier eine verwirrende Sache für mich ist, android.com sagt:

shouldShowRequestPermissionRationale() Methode gibt true zurück, wenn die App diese Berechtigung angefordert hat vorher und der Benutzer verweigert die Anfrage. Wenn der Benutzer die Berechtigungsanfrage in der Vergangenheit abgelehnt und entschied sich für die nicht wieder Option in der Berechtigungsanfrage Systemdialog fragen Sie, gibt diese Methode false

in anderen Seite ist es die Erlaubnis zur Überprüfung folgende Code gibt und Anfrage Erlaubnis, wenn seine bereits Local

// Here, thisActivity is the current activity 
if (ContextCompat.checkSelfPermission(thisActivity, 
      Manifest.permission.READ_CONTACTS) 
    != PackageManager.PERMISSION_GRANTED) { 

// Should we show an explanation? 
if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity, 
     Manifest.permission.READ_CONTACTS)) { 

    // Show an explanation to the user *asynchronously* -- don't block 
    // this thread waiting for the user's response! After the user 
    // sees the explanation, try again to request the permission. 

} else { 

    // No explanation needed, we can request the permission. 

    ActivityCompat.requestPermissions(thisActivity, 
      new String[]{Manifest.permission.READ_CONTACTS}, 
      MY_PERMISSIONS_REQUEST_READ_CONTACTS); 

    // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an 
    // app-defined int constant. The callback method gets the 
    // result of the request. 
    } 
} 

else Umfang in obigem Beispiel wird ausgeführt, wenn Benutzer die Berechtigung nicht zulässt und überprüfen Sie noch einmal fragen nicht, nicht wahr? Also mit diesem Code Benutzer nie um Erlaubnis gefragt, beim ersten Mal ausgeführt werden. Ich habe diesen Code getestet und das Ergebnis ist, was ich erwartet habe. So, wie könnte ich die Erlaubnis zum ersten Mal ausführen und etwas tun, wenn Benutzer meine Anfrage abgelehnt und etwas tun, wenn Benutzer meine Anfrage ablehnen und überprüfen Fragen Sie nicht erneut?

Answer 1

Zuerst prüfen, ob die Erlaubnis gewährt wird dann tun, was Sie brauchen sonst, wenn die Erlaubnis verweigert wird, dann überprüfen Sie, dass Sie die Erlaubnis benötigen, die Sie benötigen oder nicht durch sollteShowRequestPermissionRationale.
Wenn shallShowRequestPermissionRationale false zurückgibt, können Sie dem Benutzer nur eine Nachricht anzeigen, in der er die Berechtigung manuell aktivieren soll.
andere dann, wenn shouldShowRequestPermissionRationale true zurück fordern dann die Erlaubnis und erhalten das Ergebnis der Erlaubnis

Update in onRequestPermissionsResult gewähren, das ist nur ein einfacher Code, um die Schritte zu zeigen:

if (checkSelfPermission == granted){ 
// do what you want 
} else if (shouldShowRequestPermissionRationale == true) { 
     // you can request the permission you want from the user, then check whether permission granted or not inside onRequestPermissionsResult method 
} else { 
     // here you know the permission is not granted , and also the user check on "Dont ask Again!" checkbox, so all you can to do is just tell the user to enable the permission manually from app permissions through Toast message or any thing else 
     } 

Answer 2

@Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 

     //initilize your views 


    if(iscontactsAllowed){ 

    // do your code here 

    } else { 

    requestcontactsPermission(); 

    } 

} 
private void requestcontactsPermission() { 

     if (ActivityCompat.shouldShowRequestPermissionRationale(this, android.Manifest.permission.READ_CONTACTS)) { 
      //If the user has denied the permission previously your code will come to this block 
      //Here you can explain why you need this permission 
      //Explain here why you need this permission 
      Log.d("scancode", "denied permission before"); 
     } 

     Log.d("perm", "fourth"); 
     //And finally ask for the permission 
     ActivityCompat.requestPermissions(this, new String[]{android.Manifest.permission.READ_CONTACTS}, READ_CONTACTS_CODE /*can be any interge */); 

    } 

private boolean iscontactsAllowed() { 
      //Getting the permission status 
      int result = ContextCompat.checkSelfPermission(this, android.Manifest.permission.READ_CONTACTS); 

      //If permission is granted returning true 
      if (result == PackageManager.PERMISSION_GRANTED) 

       return true; 

      //If permission is not granted returning false 
      return false; 
     } 


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

     //Checking the request code of our request 

     if(requestCode == READ_CONTACTS_CODE){ 

if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

// you have the permission call yur method here 

} else { 

// permission denied show user why you need it or ask again by calling reuestpermission if you need the permission 
} 

} 

Answer 3

@ ArtinArtin Ich habe auf @salmanyahya aktualisiert einfachen Code erweitert und stellte meine Logik mit Alert Dialog und eine Snackbar (kein großer Fan von Snackbar) auf irgendeine Weise sehen, ob dies hilft

 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
     if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) { 
      //.... write file into storage ... 
      System.out.println("SDK > BuildVersion TRUE"); 
     } else { 
      requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 666); // Comment 26 
      System.out.println("go to requestPermissions"); 
     } 
    } 
    onLoad(); 
} 

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

    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    switch (requestCode) { 

     case 666: // Allowed was selected so Permission granted 
      if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

       Snackbar s = Snackbar.make(findViewById(android.R.id.content),"Permission Granted",Snackbar.LENGTH_LONG); 
       View snackbarView = s.getView(); 
       TextView textView = (TextView) snackbarView.findViewById(android.support.design.R.id.snackbar_text); 
       textView.setTextColor(Color.RED); 
       textView.setTextSize(18); 
       textView.setMaxLines(6); 
       s.show(); 

       // do your work here 

      } else if (Build.VERSION.SDK_INT >= 23 && !shouldShowRequestPermissionRationale(permissions[0])) { 
       // User selected the Never Ask Again Option Change settings in app settings manually 
       AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); 
       alertDialogBuilder.setTitle("Change Permissions in Settings"); 
       alertDialogBuilder 
         .setMessage("" + 
           "\nClick SETTINGS to Manually Set\n"+"Permissions to use Database Storage") 
         .setCancelable(false) 
         .setPositiveButton("SETTINGS", new DialogInterface.OnClickListener() { 
          public void onClick(DialogInterface dialog, int id) { 
           Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS); 
           Uri uri = Uri.fromParts("package", getPackageName(), null); 
           intent.setData(uri); 
           startActivityForResult(intent, 1000);  // Comment 3. 
          } 
         }); 

       AlertDialog alertDialog = alertDialogBuilder.create(); 
       alertDialog.show(); 

      } else { 
        // User selected Deny Dialog to EXIT App ==> OR <== RETRY to have a second chance to Allow Permissions 
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_DENIED) { 

        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); 
        alertDialogBuilder.setTitle("Second Chance"); 
        alertDialogBuilder 
          .setMessage("Click RETRY to Set Permissions to Allow\n\n"+"Click EXIT to the Close App") 
          .setCancelable(false) 
          .setPositiveButton("RETRY", new DialogInterface.OnClickListener() { 
           public void onClick(DialogInterface dialog, int id) { 
            //ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, Integer.parseInt(WRITE_EXTERNAL_STORAGE)); 
            Intent i = new Intent(MainActivity.this,MainActivity.class); 
            i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK); 
            startActivity(i); 
            } 
          }) 
          .setNegativeButton("EXIT", new DialogInterface.OnClickListener() { 
           public void onClick(DialogInterface dialog, int id) { 
            finish(); 
            dialog.cancel(); 
           } 
          }); 
        AlertDialog alertDialog = alertDialogBuilder.create(); 
        alertDialog.show(); 
       } 
      } 
      break; 
    }}; 

Answer 4

Dieser Code hilft, die Laufzeit Rechteverwaltung in Android

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