Comment vérifier l'autorisation multiple à la demande unique dans Android M?

Question

Je veux utiliser la

1. android.permission.CAMERA
2. android.permission.WRITE_EXTERNAL_STORAGE

à la demande unique à l'aide

ActivityCompat.requestPermissions(Activity activity,new String permisionList[],int permissionRequestcode); 

Mais mon problème est à l'heure que je demande une seule autorisation, Je lis à propos de l'autorisation de groupe, mais c'est un travail pour seulement le même groupe dont on a décidé par le développeur, comme CONTACT_GROUP : read_contact,write_contact etc.

Je veux créer l'autorisation de groupe personnalisé qui ne me demande qu'une seule demande & de fournir une seule réponse.

Merci

Answer 1

Il n'y a pas bidouille disponible à ce stade pour contourner demander des autorisations de différents groupes. C'est la nature de la façon dont android a développé des permissions d'exécution, pour donner aux utilisateurs le choix des autorisations à accepter. Bien sûr, ne pas accepter toutes les autorisations requises par une application peut empêcher l'application de fonctionner correctement.

CAMERA et WRITE_EXTERNAL_STORAGE sont à la fois regarded as dangerous permissions et en groupes séparés, donc à la fois exigeant une runtime permission request.

Une fois l'autorisation est accordée pour un groupe particulier, il n'a pas besoin d'être demandé à nouveau pour toute la durée de la course de l'application, ou jusqu'à ce qu'il soit révoqué s'il est défini par défaut.

La seule chose que vous pouvez faire est de demander à l'utilisateur d'accepter les décisions par défaut, qui peut être révoquées, by using "never ask again"

Answer 2

Comme dit précédemment, Actuellement, chaque groupe d'autorisations possède sa propre boîte de dialogue d'autorisation qui doit être appelée séparément.

Vous aurez différentes boîtes de dialogue pour chaque groupe d'autorisations, mais vous pouvez certainement vérifier le résultat ensemble dans la méthode de rappel onRequestPermissionsResult().

Here is a working example link, may be useful for someone.

Answer 3

Vous pouvez demander des autorisations multiples (de différents groupes) dans une seule requête. Pour cela, vous devez ajouter toutes les autorisations au tableau de chaînes que vous fournissez en tant que premier paramètre à l'API requestPermissions comme ceci:

requestPermissions(new String[]{ 
           Manifest.permission.READ_CONTACTS, 
           Manifest.permission.ACCESS_FINE_LOCATION}, 
         ASK_MULTIPLE_PERMISSION_REQUEST_CODE); 

En faisant cela, vous verrez la fenêtre d'autorisation comme une pile de plusieurs popups d'autorisation. Bien sûr, vous devez gérer l'acceptation et le rejet (y compris les options "Never Ask Again") de chaque autorisation. La même chose a été magnifiquement expliqué sur here.

Answer 4

J'ai fait face au même problème et ci-dessous est la solution de contournement je suis venu avec:

public boolean checkForPermission(final String[] permissions, final int permRequestCode, int msgResourceId) { 
     final List<String> permissionsNeeded = new ArrayList<>(); 
     for (int i = 0; i < permissions.length; i++) { 
      final String perm = permissions[i]; 
      if (ContextCompat.checkSelfPermission(getActivity(), permissions[i]) != PackageManager.PERMISSION_GRANTED) { 
       if (shouldShowRequestPermissionRationale(permissions[i])) { 
        final AlertDialog dialog = AlertDialog.newInstance(getResources().getString(R.string.permission_title), getResources().getString(msgResourceId)); 
        dialog.setPositiveButton("OK", new View.OnClickListener() { 
         @Override 
         public void onClick(View view) { 
          // add the request. 
          permissionsNeeded.add(perm); 
          dialog.dismiss(); 
         } 
        }); 
        dialog.show(getActivity().getSupportFragmentManager(), "HCFAlertDialog"); 
       } else { 
        // add the request. 
        permissionsNeeded.add(perm); 
       } 
      } 
     } 

     if (permissionsNeeded.size() > 0) { 
      // go ahead and request permissions 
      requestPermissions(permissionsNeeded.toArray(new String[permissionsNeeded.size()]), permRequestCode); 
      return false; 
     } else { 
      // no permission need to be asked so all good...we have them all. 
      return true; 
     } 
    } 

Et vous appelez la méthode ci-dessus comme ceci:

if (checkForPermission(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, 
Manifest.permission.CAMERA}, REQUEST_PERMISSION_EXTERNAL_STORAGE_RESULT, R.string.permission_image)) { 
         // DO YOUR STUFF 

        } 

Answer 5

Pour obtenir l'autorisation multiple, vous pouvez utiliser ce code :

final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124; 

