Erreur d'autorisation de stockage dans Marshmallow


159

Dans Lollipop, la fonctionnalité de téléchargement fonctionne correctement dans mon application, mais lorsque je suis passé à Marshmallow, mon application se bloque et donne cette erreur lorsque j'essaye de télécharger depuis Internet sur la carte SD:

Neither user  nor current process has android.permission.WRITE_EXTERNAL_STORAGE

Il se plaint de cette ligne de code:

DownloadManager manager = (DownloadManager) getSystemService(Context.DOWNLOAD_SERVICE);
manager.enqueue(request);

J'ai les autorisations dans l'application manifeste en dehors:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />

J'ai nettoyé et reconstruit le projet, mais il plante toujours.


Essayez ceci, cela peut vous aider: - stackoverflow.com/a/41221852/5488468
Bipin Bharti

J'ai préparé une bibliothèque qui aidera à gérer facilement les autorisations d'exécution. github.com/nabinbhandari/Android-Permissions
Nabin Bhandari

Réponses:


357

Vous devez vérifier si l'utilisateur a accordé l'autorisation de stockage externe en utilisant:

if (checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
    Log.v(TAG,"Permission is granted");
    //File write logic here
    return true;
}

Sinon, vous devez demander à l'utilisateur d'accorder une autorisation à votre application:

ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_CODE);

Bien sûr, ce ne sont que pour les appareils guimauve, vous devez donc vérifier si votre application fonctionne sur Marshmallow:

 if (Build.VERSION.SDK_INT >= 23) {
      //do your check here
 }

Assurez-vous également que votre activité met en œuvre OnRequestPermissionResult

La permission entière ressemble à ceci:

public  boolean isStoragePermissionGranted() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if (checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
                == PackageManager.PERMISSION_GRANTED) {
            Log.v(TAG,"Permission is granted");
            return true;
        } else {

            Log.v(TAG,"Permission is revoked");
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
            return false;
        }
    }
    else { //permission is automatically granted on sdk<23 upon installation
        Log.v(TAG,"Permission is granted");
        return true;
    }
}

Rappel du résultat de l'autorisation:

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){
        Log.v(TAG,"Permission: "+permissions[0]+ "was "+grantResults[0]);
        //resume tasks needing this permission
    }
}

2
@Houssem heureux de vous aider.!
MetaSnarf

14
Cela ne fonctionne pas pour l'API> = 23, la demande d'autorisation pour Manifest.permission.WRITE_EXTERNAL_STORAGErenvoie toujours «-1», c'est-à-dire que l'autorisation est refusée. Consultez la nouvelle documentation, elle indique que pour l'API 19, vous n'avez pas besoin de l' WRITE_EXTERNAL_STORAGEautorisation. Comme certains des commentaires ci-dessus mentionnés, vous devriez faire tout cela avec leManifest.permission.READ_EXTERNAL_STORAGE
AmeyaB

3
@VSB: C'est dans un endroit étrange mais vous y voilà: developer.android.com/guide/topics/manifest/…
AmeyaB

3
@AmeyB Comme indiqué dans la documentation, pour API> = 19, l'autorisation d'écrire sur le stockage externe n'est pas nécessaire pour être déclarée SI l' application va utiliser son propre répertoire spécifique sur le stockage externe qui est retourné par getExternalFilesDir(). Dans d'autres cas, l'autorisation android.permission.WRITE_EXTERNAL_STORAGEdoit toujours être déclarée dans manfiest.
VSB

1
Oui, c'est corrigé. Le problème était lié à la bibliothèque d'applications de hockey. cette bibliothèque a remplacé mon autorisation d'écriture. @MetaSnarf
Selin

38

Le système d'autorisation d'Android est l'un des plus gros problèmes de sécurité depuis le début, car ces autorisations sont demandées au moment de l'installation. Une fois installée, l'application pourra accéder à toutes les choses accordées sans que l'utilisateur ne reconnaisse ce que fait exactement l'application avec l'autorisation.

