Android demande la permission de guimauve?

Je travaille actuellement sur une application qui nécessite plusieurs permissions “dangereuses”. J’ai donc essayé d’append “demander la permission” comme requirejs dans Android Marshmallow (API niveau 23), mais je n’ai pas trouvé comment le faire.

Comment puis-je demander une autorisation à l’aide du nouveau modèle d’autorisation dans mon application?

Ouvrez un dialog en utilisant le code ci-dessous:

ActivityCompat.requestPermissions(MainActivity.this, new Ssortingng[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 1); 

Obtenez le résultat de l’activité comme ci-dessous:

 @Override public void onRequestPermissionsResult(int requestCode, Ssortingng permissions[], int[] grantResults) { switch (requestCode) { case 1: { // 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. Toast.makeText(MainActivity.this, "Permission denied to read your External storage", Toast.LENGTH_SHORT).show(); } return; } // other 'case' lines to check for other // permissions this app might request } } 

Plus d’info: https://developer.android.com/training/permissions/requesting.html

Cette structure que j’utilise pour vérifier si mon application a l’autorisation et demande si elle n’a pas la permission. Donc, dans mon code principal d’où je veux vérifier l’écriture suivante:

 int MyVersion = Build.VERSION.SDK_INT; if (MyVersion > Build.VERSION_CODES.LOLLIPOP_MR1) { if (!checkIfAlreadyhavePermission()) { requestForSpecificPermission(); } } 

Le module checkIfAlreadyhavePermission () est implémenté en tant que:

 private boolean checkIfAlreadyhavePermission() { int result = ContextCompat.checkSelfPermission(this, Manifest.permission.GET_ACCOUNTS); if (result == PackageManager.PERMISSION_GRANTED) { return true; } else { return false; } } 

Le module requestForSpecificPermission () est implémenté comme suit:

 private void requestForSpecificPermission() { ActivityCompat.requestPermissions(this, new Ssortingng[]{Manifest.permission.GET_ACCOUNTS, Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_SMS, Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 101); } 

et remplacer dans l’activité:

 @Override public void onRequestPermissionsResult(int requestCode, Ssortingng[] permissions, int[] grantResults) { switch (requestCode) { case 101: if (grantResults[0] == PackageManager.PERMISSION_GRANTED) { //granted } else { //not granted } break; default: super.onRequestPermissionsResult(requestCode, permissions, grantResults); } } 

Référer ce lien pour plus de détails: http://revisitingandroid.blogspot.in/2017/01/how-to-check-and-request-for-run-time.html

J’ai utilisé ce wrapper (recommandé) écrit par les développeurs Google. C’est super facile à utiliser.

https://github.com/googlesamples/easypermissions

Fonction traitant de la vérification et demande la permission si nécessaire

 public void locationAndContactsTask() { Ssortingng[] perms = { Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.READ_CONTACTS }; if (EasyPermissions.hasPermissions(this, perms)) { // Have permissions, do the thing! Toast.makeText(this, "TODO: Location and Contacts things", Toast.LENGTH_LONG).show(); } else { // Ask for both permissions EasyPermissions.requestPermissions(this, getSsortingng(R.ssortingng.rationale_location_contacts), RC_LOCATION_CONTACTS_PERM, perms); } } 

Heureux codage 🙂

À partir d’Android Marshmallow, nous devons demander à l’utilisateur des permissions spécifiques. Nous pouvons également vérifier le code si l’autorisation est déjà donnée. Voici une liste des permissions généralement nécessaires:

  • android.permission-group.CALENDAR

    • android.permission.READ_CALENDAR
    • android.permission.WRITE_CALENDAR
  • android.permission-group.CAMERA

    • android.permission.CAMERA
  • android.permission-group.CONTACTS

    • android.permission.READ_CONTACTS
    • android.permission.WRITE_CONTACTS
    • android.permission.GET_ACCOUNTS
  • android.permission-group.LOCATION

    • android.permission.ACCESS_FINE_LOCATION
    • android.permission.ACCESS_COARSE_LOCATION
  • android.permission-group.MICROPHONE

    • android.permission.RECORD_AUDIO
  • android.permission-group.PHONE

    • android.permission.READ_PHONE_STATE
    • android.permission.CALL_PHONE
    • android.permission.READ_CALL_LOG
    • android.permission.WRITE_CALL_LOG
    • android.permission.ADD_VOICEMAIL
    • android.permission.USE_SIP
    • android.permission.PROCESS_OUTGOING_CALLS
  • android.permission-group.SENSORS

    • android.permission.BODY_SENSORS
  • android.permission-group.SMS

    • android.permission.SEND_SMS
    • android.permission.RECEIVE_SMS
    • android.permission.READ_SMS
    • android.permission.RECEIVE_WAP_PUSH
    • android.permission.RECEIVE_MMS
    • android.permission.READ_CELL_BROADCASTS
  • android.permission-group.STORAGE

    • android.permission.READ_EXTERNAL_STORAGE
    • android.permission.WRITE_EXTERNAL_STORAGE

Voici un exemple de code pour vérifier les permissions:

 if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CALENDAR) != PackageManager.PERMISSION_GRANTED) { if (ActivityCompat.shouldShowRequestPermissionRationale((Activity) context, Manifest.permission.WRITE_CALENDAR)) { AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context); alertBuilder.setCancelable(true); alertBuilder.setMessage("Write calendar permission is necessary to write event!!!"); alertBuilder.setPositiveButton(android.R.ssortingng.yes, new DialogInterface.OnClickListener() { @TargetApi(Build.VERSION_CODES.JELLY_BEAN) public void onClick(DialogInterface dialog, int which) { ActivityCompat.requestPermissions((Activity)context, new Ssortingng[]{Manifest.permission.WRITE_CALENDAR}, MY_PERMISSIONS_REQUEST_WRITE_CALENDAR); } }); } else { ActivityCompat.requestPermissions((Activity)context, new Ssortingng[]{Manifest.permission.WRITE_CALENDAR}, MY_PERMISSIONS_REQUEST_WRITE_CALENDAR); } } 

Ma classe pour les permissions d’exécution demandées

 public class RequestPermissionHandler { private Activity mActivity; private RequestPermissionListener mRequestPermissionListener; private int mRequestCode; public void requestPermission(Activity activity, @NonNull Ssortingng[] permissions, int requestCode, RequestPermissionListener listener) { mActivity = activity; mRequestCode = requestCode; mRequestPermissionListener = listener; if (!needRequestRuntimePermissions()) { mRequestPermissionListener.onSuccess(); return; } requestUnGrantedPermissions(permissions, requestCode); } private boolean needRequestRuntimePermissions() { return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M; } private void requestUnGrantedPermissions(Ssortingng[] permissions, int requestCode) { Ssortingng[] unGrantedPermissions = findUnGrantedPermissions(permissions); if (unGrantedPermissions.length == 0) { mRequestPermissionListener.onSuccess(); return; } ActivityCompat.requestPermissions(mActivity, unGrantedPermissions, requestCode); } private boolean isPermissionGranted(Ssortingng permission) { return ActivityCompat.checkSelfPermission(mActivity, permission) == PackageManager.PERMISSION_GRANTED; } private Ssortingng[] findUnGrantedPermissions(Ssortingng[] permissions) { List unGrantedPermissionList = new ArrayList<>(); for (String permission : permissions) { if (!isPermissionGranted(permission)) { unGrantedPermissionList.add(permission); } } return unGrantedPermissionList.toArray(new String[0]); } public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if (requestCode == mRequestCode) { if (grantResults.length > 0) { for (int grantResult : grantResults) { if (grantResult != PackageManager.PERMISSION_GRANTED) { mRequestPermissionListener.onFailed(); return; } } mRequestPermissionListener.onSuccess(); } else { mRequestPermissionListener.onFailed(); } } } public interface RequestPermissionListener { void onSuccess(); void onFailed(); } } 

Utiliser dans Activity comme

 public class MainActivity extends AppCompatActivity { private RequestPermissionHandler mRequestPermissionHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mRequestPermissionHandler = new RequestPermissionHandler(); findViewById(R.id.button).setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { handleButtonClicked(); } }); } private void handleButtonClicked(){ mRequestPermissionHandler.requestPermission(this, new Ssortingng[] { Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_EXTERNAL_STORAGE }, 123, new RequestPermissionHandler.RequestPermissionListener() { @Override public void onSuccess() { Toast.makeText(MainActivity.this, "request permission success", Toast.LENGTH_SHORT).show(); } @Override public void onFailed() { Toast.makeText(MainActivity.this, "request permission failed", Toast.LENGTH_SHORT).show(); } }); } @Override public void onRequestPermissionsResult(int requestCode, @NonNull Ssortingng[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); mRequestPermissionHandler.onRequestPermissionsResult(requestCode, permissions, grantResults); } } 

entrer la description de l'image ici

Projet de démonstration sur Github

========

PLUS

J’ai créé une base LIRARY sur cette idée, mais elle prend en charge davantage de fonctionnalités comme la justification des spectacles, et ne demande pas à nouveau. Vérifiez-le si possible

Android-M, API 23 a introduit les permissions d’exécution pour réduire les failles de sécurité dans les appareils Android, où les utilisateurs peuvent désormais gérer directement les permissions des applications. Si l’utilisateur refuse une autorisation particulière de votre application, vous devez la demander. que vous avez mentionné dans votre requête.

Donc, vérifiez avant l’action, c.-à-d. Vérifiez que vous avez la permission d’accéder au lien de la ressource et si votre application n’a pas cette autorisation particulière, vous pouvez demander le lien d’ autorisation et gérer la demande de permission comme ci-dessous.

 @Override public void onRequestPermissionsResult(int requestCode, Ssortingng 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 } } 

Donc, enfin, c’est une bonne pratique de passer par des changements de comportement si vous prévoyez de travailler avec de nouvelles versions pour éviter les fermetures forcées 🙂

Meilleures pratiques en matière d’permissions.

Vous pouvez parcourir l’application exemple officielle ici .

Depuis Android Marshmallow (API 23) et ci-dessus, par défaut, toutes les permissions dangereuses (selon le document officiel officiel du doc ) sont désactivées. Après l’installation lorsque l’application est ouverte pour la première fois, vous devez accorder une autorisation à l’exécution.

J’ai réalisé ceci de la manière suivante:

 public class MarshMallowPermission { public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_GALLERY = 0; public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_CAMERA = 1; public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE = 2; public static final int CAMERA_PERMISSION_REQUEST_CODE = 3; public static final int LOCATION_PERMISSION_REQUEST_CODE = 4; Activity activity; Context mContext; public MarshMallowPermission(Activity activity) { this.activity = activity; this.mContext = activity; } public boolean checkPermissionForExternalStorage(){ int result = ContextCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE); if (result == PackageManager.PERMISSION_GRANTED){ return true; } else { return false; } } public boolean checkPermissionForCamera(){ int result = ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA); if (result == PackageManager.PERMISSION_GRANTED){ return true; } else { return false; } } public boolean checkLocationPermission(){ int result = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION); if (result == PackageManager.PERMISSION_GRANTED){ return true; } else { return false; } } public void requestPermissionForExternalStorage(int requestCode){ if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)){ Toast.makeText(mContext.getApplicationContext(), "External Storage permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show(); } else { ActivityCompat.requestPermissions(activity,new Ssortingng[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},requestCode); } } public void requestPermissionForCamera(){ if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA)){ Toast.makeText(mContext.getApplicationContext(), "Camera permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show(); } else { ActivityCompat.requestPermissions(activity,new Ssortingng[]{Manifest.permission.CAMERA},CAMERA_PERMISSION_REQUEST_CODE); } } public void requestPermissionForLocation(){ if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_FINE_LOCATION) && ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_COARSE_LOCATION)){ Toast.makeText(mContext.getApplicationContext(), "Location permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show(); } else { ActivityCompat.requestPermissions(activity, new Ssortingng[]{Manifest.permission.ACCESS_FINE_LOCATION,Manifest.permission.ACCESS_COARSE_LOCATION}, LOCATION_PERMISSION_REQUEST_CODE); } } } 

EN Votre classe d’activité:

  public class MainActivity extends AppCompatActivity{ private MarshMallowPermission marshMallowPermission; @Override protected void onCreate(Bundle savedInstanceState) { Log.d("NavHome", "Oncreate_nav"); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); marshMallowPermission = new MarshMallowPermission(MainActivity.this); if (!marshMallowPermission.checkPermissionForExternalStorage()) { marshMallowPermission.requestPermissionForExternalStorage(MarshMallowPermission.EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE); } } @Override public void onRequestPermissionsResult(int requestCode, Ssortingng[] permissions, int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); switch (requestCode) { case MarshMallowPermission.EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE: if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { //permission granted successfully } else { //permission denied } break; } } } 

J’utilise ceci comme une classe de fragment de base. Je demande uniquement des permissions à partir d’un fragment, mais vous pouvez le refactoriser et en faire une version d’activité similaire.

 public class BaseFragment extends Fragment { private static final int PERMISSION_REQUEST_BLOCK_INTERNAL = 555; private static final Ssortingng PERMISSION_SHARED_PREFERENCES = "permissions"; @Override public void onRequestPermissionsResult(int requestCode, @NonNull Ssortingng[] permissions, @NonNull int[] grantResults) { if (requestCode == PERMISSION_REQUEST_BLOCK_INTERNAL) { boolean allPermissionsGranted = true; for (int iGranting : grantResults) { if (iGranting != PermissionChecker.PERMISSION_GRANTED) { allPermissionsGranted = false; break; } } if (allPermissionsGranted && permissionBlock != null) { permissionBlock.run(); } permissionBlock = null; } } public void runNowOrAskForPermissionsFirst(Ssortingng permission, Runnable block) { if (hasPermission(permission)) { block.run(); } else if (!hasPermissionOrWillAsk(permission)) { permissionBlock = block; askForPermission(permission, PERMISSION_REQUEST_BLOCK_INTERNAL); } } public boolean hasPermissionOrWillAsk(Ssortingng permission) { boolean hasPermission = hasPermission(permission); boolean hasAsked = hasPreviouslyAskedForPermission(permission); boolean shouldExplain = shouldShowRequestPermissionRationale(permission); return hasPermission || (hasAsked && !shouldExplain); } private boolean hasPermission(Ssortingng permission) { return (ContextCompat.checkSelfPermission(getContext(), permission) == PackageManager.PERMISSION_GRANTED); } private boolean hasPreviouslyAskedForPermission(Ssortingng permission) { SharedPreferences prefs = getContext().getSharedPreferences(PERMISSION_SHARED_PREFERENCES, Context.MODE_PRIVATE); return prefs.getBoolean(permission, false); } private void askForPermission(Ssortingng permission, int requestCode) { SharedPreferences.Editor editor = getContext().getSharedPreferences(PERMISSION_SHARED_PREFERENCES, Context.MODE_PRIVATE).edit(); editor.putBoolean(permission, true); editor.apply(); requestPermissions(new Ssortingng[] { permission }, requestCode); } } 

Vous devez utiliser deux méthodes principales:

  • hasPermissionOrWillAsk – Utilisez ceci pour voir si une autorisation a été demandée et refusée par un utilisateur qui ne veut pas être interrogé à nouveau. Ceci est utile pour désactiver l’interface utilisateur lorsque l’utilisateur a donné sa réponse finale sur le fait de ne PAS vouloir une fonctionnalité.

  • runNowOrAskForPermissionsFirst – Utilisez ceci pour exécuter du code qui nécessite des permissions. Si l’utilisateur a déjà accordé la permission, le code s’exécutera immédiatement. Sinon, le code s’exécutera plus tard si l’utilisateur accorde la permission. Ou pas du tout. C’est bien parce que vous spécifiez le code en un seul endroit.

Voici un exemple:

 mFragment.runNowOrAskForPermissionsFirst(Manifest.permission.ACCESS_FINE_LOCATION, new Runnable() { @Override public void run() { ...do something if we have permission... } }); 

Heureux d’avoir des commentaires à ce sujet. Bien que cet exemple spécifique ne soit pas un peu simplifié, vous devez également vérifier si les services de localisation sont activés sur le périphérique. (Cela diffère des permissions.) En outre, il ne prend en charge qu’une seule autorisation à la fois, mais il serait simple à modifier si vous en avez besoin pour prendre en charge plusieurs applications à la fois.

Ce peut être une façon plus propre. Ajoutez toutes vos permissions dans un tableau comme

 private static final Ssortingng[] INITIAL_PERMS={ android.Manifest.permission.ACCESS_FINE_LOCATION, android.Manifest.permission.ACCESS_COARSE_LOCATION }; private static final int INITIAL_REQUEST=1337; 

Quelle que soit votre méthode de création, créez une méthode pour chaque permision

 @RequiresApi(api = Build.VERSION_CODES.M) private boolean canAccessFineLocation() { return(hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)); } @RequiresApi(api = Build.VERSION_CODES.M) private boolean canAccessCoarseLocation() { return(hasPermission(Manifest.permission.ACCESS_COARSE_LOCATION)); } @RequiresApi(api = Build.VERSION_CODES.M) private boolean hasPermission(Ssortingng perm) { return(PackageManager.PERMISSION_GRANTED == checkSelfPermission(perm)); } 

Appelez cette méthode dans onCreate

  if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){ if(!canAccessCoarseLocation() || !canAccessFineLocation()){ requestPermissions(INITIAL_PERMS, INITIAL_REQUEST); } } 

Maintenant, remplacez surRequestPermissionsResult

 @Override public void onRequestPermissionsResult(int requestCode, @NonNull Ssortingng[] permissions, @NonNull int[] grantResults) { if(requestCode == INITIAL_REQUEST){ if (canAccessFineLocation() && canAccessCoarseLocation()) { //call your method } else { //show Toast or alert that this permissions is neccessary } } } 

Pour gérer l’autorisation d’exécution, Google a fourni un projet de bibliothèque. Vous pouvez le vérifier ici https://github.com/googlesamples/easypermissions

EasyPermissions est installé en ajoutant la dépendance suivante à votre fichier build.gradle:

 dependencies { comstack 'pub.devrel:easypermissions:0.3.0' } 

Pour commencer à utiliser EasyPermissions, faites en sorte que votre activité (ou fragment) remplace la méthode onRequestPermissionsResult:

 public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public void onRequestPermissionsResult(int requestCode, Ssortingng[] permissions, int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); // Forward results to EasyPermissions EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this); } @Override public void onPermissionsGranted(int requestCode, List list) { // Some permissions have been granted // ... } @Override public void onPermissionsDenied(int requestCode, List list) { // Some permissions have been denied // ... } } 

Ici, vous obtiendrez un exemple de fonctionnement de cette bibliothèque https://github.com/milon87/EasyPermission

Pour une autorisation multiple à la fois, vous pouvez l’utiliser. Ce travail pour moi .. J’ai une autre solution. Si vous donnez votre targetSdkVersion ci-dessous 22, cela fonctionne pour moi. et le comportement comme obtenir la permission de manifest.xml. Testé et travaille pour moi.

 final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124; private void insertDummyContactWrapper() { List permissionsNeeded = new ArrayList(); final List permissionsList = new ArrayList(); 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 Ssortingng 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 permissionsList, Ssortingng permission) { if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) { permissionsList.add(permission); // Check for Rationale Option if (!shouldShowRequestPermissionRationale(permission)) return false; } return true; } @Override public void onRequestPermissionsResult(int requestCode, Ssortingng[] permissions, int[] grantResults) { switch (requestCode) { case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: { Map perms = new HashMap(); // Initial perms.put(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.PERMISSION_GRANTED); perms.put(Manifest.permission.READ_CONTACTS, PackageManager.PERMISSION_GRANTED); perms.put(Manifest.permission.WRITE_CONTACTS, PackageManager.PERMISSION_GRANTED); // Fill with results for (int i = 0; i < permissions.length; i++) perms.put(permissions[i], grantResults[i]); // Check for ACCESS_FINE_LOCATION if (perms.get(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED && perms.get(Manifest.permission.READ_CONTACTS) == PackageManager.PERMISSION_GRANTED && perms.get(Manifest.permission.WRITE_CONTACTS) == PackageManager.PERMISSION_GRANTED) { // All Permissions Granted insertDummyContact(); } else { // Permission Denied Toast.makeText(MainActivity.this, "Some Permission is Denied", Toast.LENGTH_SHORT) .show(); } } break; default: super.onRequestPermissionsResult(requestCode, permissions, grantResults); } } 

Pour plus de détails. Cochez le lien ci-dessous

https://inthecheesefactory.com/blog/things-you-need-to-know-about-android-m-permission-developer-edition/en

Il existe une bonne bibliothèque qui peut être utilisée si des permissions doivent être demandées lorsqu’une autorisation est requirejse par un service d’arrière-plan. Bien qu’une limitation de la bibliothèque, c’est qu’elle ne peut pas être utilisée pour simplement déterminer si des permissions sont actuellement données à l’application ou non. Il demande toujours à l’utilisateur si l’application ne les a pas déjà.

Essayez-le car il simplifie la vie: Autorisations Android

Essaye ça

C’est le moyen le plus simple de demander une autorisation dans la version de Marshmallow.

  if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED&&ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) { //TO do here if permission is granted by user } else { //ask for permission if user didnot given if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { requestPermissions(new Ssortingng[]{Manifest.permission.CAMERA,Manifest.permission.ACCESS_FINE_LOCATION}, 0); } } 

Remarque: – N’oubliez pas d’append cette même autorisation dans le fichier manifeste également

    

Deuxième méthode Code pour vérifier la permission est accordée ou non?

 ActivityCompat.requestPermissions(MainActivity.this, new Ssortingng[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.CAMERA}, 1); 

Et remplacer la méthode

 @Override public void onRequestPermissionsResult(int requestCode, Ssortingng permissions[], int[] grantResults) { switch (requestCode) { case 1: { if (grantResults.length > 0 && grantResults[1] == PackageManager.PERMISSION_GRANTED) { // grantResult[0] means it will check for the first postion permission which is READ_EXTERNAL_STORAGE // grantResult[1] means it will check for the Second postion permission which is CAMERA Toast.makeText(this, "Permission Granted", Toast.LENGTH_SHORT).show(); } else Toast.makeText(this, "Permission not Granted", Toast.LENGTH_SHORT).show(); return; } } } 

Ce code ci-dessous fonctionne parfaitement.Je l’explique à l’aide d’un exemple.

Dans mon cas, j’ai placé les contrôles d’autorisation séparément dans une classe util et passé les permissions spécifiques dont j’ai besoin pour vérifier les classes appropriées. Ceci permet de réutiliser le fichier util check d’autorisation dans toute l’application.

La partie de code ci-dessous montre l’appel de la fonction. Dans ce cas, demande l’autorisation android.Manifest.permission.READ_EXTERNAL_STORAGE .

 //the below call is from a fragment @OnClick(R.id.button)//butterknife implementation public void attachPressed() { if (PermissionUtils.hasThisPermission(getContext(), android.Manifest.permission.READ_EXTERNAL_STORAGE)) { onAttachPressed(); } else { PermissionUtils.isPermissionRequestNeeded(getActivity(), this, android.Manifest.permission.READ_EXTERNAL_STORAGE, PermissionUtils.REQUEST_GROUP_STORAGE); } } 

Dans le cas ci-dessus, la permission est cochée si on permet le onAttachPressed(); la fonction est appelée sinon nous vérifions l’autorisation de demande.

Le ci-dessous est le code présent dans la classe util dans mon cas PermissionUtils

 public final class PermissionUtils { public static final int REQUEST_GROUP_STORAGE = 1508; private PermissionUtils() { } public static boolean hasThisPermission(Context context, Ssortingng permission) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { return ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED; } else { return true; } } public static boolean isPermissionRequestNeeded(Activity activity, Fragment fragment, Ssortingng permission, int requestCode) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !hasThisPermission(activity, permission)) { final Ssortingng[] permissions = new Ssortingng[]{permission}; if (fragment == null) { activity.requestPermissions(permissions, requestCode); } else { fragment.requestPermissions(permissions, requestCode); } return true; } return false; } } 

Et après la requête, si vous souhaitez appeler la fonction onRequestPermissionsResult ou vous devrez appuyer à nouveau sur le bouton pour l’appel de la fonction.

Alors, appelez-le simplement sur onRequestPermissionsResult

 //the below call is from a fragment @Override public void onRequestPermissionsResult(int requestCode, Ssortingng[] permissions, int[] grantResults) { if (requestCode == PermissionUtils.REQUEST_GROUP_STORAGE && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { onAttachPressed(); } else { Log.e("value", "Permission Denied, You cannot use local drive ."); } } 

Un moyen simple de demander la permission en évitant d’écrire beaucoup de code,

https://github.com/sachinvarma/EasyPermission

Comment append :

 repositories { maven { url "https://jitpack.io" } } implementation 'com.github.sachinvarma:EasyPermission:1.0.1' 

Comment demander la permission:

  List permission = new ArrayList<>(); permission.add(EasyPermissionList.READ_EXTERNAL_STORAGE); permission.add(EasyPermissionList.ACCESS_FINE_LOCATION); new EasyPermissionInit(MainActivity.this, permission); 

En espérant que cela sera utile pour quelqu’un.

  if (CommonMethod.isNetworkAvailable(MainActivity.this)) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { int permissionCheck = ContextCompat.checkSelfPermission(MainActivity.this, android.Manifest.permission.CAMERA); if (permissionCheck == PackageManager.PERMISSION_GRANTED) { //showing dialog to select image callFacebook(); Log.e("permission", "granted MarshMallow"); } else { ActivityCompat.requestPermissions(MainActivity.this, new Ssortingng[]{android.Manifest.permission.READ_EXTERNAL_STORAGE, android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.CAMERA}, 1); } } else { Log.e("permission", "Not Required Less than MarshMallow Version"); callFacebook(); } } else { CommonMethod.showAlert("Internet Connectivity Failure", MainActivity.this); } 

Vous pouvez utiliser ma bibliothèque – NoPermission (c’est juste une classe)

comstack 'ru.alexbykov:nopermission:1.1.1'

Échantillon

 PermissionHelper permissionHelper = new PermissionHelper(this); //don't use getActivity in fragment! permissionHelper.check(Manifest.permission.READ_CONTACTS) .onSuccess(this::onSuccess) .onDenied(this::onDenied) .onNeverAskAgain(this::onNeverAskAgain) .run(); 

onRequestPermissionResult:

  @Override public void onRequestPermissionsResult(int requestCode, @NonNull Ssortingng[] permissions, @NonNull int[] grantResults) permissionHelper.onRequestPermissionsResult(requestCode, permissions, grantResults); } 

Je pense que l’API est plus pratique que EasyPermissions de Google.

J’utilise la bibliothèque de bibliothèque RxPermission pour demander la permission. Parce que c’est un long code qu’il faut écrire pour demander la permission.

 RxPermissions rxPermissions = new RxPermissions(this); // where this is an Activity instance // Must be done during an initialization phase like onCreate rxPermissions .request(Manifest.permission.CAMERA) .subscribe(granted -> { if (granted) { // Always true pre-M // I can control the camera now } else { // Oups permission denied } }); 

Ajoutez ces dépendances dans votre build.gradle

 allprojects { repositories { ... maven { url 'https://jitpack.io' } } } dependencies { implementation 'com.github.tbruyelle:rxpermissions:0.10.1' implementation 'com.jakewharton.rxbinding2:rxbinding:2.1.1' } 

Runtime Permission AnyWhere Dans Application Voici Exemple

 use dependency maven { url 'https://jitpack.io' } dependencies { implementation 'com.github.irshadsparky:PermissionLib:master-SNAPSHOT' } 

et appeler le code comme ceci:

 PermissionHelper.requestCamera(new PermissionHelper.OnPermissionGrantedListener() { @Override public void onPermissionGranted() { } }); 

vous pouvez trouver plus de Github