मार्शमैलो में संग्रहण अनुमति त्रुटि


159

लॉलीपॉप में, डाउनलोड की कार्यक्षमता मेरे ऐप में ठीक काम करती है, लेकिन जब मैंने मार्शमैलो में अपग्रेड किया, तो मेरा ऐप क्रैश हो गया और जब मैंने इंटरनेट से एसडी कार्ड में डाउनलोड करने की कोशिश की तो यह त्रुटि हो गई:

Neither user  nor current process has android.permission.WRITE_EXTERNAL_STORAGE

यह इस लाइन कोड के बारे में शिकायत करता है:

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

मुझे बाहर के आवेदन में अनुमति है:

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

मैंने प्रोजेक्ट को साफ और पुनर्निर्माण किया, लेकिन यह अभी भी दुर्घटनाग्रस्त है।


कोशिश करें कि यह आपकी मदद कर सकता है: - stackoverflow.com/a/41221852/5488468
Bipin Bharti

मैंने एक पुस्तकालय तैयार किया है जो रनटाइम अनुमतियों को आसानी से संभालने में मदद करेगा। github.com/nabinbhandari/Android-Pokes
नबीन भंडारी

जवाबों:


357

यदि उपयोगकर्ता ने बाहरी संग्रहण की अनुमति दी है, तो आपको जाँच करनी चाहिए:

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

यदि नहीं, तो आपको अपने ऐप को अनुमति देने के लिए उपयोगकर्ता से पूछना होगा:

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

बेशक ये मार्शमैलो डिवाइस के लिए ही हैं इसलिए आपको यह जांचना होगा कि आपका ऐप मार्शमैलो पर चल रहा है या नहीं:

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

यह भी सुनिश्चित करें कि आपकी गतिविधि लागू हो OnRequestPermissionResult

संपूर्ण अनुमति इस तरह दिखाई देती है:

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

अनुमति परिणाम कॉलबैक:

@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
@ हसेम मदद करने के लिए खुश हैं।
मेटासरफ

14
यह एपीआई> = 23 के लिए काम नहीं करता है, Manifest.permission.WRITE_EXTERNAL_STORAGEहमेशा '-1' रिटर्न की अनुमति का अनुरोध करता है। नए दस्तावेज़ की जाँच करें, यह कहता है कि एपीआई 19 के लिए, आपको WRITE_EXTERNAL_STORAGEअनुमति की आवश्यकता नहीं है । उपरोक्त कुछ टिप्पणियों के रूप में, आपको यह सब करना चाहिएManifest.permission.READ_EXTERNAL_STORAGE
AmeyaB

3
@VSB: इसकी अजीब जगह पर लेकिन यहाँ आप चलते हैं: developer.android.com/guide/topics/manifest/…
AmeyaB

3
@AmeyB जैसा कि दस्तावेज़ीकरण ने कहा, एपीआई> = 19 के लिए, बाहरी भंडारण पर लिखने की अनुमति की घोषणा करने की आवश्यकता नहीं है यदि बाहरी भंडारण पर अपने स्वयं के विशिष्ट निर्देशिका का उपयोग करने के लिए आवेदन किया जा रहा है getExternalFilesDir()। अन्य मामलों में, अभी भी अनुमति android.permission.WRITE_EXTERNAL_STORAGEको मैनफ़िएस्ट में घोषित किया जाना चाहिए।
VSB

1
हाँ, यह तय है। समस्या हॉकी ऐप लाइब्रेरी से संबंधित थी। यह पुस्तकालय मेरे लेखन की अनुमति से आगे निकल गया है। @ मीतासर्फ़
सेलिन

38

एंड्रॉइड की अनुमति प्रणाली उन सभी सुरक्षा चिंताओं में से एक है, जब से उन अनुमतियों को इंस्टॉल समय पर पूछा जाता है। एक बार स्थापित होने के बाद, एप्लिकेशन किसी भी उपयोगकर्ता की पावती के बिना दी गई सभी चीजों तक पहुंच प्राप्त करने में सक्षम होगा जो कि आवेदन की अनुमति के साथ वास्तव में करता है।

एंड्रॉइड 6.0 मार्शमैलो रनटाइम अनुमतियों को जोड़ने के साथ अनुमतियों के मॉडल में सबसे बड़े बदलावों में से एक का परिचय देता है, एक नया अनुमति मॉडल जो मौजूदा 23 बार अनुमतियों को स्थापित करता है जब आप एपीआई 23 को लक्षित करते हैं और ऐप एंड्रॉइड 6.0+ डिवाइस पर चल रहा होता है

शिष्टाचार रन टाइम में अनुरोधों की अनुमति देता है

उदाहरण

इसे वैश्विक घोषित करें

private static final int PERMISSION_REQUEST_CODE = 1;

इसे अपने onCreate()अनुभाग में जोड़ें

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
    }

अब checkPermission () और 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

यह इंटरफ़ेस अनुमति अनुरोधों के लिए परिणाम प्राप्त करने का अनुबंध है।


29

एपीआई स्तर 23 चरण 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,
};

चरण 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;
}

चरण 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;
    }
}

चरण 4: गतिविधि चेकपाइंट्स के ऑनक्रिएट में ();


2
धन्यवाद। यह कई अनुमतियों के लिए एक आशाजनक उत्तर की तरह दिखता है। लेकिन इसका उदाहरणों में थोड़ा अभाव है। यह never ask againकुछ अनुमतियों से कैसे निपटता है और कैसे गायब होता है? क्या उपयोगकर्ता को कोई प्रतिक्रिया मिलती है? अपने कोड स्निपेट पर इस या अधिक टिप्पणियों का एक वास्तविक उदाहरण देखकर अच्छा लगा होगा।
not2qubit