Android 6.0 Marshmallow introduit l'un des changements les plus importants dans le modèle d'autorisations avec l'ajout d'autorisations d'exécution, un nouveau modèle d'autorisation qui remplace le modèle d'autorisations d'installation existant lorsque vous ciblez l'API 23 et que l'application s'exécute sur un appareil Android 6.0+

La courtoisie va à la demande d'autorisations au moment de l'exécution .

Exemple

Déclarez cela comme Global

private static final int PERMISSION_REQUEST_CODE = 1;

Ajoutez ceci dans votre onCreate()section

Après setContentView (R.layout.your_xml);

 if (Build.VERSION.SDK_INT >= 23)
    {
        if (checkPermission())
        {
            // Code for above or equal 23 API Oriented Device 
            // Your Permission granted already .Do next code
        } else {
            requestPermission(); // Code for permission
        }
    }
  else
    {

       // Code for Below 23 API Oriented Device 
       // Do next code
    }

Ajout de checkPermission () et requestPermission ()

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

private void requestPermission() {

    if (ActivityCompat.shouldShowRequestPermissionRationale(Your_Activity.this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
        Toast.makeText(Your_Activity.this, "Write External Storage permission allows us to do store images. Please allow this permission in App Settings.", Toast.LENGTH_LONG).show();
    } else {
        ActivityCompat.requestPermissions(Your_Activity.this, new String[]{android.Manifest.permission.WRITE_EXTERNAL_STORAGE}, PERMISSION_REQUEST_CODE);
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case PERMISSION_REQUEST_CODE:
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Log.e("value", "Permission Granted, Now you can use local drive .");
            } else {
                Log.e("value", "Permission Denied, You cannot use local drive .");
            }
            break;
    }
}

FYI

onRequestPermissionsResult

Cette interface est le contrat de réception des résultats des demandes d'autorisation.


29

Vérifiez plusieurs autorisations au niveau de l'API 23 Étape 1:

 String[] permissions = new String[]{
        Manifest.permission.INTERNET,
        Manifest.permission.READ_PHONE_STATE,
        Manifest.permission.READ_EXTERNAL_STORAGE,
        Manifest.permission.WRITE_EXTERNAL_STORAGE,
        Manifest.permission.VIBRATE,
        Manifest.permission.RECORD_AUDIO,
};

Étape 2:

 private boolean checkPermissions() {
    int result;
    List<String> listPermissionsNeeded = new ArrayList<>();
    for (String p : permissions) {
        result = ContextCompat.checkSelfPermission(this, p);
        if (result != PackageManager.PERMISSION_GRANTED) {
            listPermissionsNeeded.add(p);
        }
    }
    if (!listPermissionsNeeded.isEmpty()) {
        ActivityCompat.requestPermissions(this, listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]), 100);
        return false;
    }
    return true;
}

Étape 3:

 @Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    if (requestCode == 100) {
        if (grantResults.length > 0
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // do something
        }
        return;
    }
}

Étape 4: dans onCreate of Activity checkPermissions ();


2
Merci. Cela ressemble à une réponse prometteuse pour plusieurs autorisations. Mais il manque un peu d'exemples. Comment gère-t-il never ask againet manque-t-il quelques autorisations? L'utilisateur reçoit-il des commentaires? Cela aurait été bien de voir un exemple réel de cela ou plus de commentaires sur vos extraits de code.
not2qubit

Pour faire face, ne demandez pas à nouveau d'entourer l'ajout aux autorisations si bloquez avec if (shouldshowpermissionrationale ()) {} ... c'est vrai si l'autorisation est nécessaire et pas à jamais rejetée
me_

Celui-ci devrait être la réponse correcte et optimisée.
VikaS GuttE

21

À moins qu'il n'y ait une exigence précise d'écriture sur un stockage externe, vous pouvez toujours choisir d'enregistrer les fichiers dans le répertoire de l'application. Dans mon cas, j'ai dû enregistrer des fichiers et après avoir perdu 2 à 3 jours, j'ai découvert si je modifiais le chemin de stockage de

