Storage permission error in Marshmallow

Question

In Lollipop, the download functionality works fine in my app, but when I upgraded to Marshmallow, my app crashes and gives this error when I try to download from the internet into the SD card:

Neither user  nor current process has android.permission.WRITE_EXTERNAL_STORAGE

It complains about this line of code:

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

I have the permissions in the manifest outside application:

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

I cleaned and rebuilt the project, but it still crashes.

Try this it may be help you:-http://stackoverflow.com/a/41221852/5488468 — Bipin Bharti, Dec 20 '16 at 11:00
I have prepared a library which will help to handle runtime permissions easily. https://github.com/nabinbhandari/Android-Permissions — Nabin Bhandari, Oct 06 '17 at 03:24

score 389 · Accepted Answer · edited Apr 24 '19 at 11:04

389

You should be checking if the user has granted permission of external storage by using:

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

If not, you need to ask the user to grant your app a permission:

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

Of course these are for marshmallow devices only so you need to check if your app is running on Marshmallow:

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

Be also sure that your activity implements OnRequestPermissionResult

The entire permission looks like this:

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

Permission result callback:

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

edited Apr 24 '19 at 11:04

Atif Mahmood

8,882
2
41
44

answered Oct 16 '15 at 04:11

MetaSnarf

5,857
3
25
41

2

@Houssem glad to help.! – MetaSnarf Jun 23 '16 at 05:55
Reading .you mean checking if a permission is granted? – MetaSnarf Jul 27 '16 at 07:48
Yes, the ``manifest equivalent. – Cedric Jul 27 '16 at 08:02
Yes, you can use the `isStoragePermissiionGranted()` method. Just change the requested permission to `READ_EXTERNAL_STORAGE` . – MetaSnarf Jul 27 '16 at 08:27
22

This does not work for API >=23, requesting permission for `Manifest.permission.WRITE_EXTERNAL_STORAGE` always returns '-1' i.e Permission denied. Check the new documentation, it says that for API 19 onwards, you do not need the `WRITE_EXTERNAL_STORAGE` permission. As some of the above comments mentioned, you should do all of this with the `Manifest.permission.READ_EXTERNAL_STORAGE` – AmeyaB Aug 01 '16 at 22:01
@AmeyaB can provide link for the referred documentation? – VSB Oct 18 '16 at 06:26
3

@VSB: Its in weird place but here you go: https://developer.android.com/guide/topics/manifest/uses-permission-element.html – AmeyaB Oct 18 '16 at 19:54
3

@AmeyB As documentation said, for API>=19, permission to write on external storage is not required to be declared **IF** application is going to use its own specific directory on external storage which is returned by `getExternalFilesDir()`. In other cases, still permission `android.permission.WRITE_EXTERNAL_STORAGE` must be declared in manfiest. – VSB Oct 19 '16 at 04:57
I had the same problem while migrating from Eclipse to Android Studio, it seems that Eclipse code pass this checks, and in studio developer certainly should check this in higher APIs – Ahmad Ebrahimi Dec 13 '16 at 22:05
@MetaSnarf thank you for a good answer, I using **isStoragePermissionGranted** method for the same purpose but when I trying it on my device > lollipop 5.5 SDK_INT 22, it's not calling **onRequestPermissionsResult** and therefore the task on it will not starting if anyone has solution for this please share it with me – Dr Mido Jan 17 '18 at 22:45
@DrMido did you set the requestPermission callback class to the same class where your onRequestPermissionResult is? – MetaSnarf Mar 20 '18 at 09:27
I have tried this solution but grantResult is -1 onRequestPermissionsResult. I can't take this permission on runtime, so I can't use DowloadManager. I have tried for READ_EXTERNAL_STORAGE permission, I could take that permission but it didn't work for WRITE_EXTERNAL_STORAGE permission. Have you any idea for this situation? – Selin Nov 07 '18 at 14:50
@Selin Can you show your permission code to me? you can ask a different question an link it here. – MetaSnarf Nov 16 '18 at 06:04
Thanks @MetaSnarf We fixed in here: https://stackoverflow.com/questions/53192161/permission-dialog-is-not-shown-for-write-external-storage – Selin Nov 19 '18 at 06:52
@Selin I can see that one answer solves your problem. Did it already solve your issue? I think the permission pop out problem you have is related to the user tapping never ask again when it asked once. – MetaSnarf Nov 19 '18 at 13:25
1

Yes it fixed. The problem was related to hockey app library. this library has been overriding my write permission. @MetaSnarf – Selin Nov 19 '18 at 13:34
@Selin, I see. Good then :) – MetaSnarf Nov 20 '18 at 04:21
ActivityCompat.requestPermiss.... as that the second part just worked on onCreate by me. – Bay Sep 15 '19 at 09:53

IntelliJ Amiya · Answer 2 · 2017-01-17T11:19:13.740

Android's permission system is one of the biggest security concern all along since those permissions are asked for at install time. Once installed, the application will be able to access all of things granted without any user's acknowledgement what exactly application does with the permission.

Android 6.0 Marshmallow introduces one of the largest changes to the permissions model with the addition of runtime permissions, a new permission model that replaces the existing install time permissions model when you target API 23 and the app is running on an Android 6.0+ device

Courtesy goes to Requesting Permissions at Run Time .

Example

Declare this as Global

private static final int PERMISSION_REQUEST_CODE = 1;

Add this in your onCreate() section

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

