Android Runtime permissions- wie

Question

Android Developer Documentation gibt dieses Beispiel Anfordern von Berechtigungen zur Laufzeit implementieren:

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

Was ist "MY_PERMISSIONS_REQUEST_READ_CONTACTS" in diesem Beispiel? Es sagt, es ist eine App-definierte int-Konstante, aber heißt das, ich sollte eine Constants.java machen und eine öffentliche statische int deklarieren? Was sollte der Wert sein?

In anderen Beispielen sehe ich Menschen hier 1 oder 0 oder 0xFFEEDDCC, aber ich kann keine Erklärung dafür finden, was es ist. Kann mir jemand erklären, was hier los ist und warum? (In meinem Fall muss ich sicherstellen, dass die App die Berechtigung zum Zugriff auf den genauen Standort hat)

Die ActivityCompat-Dokumentation sagt "Anwendungsspezifischer Anforderungscode, der mit einem an onRequestPermissionsResult gemeldeten Ergebnis übereinstimmt"? Das hilft mir nicht.

Answer 1

Was ist "MY_PERMISSIONS_REQUEST_READ_CONTACTS" in diesem Beispiel?

Es ist ein int, einen bestimmten requestPermissions() Aufruf des entsprechenden onRequestPermissionsResult() Rückruf zu binden.

Unter den Abdeckungen requestPermissions() wird startActivityForResult() verwendet; Diese int dient der gleichen Rolle wie in startActivityForResult().

bedeutet das, ich sollte eine Constants.java machen und eine öffentliche statische int deklarieren?

Ich würde nur eine private static final int in der Aktivität machen. Aber, Sie können es erklären, wo immer Sie wollen.

Was sollte der Wert sein?

Ich erinnere mich, dass es unter 0x8000000 sein muss, aber sonst kann es sein, was auch immer Sie wollen. Der Wert, den Sie für jede requestPermissions() -Aufruf in einer Aktivität verwenden, sollte eine eindeutige int erhalten, aber die tatsächlichen Zahlen sind nicht wichtig.

Wenn Ihre Aktivität nur einen requestPermissions() Anruf hat, dann spielt der int Wert keine Rolle. Aber viele Apps haben mehrere requestPermissions() Anrufe in einer Aktivität. In diesem Fall muss der Entwickler möglicherweise in onRequestPermissionsResult() wissen, für welche Anfrage dies das Ergebnis ist.

Answer 2

Schauen Sie nur ein wenig weiter unten in der Dokumentation unter "Behandeln Sie die Antwort der Berechtigungsanforderung" und Sie werden ihren Zweck sehen.

Ein Callback-Methode onRequestPermissionsResult wird zurückgeschickt den gleichen Code als Parameter aufgerufen, so dass Sie wissen, welche die Erlaubnis erteilt angefordert wurde/wird:

@Override 
public void onRequestPermissionsResult(int requestCode, 
     String permissions[], int[] grantResults) { 
    switch (requestCode) { 
     case MY_PERMISSIONS_REQUEST_READ_CONTACTS: { 
      // If request is cancelled, the result arrays are empty. 
      if (grantResults.length > 0 
       && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

       // permission was granted, yay! Do the 
       // contacts-related task you need to do. 

      } else { 

       // permission denied, boo! Disable the 
       // functionality that depends on this permission. 
      } 
      return; 
     } 

     // other 'case' lines to check for other 
     // permissions this app might request 
    } 
} 

Da die Konstante, die durch Sie wird nur verwendet, können Sie es den Wert, geben Sie mögen als public static final int. Jede angeforderte Berechtigung benötigt eine eigene Konstante.

Answer 3

public class SplashActivity extends RuntimePermissionsActivity { 


@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_splash); 

    SplashActivity.super.requestAppPermissions(new 
        String[]{android.Manifest.permission.READ_PHONE_STATE, 
        Manifest.permission.WRITE_EXTERNAL_STORAGE, 
        Manifest.permission.READ_EXTERNAL_STORAGE}, R.string.app_name 
      , 20); 

} 

@Override 
public void onPermissionsGranted(int requestCode) { 


    try { 
     TelephonyManager tele = (TelephonyManager) getApplicationContext() 
       .getSystemService(Context.TELEPHONY_SERVICE); 

     String imei =tele.getDeviceId() 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

public abstract class RuntimePermissionsActivity extends AppCompatActivity { 
private SparseIntArray mErrorString; 

@Override 
protected void onCreate(@Nullable Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    mErrorString = new SparseIntArray(); 
} 

@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    int permissionCheck = PackageManager.PERMISSION_GRANTED; 
    for (int permission : grantResults) { 
     permissionCheck = permissionCheck + permission; 
    } 
    if ((grantResults.length > 0) && permissionCheck == PackageManager.PERMISSION_GRANTED) { 
     onPermissionsGranted(requestCode); 
    } else { 

     finish(); 

    } 
} 

public void requestAppPermissions(final String[] requestedPermissions, 
            final int stringId, final int requestCode) { 
    mErrorString.put(requestCode, stringId); 
    int permissionCheck = PackageManager.PERMISSION_GRANTED; 
    boolean shouldShowRequestPermissionRationale = false; 
    for (String permission : requestedPermissions) { 
     permissionCheck = permissionCheck + ContextCompat.checkSelfPermission(this, permission); 
     shouldShowRequestPermissionRationale = shouldShowRequestPermissionRationale || ActivityCompat.shouldShowRequestPermissionRationale(this, permission); 
    } 
    if (permissionCheck != PackageManager.PERMISSION_GRANTED) { 
     if (shouldShowRequestPermissionRationale) { 
      ActivityCompat.requestPermissions(RuntimePermissionsActivity.this, requestedPermissions, requestCode); 
      /*Snackbar.make(findViewById(android.R.id.content), stringId, 
        Snackbar.LENGTH_INDEFINITE).setAction("GRANT", 
        new View.OnClickListener() { 
         @Override 
         public void onClick(View v) { 
          ActivityCompat.requestPermissions(RuntimePermissionsActivity.this, requestedPermissions, requestCode); 
         } 
        }).show();*/ 
     } else { 
      ActivityCompat.requestPermissions(this, requestedPermissions, requestCode); 
     } 
    } else { 
     onPermissionsGranted(requestCode); 
    } 
} 

public abstract void onPermissionsGranted(int requestCode); 

}