Environment.getExternalStorageDirectory()

à

getApplicationContext().getFilesDir().getPath() //which returns the internal app files directory path

cela fonctionne comme du charme sur tous les appareils. En effet, pour écrire sur le stockage externe, vous avez besoin d'autorisations supplémentaires, mais l'écriture dans le répertoire interne de l'application est simple.


où écrivez-vous ce code? Je ne me souviens pas avoir utilisé Environment.getExternalStorageDiretory () sur mon code
royjavelosa

5

vous devez utiliser l'autorisation d'exécution dans marshmallow https://developer.android.com/training/permissions/requesting.html

vous pouvez vérifier les informations de l'application -> autorisation

votre application obtient-elle l'autorisation d'écrire sur le stockage externe ou non


2
en fait, cette information sur l'application de réponse -> l'autorisation a résolu le crash :), mais j'ai accepté l'autre réponse pour les détails de ce qu'il faut faire. Je souhaite que je puisse accepter les deux Merci beaucoup
Badr

Merci d'avoir corrigé le problème de
blocage

4

Il semble que l'utilisateur a refusé l'autorisation et que l'application tente d'écrire sur le disque externe, provoquant une erreur.

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

Vérifiez https://developer.android.com/training/permissions/requesting.html

Cette vidéo vous donnera une meilleure idée de l'UX, de la gestion des autorisations d'exécution https://www.youtube.com/watch?v=iZqDdvhTZj0


1

À partir de la version marshmallow, les développeurs doivent demander des autorisations d'exécution à l'utilisateur. Permettez-moi de vous donner tout le processus pour demander des autorisations d'exécution.

J'utilise la référence d'ici: autorisations d'exécution de guimauve android .

Créez d'abord une méthode qui vérifie si toutes les autorisations sont données ou non

private  boolean checkAndRequestPermissions() {
        int camerapermission = ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA);
        int writepermission = ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE);
        int permissionLocation = ContextCompat.checkSelfPermission(this,Manifest.permission.ACCESS_FINE_LOCATION);
        int permissionRecordAudio = ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO);


        List<String> listPermissionsNeeded = new ArrayList<>();

        if (camerapermission != PackageManager.PERMISSION_GRANTED) {
            listPermissionsNeeded.add(Manifest.permission.CAMERA);
        }
        if (writepermission != PackageManager.PERMISSION_GRANTED) {
            listPermissionsNeeded.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
        }
        if (permissionLocation != PackageManager.PERMISSION_GRANTED) {
            listPermissionsNeeded.add(Manifest.permission.ACCESS_FINE_LOCATION);
        }
        if (permissionRecordAudio != PackageManager.PERMISSION_GRANTED) {
            listPermissionsNeeded.add(Manifest.permission.RECORD_AUDIO);
        }
        if (!listPermissionsNeeded.isEmpty()) {
            ActivityCompat.requestPermissions(this, listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]), REQUEST_ID_MULTIPLE_PERMISSIONS);
            return false;
        }
        return true;
    } 