सौदा करने के लिए फिर से अनुमति के लिए ऐड को घेरने के लिए अगर (shouldshowpermissionrationale ()) {} के साथ ब्लॉक करें ... यह सच है अगर अनुमति की जरूरत है और हमेशा के लिए खारिज नहीं किया जाता है
me_

यह सही और अनुकूलित उत्तर होना चाहिए।
विकास गुट्टे

21

जब तक बाहरी भंडारण पर लिखने की एक निश्चित आवश्यकता नहीं होती है, आप हमेशा एप्लिकेशन डायरेक्टरी में फ़ाइलों को सहेजने के लिए चुन सकते हैं। मेरे मामले में मुझे फाइलें बचानी थीं और 2 से 3 दिन बर्बाद करने के बाद मुझे पता चला कि क्या मैं स्टोरेज पाथ को बदल दूं

Environment.getExternalStorageDirectory()

सेवा

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

यह सभी उपकरणों पर आकर्षण की तरह काम करता है। ऐसा इसलिए है क्योंकि बाहरी संग्रहण पर लिखने के लिए आपको अतिरिक्त अनुमतियों की आवश्यकता होती है लेकिन आंतरिक एप्लिकेशन निर्देशिका में लिखना सरल है।


आप इस कोड को कहाँ लिखते हैं? मैं Environment.getExternalStorageDiretory () का उपयोग करने पर मेरी कोड याद नहीं कर सकते
royjavelosa

5

आपको मार्शमैलो में रनटाइम अनुमति का उपयोग करने की आवश्यकता है https://developer.android.com/training/permissions/requaremail

आप एप्लिकेशन जानकारी -> अनुमति में देख सकते हैं

क्या आपके ऐप को बाहरी स्टोरेज लिखने की अनुमति मिलती है या नहीं


2
वास्तव में इस उत्तर ऐप की जानकारी -> अनुमति ने दुर्घटना को हल किया :), लेकिन मैंने क्या करना है, इसके विवरण के लिए अन्य उत्तर को स्वीकार किया। मेरी इच्छा है कि मैं थैंक्स ua लॉट स्वीकार कर सकता हूं
Badr

धन्यवाद कि एंड्रॉइड एमुलेटर में डाउनलोड समस्या पर क्रैश होने वाले ब्राउज़र को ठीक किया
sdaffa23fdsf

4

लगता है कि उपयोगकर्ता ने अनुमति को अस्वीकार कर दिया है और ऐप बाहरी डिस्क पर लिखने की कोशिश करता है, जिससे त्रुटि होती है।

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

चेक https://developer.android.com/training/permissions/requesting.html

यह वीडियो आपको UX के बारे में एक बेहतर विचार प्रदान करेगा, रनटाइम अनुमतियों को संभालना https://www.youtube.com/watch?v=iZqDdvhTZj0


1

मार्शमैलो संस्करण से, डेवलपर्स को उपयोगकर्ता से रनटाइम अनुमतियों के लिए पूछना होगा। रनटाइम परमिशन मांगने के लिए मैं आपको पूरी प्रक्रिया देता हूं।

मैं यहां से संदर्भ का उपयोग कर रहा हूं: मार्शमैलो रनटाइम अनुमतियां Android

पहले एक विधि बनाएं जो यह जांच करे कि सभी अनुमतियां दी गई हैं या नहीं

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

अब यहाँ कोड है जो उपरोक्त विधि के बाद चलाया जाता है। हम onRequestPermissionsResult()विधि को ओवरराइड करेंगे :

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

    }

यदि उपयोगकर्ता इनकार विकल्प पर क्लिक करता है तो showDialogOK()संवाद दिखाने के लिए विधि का उपयोग किया जाएगा

यदि उपयोगकर्ता Deny पर क्लिक करता है और यह भी कहता है कि "फिर से कभी मत पूछो" चेकबॉक्स क्लिक करता है , तो explain()डायलॉग दिखाने के लिए विधि का उपयोग किया जाएगा।

संवाद दिखाने के तरीके:

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

उपरोक्त कोड स्निपेट एक बार में चार अनुमतियां मांगता है। आप अपनी आवश्यकताओं के अनुसार किसी भी गतिविधि में अनुमतियों की संख्या के लिए भी पूछ सकते हैं।


0

बहुत खोज के बाद यह कोड मेरे लिए काम करता है:

अनुमति की जांच पहले से करें: WRITE_EXTERNAL_STORAGE अनुमति दें या नहीं की जाँच करें?

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

उपयोगकर्ता के लिए अनुमति या इनकार करने की जाँच के लिए ओवरराइड onRequestPeaksResult विधि को लागू करें

 @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

यह मेरे लिए काम किया है

 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

अपना डाउनलोड शुरू करने से पहले अपने रनटाइम अनुमतियों की जांच करें और यदि आपके पास इस पद्धति की तरह अनुरोध की अनुमति नहीं है

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

एक सरल तरीके से मैनिफ़ेस्ट को प्रकट करने की अनुमति दी जा सकती है। xml फ़ाइल, लेकिन यह एपीआई स्तर 23 sdk संस्करण 6 तक ठीक था, यहाँ से, यदि हम अनुमति प्राप्त करना चाहते हैं तो हमें अनुमति देने के लिए उपयोग के लिए पूछना होगा जिसकी जरूरत है।

इस कोड को mainActivity.java में जोड़ें

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

CAMERA बदलें या यदि आप चाहते हैं, और अनूठे कोड के साथ WRITE_EXTERNAL_STORAGE को जोड़ें।

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

यह अनुमति प्राप्त करने के लिए सरल कोड है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.