private void insertDummyContactWrapper() { 
    List<String> permissionsNeeded = new ArrayList<String>(); 

    final List<String> permissionsList = new ArrayList<String>(); 
    if (!addPermission(permissionsList, Manifest.permission.ACCESS_FINE_LOCATION)) 
     permissionsNeeded.add("GPS"); 
    if (!addPermission(permissionsList, Manifest.permission.READ_CONTACTS)) 
     permissionsNeeded.add("Read Contacts"); 
    if (!addPermission(permissionsList, Manifest.permission.WRITE_CONTACTS)) 
     permissionsNeeded.add("Write Contacts"); 

    if (permissionsList.size() > 0) { 
     if (permissionsNeeded.size() > 0) { 
      // Need Rationale 
      String message = "You need to grant access to " + permissionsNeeded.get(0); 
      for (int i = 1; i < permissionsNeeded.size(); i++) 
       message = message + ", " + permissionsNeeded.get(i); 
      showMessageOKCancel(message, 
        new DialogInterface.OnClickListener() { 
         @Override 
         public void onClick(DialogInterface dialog, int which) { 
          requestPermissions(permissionsList.toArray(new String[permissionsList.size()]), 
            REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS); 
         } 
        }); 
      return; 
     } 
     requestPermissions(permissionsList.toArray(new String[permissionsList.size()]), 
       REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS); 
     return; 
    } 

    insertDummyContact(); 
} 

private boolean addPermission(List<String> permissionsList, String permission) { 
    if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) { 
     permissionsList.add(permission); 
     // Check for Rationale Option 
     if (!shouldShowRequestPermissionRationale(permission)) 
      return false; 
    } 
    return true; 
} 

Answer 6

J'ai eu le même problème et sommes tombés sur ce library.

Fondamentalement, vous pouvez demander plusieurs autorisations de manière séquentielle, en plus vous pouvez ajouter des écouteurs pour faire apparaître une barre d'en-cas si l'utilisateur refuse votre permission.

https://raw.githubusercontent.com/Karumi/Dexter/master/art/sample.gif

(Désolé, n'ont pas assez réputation d'inclure des images.)

Answer 7

 // **For multiple permission you can use this code :** 

     // **First:** 
//Write down in onCreate method. 

     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
        requestPermissions(new String[]{ 
            android.Manifest.permission.READ_EXTERNAL_STORAGE, 
            android.Manifest.permission.CAMERA}, 
          MY_PERMISSIONS_REQUEST); 

     } 

     //**Second:** 
    //Write down in a activity. 
    @Override 
     public void onRequestPermissionsResult(int requestCode, 
               String permissions[], int[] grantResults) { 
      switch (requestCode) { 
       case MY_PERMISSIONS_REQUEST: 

        if (grantResults.length > 0 
          && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 
         new Handler().postDelayed(new Runnable() { 
          @Override 
          public void run() { 
           progressBar.setVisibility(View.GONE); 
           Intent i = new Intent(SplashActivity.this, 
             HomeActivity.class); 
           startActivity(i); 
           finish(); 
          } 
         }, SPLASH_DISPLAY_LENGTH); 

        } else { 
         finish(); 
        } 
        return; 
      } 
     } 

Answer 8

d'abord initialiser le code de demande d'autorisation

public static final int PERMISSIONS_MULTIPLE_REQUEST = 123; 

Vérification de la version Android

private void checkAndroidVersion() { 
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
     checkPermission(); 

    } else { 
     // write your logic here 
    } 

} 

vérifier plusieurs codes d'autorisation

private void checkPermission() { 
    if (ContextCompat.checkSelfPermission(getActivity(), 
      Manifest.permission.READ_EXTERNAL_STORAGE) + ContextCompat 
      .checkSelfPermission(getActivity(), 
        Manifest.permission.CAMERA) 
      != PackageManager.PERMISSION_GRANTED) { 

     if (ActivityCompat.shouldShowRequestPermissionRationale 
       (getActivity(), Manifest.permission.READ_EXTERNAL_STORAGE) || 
       ActivityCompat.shouldShowRequestPermissionRationale 
         (getActivity(), Manifest.permission.CAMERA)) { 

     Snackbar.make(getActivity().findViewById(android.R.id.content), 
        "Please Grant Permissions to upload profile photo", 
        Snackbar.LENGTH_INDEFINITE).setAction("ENABLE", 
        new View.OnClickListener() { 
         @Override 
         public void onClick(View v) { 
          requestPermissions(
            new String[]{Manifest.permission 
              .READ_EXTERNAL_STORAGE, Manifest.permission.CAMERA}, 
            PERMISSIONS_MULTIPLE_REQUEST); 
         } 
        }).show(); 
     } else { 
      requestPermissions(
        new String[]{Manifest.permission 
          .READ_EXTERNAL_STORAGE, Manifest.permission.CAMERA}, 
        PERMISSIONS_MULTIPLE_REQUEST); 
     } 
    } else { 
     // write your logic code if permission already granted 
    } 
} 

