Android runtime permissions- come implementare

Question

Android Developer Documentation dà questo esempio di richiedere permessi in fase di esecuzione:

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

Che cosa è "MY_PERMISSIONS_REQUEST_READ_CONTACTS" In questo esempio? Dice che è una costante int definita dall'app, ma ciò significa che dovrei creare un Constants.java e dichiarare un int statico pubblico? quale dovrebbe essere il valore?

In altri esempi, vedo che le persone usano 1 qui, o 0 o 0xFFEEDDCC, ma non riesco a trovare una spiegazione di cosa sia. Qualcuno può spiegarmi che cosa deve andare qui e perché? (Nel mio caso, ho bisogno di assicurarmi che l'app abbia il permesso di accedere alla posizione fine)

La documentazione di ActivityCompat dice "Codice di richiesta specifico dell'applicazione da abbinare a un risultato segnalato a onRequestPermissionsResult"? Questo non mi aiuta

Answer 1

Che cos'è "MY_PERMISSIONS_REQUEST_READ_CONTACTS" in questo esempio?

È un int, per legare un particolare requestPermissions() chiamata al corrispondente onRequestPermissionsResult() richiamata.

Sotto le coperture, requestPermissions() utilizza startActivityForResult(); questo int ha lo stesso ruolo di startActivityForResult().

vuol dire che dovrei creare un Constants.java e dichiarare un int statico pubblico?

Farei appena un private static final int nell'attività. Ma puoi dichiararlo ovunque tu voglia.

Quale dovrebbe essere il valore?

Mi sembra di ricordare che deve essere inferiore a 0x8000000, ma altrimenti può essere qualunque cosa tu voglia. Il valore che si utilizza per ogni chiamata requestPermissions() in un'attività dovrebbe ottenere un valore distinto int, ma i numeri reali non contano.

Se la tua attività ha una sola chiamata requestPermissions(), il valore int non ha importanza. Ma molte app avranno più chiamate requestPermissions() in un'attività. In tal caso, potrebbe essere necessario che lo sviluppatore sappia, in onRequestPermissionsResult(), per quale richiesta questo è il risultato.

Answer 2

Guardare solo un po 'più in basso nella documentazione in "Gestire la risposta richiesta autorizzazioni" e vedrete il suo scopo.

un metodo di callback chiamato onRequestPermissionsResult viene rispedito lo stesso codice come parametro in modo da sapere che l'autorizzazione è stata data della richiesta/concessa:

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

Dal momento che la costante è utilizzato da voi solo si può dare qualsiasi valore ti piace come public static final int. Ogni autorizzazione richiesta richiede una propria costante.

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

}