Voici maintenant le code qui est exécuté après la méthode ci-dessus. Nous remplacerons la onRequestPermissionsResult()méthode:

 @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        Log.d(TAG, "Permission callback called-------");
        switch (requestCode) {
            case REQUEST_ID_MULTIPLE_PERMISSIONS: {

                Map<String, Integer> perms = new HashMap<>();
                // Initialize the map with both permissions
                perms.put(Manifest.permission.CAMERA, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.WRITE_EXTERNAL_STORAGE, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.RECORD_AUDIO, PackageManager.PERMISSION_GRANTED);
                // Fill with actual results from user
                if (grantResults.length > 0) {
                    for (int i = 0; i < permissions.length; i++)
                        perms.put(permissions[i], grantResults[i]);
                    // Check for both permissions
                    if (perms.get(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
                            && perms.get(Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED 
&& perms.get(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED 
&& perms.get(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED) {
                        Log.d(TAG, "sms & location services permission granted");
                        // process the normal flow
                        Intent i = new Intent(MainActivity.this, WelcomeActivity.class);
                        startActivity(i);
                        finish();
                        //else any one or both the permissions are not granted
                    } else {
                        Log.d(TAG, "Some permissions are not granted ask again ");
                        //permission is denied (this is the first time, when "never ask again" is not checked) so ask again explaining the usage of permission
//                        // shouldShowRequestPermissionRationale will return true
                        //show the dialog or snackbar saying its necessary and try again otherwise proceed with setup.
                        if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA) 
|| ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) 
|| ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)
 || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.RECORD_AUDIO)) {
                            showDialogOK("Service Permissions are required for this app",
                                    new DialogInterface.OnClickListener() {
                                        @Override
                                        public void onClick(DialogInterface dialog, int which) {
                                            switch (which) {
                                                case DialogInterface.BUTTON_POSITIVE:
                                                    checkAndRequestPermissions();
                                                    break;
                                                case DialogInterface.BUTTON_NEGATIVE:
                                                    // proceed with logic by disabling the related features or quit the app.
                                                    finish();
                                                    break;
                                            }
                                        }
                                    });
                        }
                        //permission is denied (and never ask again is  checked)
                        //shouldShowRequestPermissionRationale will return false
                        else {
                            explain("You need to give some mandatory permissions to continue. Do you want to go to app settings?");
                            //                            //proceed with logic by disabling the related features or quit the app.
                        }
                    }
                }
            }
        }

    }

Si l'utilisateur clique sur l' option Refuser , la showDialogOK()méthode sera utilisée pour afficher la boîte de dialogue

Si l'utilisateur clique sur Refuser et clique également sur une case à cocher disant "ne plus jamais demander" , alors la explain()méthode sera utilisée pour afficher la boîte de dialogue.

méthodes pour afficher les boîtes de dialogue:

 private void showDialogOK(String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(this)
                .setMessage(message)
                .setPositiveButton("OK", okListener)
                .setNegativeButton("Cancel", okListener)
                .create()
                .show();
    }
    private void explain(String msg){
        final android.support.v7.app.AlertDialog.Builder dialog = new android.support.v7.app.AlertDialog.Builder(this);
        dialog.setMessage(msg)
                .setPositiveButton("Yes", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                        //  permissionsclass.requestPermission(type,code);
                        startActivity(new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:com.exampledemo.parsaniahardik.marshmallowpermission")));
                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface paramDialogInterface, int paramInt) {
                        finish();
                    }
                });
        dialog.show();
    }

L'extrait de code ci-dessus demande quatre autorisations à la fois. Vous pouvez également demander un nombre illimité d'autorisations dans toute activité selon vos besoins.


0

Après de nombreuses recherches, ce code fonctionne pour moi:

Vérifiez que l'autorisation a déjà: Vérifiez l'autorisation WRITE_EXTERNAL_STORAGE Autorisée ou non?

if(isReadStorageAllowed()){
            //If permission is already having then showing the toast
            //Toast.makeText(SplashActivity.this,"You already have the permission",Toast.LENGTH_LONG).show();
            //Existing the method with return
            return;
        }else{
            requestStoragePermission();
        }



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

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

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

//Requesting permission
private void requestStoragePermission(){

    if (ActivityCompat.shouldShowRequestPermissionRationale(this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE)){
        //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
    }

    //And finally ask for the permission
    ActivityCompat.requestPermissions(this,new String[]{android.Manifest.permission.WRITE_EXTERNAL_STORAGE},REQUEST_WRITE_STORAGE);
}