méthode de rappel

après l'autorisation de subvention par l'utilisateur

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

    switch (requestCode) { 
     case PERMISSIONS_MULTIPLE_REQUEST: 
      if (grantResults.length > 0) { 
       boolean cameraPermission = grantResults[1] == PackageManager.PERMISSION_GRANTED; 
       boolean readExternalFile = grantResults[0] == PackageManager.PERMISSION_GRANTED; 

       if(cameraPermission && readExternalFile) 
       { 
        // write your logic here 
       } else { 
        Snackbar.make(getActivity().findViewById(android.R.id.content), 
         "Please Grant Permissions to upload profile photo", 
         Snackbar.LENGTH_INDEFINITE).setAction("ENABLE", 
         new View.OnClickListener() { 
          @Override 
          public void onClick(View v) { 
           requestPermissions(
             new String[]{Manifest.permission 
               .READ_EXTERNAL_STORAGE, Manifest.permission.CAMERA}, 
             PERMISSIONS_MULTIPLE_REQUEST); 
          } 
         }).show(); 
       } 
      } 
      break; 
    } 
} 

Answer 9

Sur la base de ce que j'ai cherché, je pense que ce sont les meilleures réponses que j'ai trouvé Android 6.0 multiple permissions Ajouter un code générique pour différents types d'autorisations.

Answer 10

Copiez-collez avec des modifications mineures. Lisez les commentaires "TODO" dans le code ci-dessous.

Faites l'activité suivante votre activité de lancement:

public class PermissionReqActivity extends AppCompatActivity { 

    private static final int CODE_WRITE_SETTINGS_PERMISSION = 332; 
    private static String[] PERMISSIONS_ALL = {Manifest.permission.WRITE_EXTERNAL_STORAGE}; //TODO You can Add multiple permissions here. 
    private static final int PERMISSION_REQUEST_CODE = 223; 
    private Context context; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_permission_req); 
     context = this; 

     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 

      boolean allPermissionsGranted = true; 
      ArrayList<String> toReqPermissions = new ArrayList<>(); 

      for (String permission : PERMISSIONS_ALL) { 
       if (ActivityCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) { 
        toReqPermissions.add(permission); 

        allPermissionsGranted = false; 
       } 
      } 
      if (allPermissionsGranted) 
       //TODO Now some permissions are very special and require Settings Activity to launch, as u might have seen in some apps. handleWriteSettingsPermission() is an example for WRITE_SETTINGS permission. If u don't need very special permission(s), replace handleWriteSettingsPermission() with initActivity(). 
       handleWriteSettingsPermission(); 
      else 
       ActivityCompat.requestPermissions(this, 
         toReqPermissions.toArray(new String[toReqPermissions.size()]), PERMISSION_REQUEST_CODE); 
     } 
    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { 
     if (requestCode == PERMISSION_REQUEST_CODE) { 
      boolean allPermGranted = true; 
      for (int i = 0; i < grantResults.length; i++) { 
       if (grantResults[i] != PackageManager.PERMISSION_GRANTED) { 
        Toast.makeText(this, "Permissions not granted: " + permissions[i], Toast.LENGTH_LONG).show(); 
        allPermGranted = false; 
        finish(); 
        break; 
       } 
      } 
      if (allPermGranted) 
       handleWriteSettingsPermission();//TODO As mentioned above, use initActivity() here if u dont need very special permission WRITE_SETTINGS 
     } 
     super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    } 

    private void handleWriteSettingsPermission() { 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
      if (Settings.System.canWrite(context)) { 
       initActivity(); 
      } else { 
       Toast.makeText(this, "Please Enable this permission for " + 
         getApplicationInfo().loadLabel(getPackageManager()).toString(), Toast.LENGTH_LONG).show(); 
       Intent intent = new Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS); 
       intent.setData(Uri.parse("package:" + context.getPackageName())); 
       startActivityForResult(intent, CODE_WRITE_SETTINGS_PERMISSION); 
      } 
     } 
    } 

//TODO You don't need the following onActivityResult() function if u dont need very special permissions. 

    @Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
     super.onActivityResult(requestCode, resultCode, data); 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && requestCode == CODE_WRITE_SETTINGS_PERMISSION) { 
      if (Settings.System.canWrite(this)) 
       initActivity(); 
      else { 
       Toast.makeText(this, "Permissions not granted: " + Manifest.permission.WRITE_SETTINGS, Toast.LENGTH_LONG).show(); 
       finish(); 
      } 
     } 
    } 

    private void initActivity() { 
     startActivity(new Intent(this, MainActivity.class)); 
    } 
}