Now adding checkPermission() and 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

This interface is the contract for receiving the results for permission requests.

Bipin Bharti · Answer 3 · 2017-01-19T10:48:41.940

Check multiple Permission in API level 23 Step 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,
};

Step 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;
}

Step 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;
    }
}

Step 4: in onCreate of Activity checkPermissions();

Thanks. This look like a promising answer for multiple permissions. But it's lacking a bit in examples. How does it deal with `never ask again` and missing a few permissions? Does the user get any feedback? Would have been nice to see a real example of this or more comments on your code snippets. — not2qubit, Jan 18 '17 at 17:43
To deal with don't ask again surround the add to permissions if block with if(shouldshowpermissionrationale() ){}... it is true if the permission is needed and not forever dismissed — me_, Jun 20 '18 at 04:54

score 21 · Answer 4 · answered Mar 02 '16 at 11:31

21

Unless there is a definite requirement of writing on external storage, you can always choose to save files in app directory. In my case I had to save files and after wasting 2 to 3 days I found out if I change the storage path from

Environment.getExternalStorageDirectory()

to

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

it works like charm on all the devices. This is because for writing on External storage you need extra permissions but writing in internal app directory is simple.

answered Mar 02 '16 at 11:31

Mujtaba Hassan

2,495
2
20
29

where do you write this code? I cant remember using Environment.getExternalStorageDiretory() on my code – royjavelosa Nov 30 '17 at 14:03
Keep in mind that with this approach, if the user uninstalls the app the files will be deleted along with it. Sometimes, such as with photos, the user may expect the files to remain even if the app is uninstalled. – shagberg Feb 21 '22 at 17:14

score 5 · Answer 5 · answered Oct 16 '15 at 03:42

5

you need to use runtime permission in marshmallow https://developer.android.com/training/permissions/requesting.html

you can check in app info -> permission

is your app get permission for write external storage or not

answered Oct 16 '15 at 03:42

aiwiguna

2,852
2
15
26

2

actually this answer app info -> permission solved the crash :), but i accepted the other answer for the details of what to do. I wish I can accept both Thank u a lot – fullmoon Oct 16 '15 at 04:32
Thanks that fixed the browser crashing on download problem in android emulator – sdaffa23fdsf Nov 15 '15 at 22:35

user6435056 · Answer 6 · 2017-04-15T06:37:36.387

From marshmallow version, developers need to ask for runtime permissions to user. Let me give you whole process for asking runtime permissions.

I am using reference from here : marshmallow runtime permissions android.

First create a method which checks whether all permissions are given or not

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

Now here is the code which is run after above method. We will override onRequestPermissionsResult() method :

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

    }

If user clicks on Deny option then showDialogOK() method will be used to show dialog

If user clicks on Deny and also clicks a checkbox saying "never ask again", then explain() method will be used to show dialog.

methods to show dialogs :

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

Above code snippet asks for four permissions at a time. You can also ask for any number of permissions in your any activity as per your requirements.

score 2 · Answer 7 · answered Sep 15 '20 at 18:41

The easiest way I found was

private boolean checkPermissions(){
    if(ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
        return true;
    }
    else {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, PERMISSION_CODE);
        return false;
    }
}

score 1 · Answer 8 · answered Oct 12 '20 at 10:32

Add below code to your OnCreate() function in MainAcitivity, which will display pop up to ask for permission:

if (ActivityCompat.shouldShowRequestPermissionRationale(TestActivity.this,
                        Manifest.permission.WRITE_EXTERNAL_STORAGE)){
}
else {
     ActivityCompat.requestPermissions(TestActivity.this,
                            new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                            100);
}

score 1 · Answer 9 · answered Dec 23 '20 at 08:32

if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(),
                Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
            Log.d(TAG, "Permission granted");
        } else {
            ActivityCompat.requestPermissions(getActivity(),
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                    100);
        }

        fab.setOnClickListener(v -> {
            Bitmap b = BitmapFactory.decodeResource(getResources(), R.drawable.refer_pic);
            Intent share = new Intent(Intent.ACTION_SEND);
            share.setType("image/*");
            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
            b.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
            String path = MediaStore.Images.Media.insertImage(requireActivity().getContentResolver(),
                    b, "Title", null);
            Uri imageUri = Uri.parse(path);
            share.putExtra(Intent.EXTRA_STREAM, imageUri);
            share.putExtra(Intent.EXTRA_TEXT, "Here is text");
            startActivity(Intent.createChooser(share, "Share via"));
        });

score 0 · Answer 10 · answered May 25 '16 at 03:06

After lots of searching This code work for me:

Check the permission already has: Check WRITE_EXTERNAL_STORAGE permission Allowed or not?

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

Implement Override onRequestPermissionsResult method for checking is the user allow or denie

 @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();
        }
    }

score 0 · Answer 11 · edited Aug 22 '18 at 10:24

Before starting your download check your runtime permissions and if you don't have permission the request permissions like this method

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

score 0 · Answer 12 · answered May 22 '20 at 09:41

In a simple way the permission can be granted using manifest.xml file, but it was ok till the api level 23 sdk version 6, after from here, if we want to get the permission we have to ask for the use to allow the permission which are needed.

Just add this code in the mainActivity.java

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

Replace CAMERA or add with WRITE_EXTERNAL_STORAGE if you want, and with the unique code.

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

This is the simple code to get permission.

Storage permission error in Marshmallow

12 Answers12

FYI

Linked

Related