Implémenter la méthode Override onRequestPermissionsResult pour vérifier si l'utilisateur autorise ou refuse

 @Override
 public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    //Checking the request code of our request
    if(requestCode == REQUEST_WRITE_STORAGE){

        //If permission is granted
        if(grantResults.length >0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){

            //Displaying a toast
            Toast.makeText(this,"Permission granted now you can read the storage",Toast.LENGTH_LONG).show();

        }else{
            //Displaying another toast if permission is not granted
            Toast.makeText(this,"Oops you just denied the permission",Toast.LENGTH_LONG).show();
        }
    }

0

ça a marché pour moi

 boolean hasPermission = (ContextCompat.checkSelfPermission(AddContactActivity.this,
            Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED);
    if (!hasPermission) {
        ActivityCompat.requestPermissions(AddContactActivity.this,
                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                REQUEST_WRITE_STORAGE);
    }

   @Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode)
    {
        case REQUEST_WRITE_STORAGE: {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED)
            {
                //reload my activity with permission granted or use the features what required the permission
            } else
            {
                Toast.makeText(AddContactActivity.this, "The app was not allowed to write to your storage. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show();
            }
        }
    }

}

0
   Try this



int permission = ContextCompat.checkSelfPermission(MainActivity.this,
                    android.Manifest.permission.WRITE_EXTERNAL_STORAGE);

     if (permission != PackageManager.PERMISSION_GRANTED) {
                Log.i("grant", "Permission to record denied");

                if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                        android.Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                    AlertDialog.Builder builder = new AlertDialog.Builder(this);
                    builder.setMessage(getString(R.string.permsg))
                            .setTitle(getString(R.string.permtitle));

                    builder.setPositiveButton(getString(R.string.ok), new DialogInterface.OnClickListener() {

                        public void onClick(DialogInterface dialog, int id) {
                            Log.i("grant", "Clicked");
                            makeRequest();
                        }
                    });

                    AlertDialog dialog = builder.create();
                    dialog.show();

                } else {

                    //makeRequest1();
                    makeRequest();
                }
            }


     protected void makeRequest() {
            ActivityCompat.requestPermissions(this,
                    new String[]{android.Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    500);
        }



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

                    if (grantResults.length == 0
                            || grantResults[0] !=
                            PackageManager.PERMISSION_GRANTED) {

                        Log.i("1", "Permission has been denied by user");

                    } else {

                        Log.i("1", "Permission has been granted by user");

                    }
                    return;
                }

            }
        }

0

Avant de commencer votre téléchargement, vérifiez vos autorisations d'exécution et si vous n'en avez pas les autorisations de demande comme cette méthode

requestStoragePermission ()

private void requestStoragePermission(){
    if (ActivityCompat.shouldShowRequestPermissionRationale(this, 
                android.Manifest.permission.READ_EXTERNAL_STORAGE))
        {

        }

        ActivityCompat.requestPermissions(this, 
            new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
            STORAGE_PERMISSION_CODE);
}

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

    if(requestCode == STORAGE_PERMISSION_CODE){
        if(grantResults.length >0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){
        }
        else{
            Toast.makeText(this,
                           "Oops you just denied the permission", 
                           Toast.LENGTH_LONG).show();
        }
    }
}

0

D'une manière simple, l'autorisation peut être accordée en utilisant le fichier manifest.xml, mais c'était ok jusqu'au niveau de l'api 23 sdk version 6, après d'ici, si nous voulons obtenir l'autorisation, nous devons demander l'utilisation pour autoriser l'autorisation qui sont nécessaires.

Ajoutez simplement ce code dans le mainActivity.java

Override
            public void onClick(View view) {
                // Request the permission
                ActivityCompat.requestPermissions(MainActivity.this,
                        new String[]{Manifest.permission.CAMERA},
                        PERMISSION_REQUEST_CAMERA);

Remplacez CAMERA ou ajoutez avec WRITE_EXTERNAL_STORAGE si vous le souhaitez, et avec le code unique.

                            new String[]{Manifest.permission.CAMERA,
Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    101);

Ceci est le code simple pour obtenir la permission.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.