Speicherberechtigungsfehler in Marshmallow

159

In Lollipop funktioniert die Download-Funktion in meiner App einwandfrei. Wenn ich jedoch auf Marshmallow aktualisiert habe, stürzt meine App ab und gibt diesen Fehler aus, wenn ich versuche, aus dem Internet auf die SD-Karte herunterzuladen:

Neither user  nor current process has android.permission.WRITE_EXTERNAL_STORAGE

Es beschwert sich über diese Codezeile:

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

Ich habe die Berechtigungen im Manifest außerhalb der Anwendung:

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

Ich habe das Projekt bereinigt und neu erstellt, aber es stürzt immer noch ab.

Badr
quelle
Versuchen Sie dies, es kann Ihnen helfen: - stackoverflow.com/a/41221852/5488468
Bipin Bharti
Ich habe eine Bibliothek vorbereitet, mit deren Hilfe die Laufzeitberechtigungen problemlos verwaltet werden können. github.com/nabinbhandari/Android-Permissions
Nabin Bhandari

Antworten:

357

Sie sollten überprüfen, ob der Benutzer die Berechtigung zum externen Speichern erteilt hat, indem Sie Folgendes verwenden:

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

Wenn nicht, müssen Sie den Benutzer bitten, Ihrer App eine Berechtigung zu erteilen:

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

Natürlich sind diese nur für Marshmallow-Geräte, daher müssen Sie überprüfen, ob Ihre App auf Marshmallow ausgeführt wird:

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

Stellen Sie außerdem sicher, dass Ihre Aktivität implementiert wird OnRequestPermissionResult

Die gesamte Erlaubnis sieht folgendermaßen aus:

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

Rückruf des Berechtigungsergebnisses:

@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
    }
}
MetaSnarf
quelle
2
@Houssem gerne helfen.!
MetaSnarf
14
Dies funktioniert nicht für API> = 23 und fordert die Berechtigung an, Manifest.permission.WRITE_EXTERNAL_STORAGEimmer '-1' zurückzugeben, dh die Berechtigung wird verweigert. Überprüfen Sie die neue Dokumentation. Dort heißt es, dass Sie ab API 19 keine WRITE_EXTERNAL_STORAGEBerechtigung benötigen . Wie einige der oben genannten Kommentare erwähnt, sollten Sie all dies mit demManifest.permission.READ_EXTERNAL_STORAGE
AmeyaB
3
@VSB: Es ist an einem seltsamen Ort, aber los geht's: developer.android.com/guide/topics/manifest/…
AmeyaB
3
@AmeyB Als Dokumentation gesagt, für API> = 19, die Erlaubnis zu schreiben auf externen Speichern deklariert wird nicht benötigt IF Anwendung wird sein eigenes spezifisches Verzeichnis auf externe Speicher verwenden , die durch zurückgeführt wird getExternalFilesDir(). In anderen Fällen android.permission.WRITE_EXTERNAL_STORAGEmuss die Erlaubnis noch am besten erklärt werden.
VSB
1
Ja, es wurde behoben. Das Problem hing mit der Hockey-App-Bibliothek zusammen. Diese Bibliothek hat meine Schreibberechtigung überschrieben. @MetaSnarf
Selin
38

Das Berechtigungssystem von Android ist eines der größten Sicherheitsbedenken, da diese Berechtigungen bei der Installation angefordert werden. Nach der Installation kann die Anwendung auf alle gewährten Dinge zugreifen, ohne dass ein Benutzer bestätigt, was genau die Anwendung mit der Berechtigung tut.

Android 6.0 Marshmallow führt eine der größten Änderungen am Berechtigungsmodell ein, indem Laufzeitberechtigungen hinzugefügt werden. Dieses neue Berechtigungsmodell ersetzt das vorhandene Berechtigungsmodell für die Installationszeit, wenn Sie auf API 23 abzielen und die App auf einem Android 6.0+ -Gerät ausgeführt wird

Mit freundlicher Genehmigung können Sie zur Laufzeit Berechtigungen anfordern .

Beispiel

Deklarieren Sie dies als global

private static final int PERMISSION_REQUEST_CODE = 1;

Fügen Sie dies in Ihren onCreate()Abschnitt ein

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

Fügen Sie nun checkPermission () und requestPermission () hinzu.

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

Zu Ihrer Information

onRequestPermissionsResult

Diese Schnittstelle ist der Vertrag für den Empfang der Ergebnisse für Berechtigungsanfragen.

IntelliJ Amiya
quelle
28

Überprüfen Sie die Mehrfachberechtigung in API-Ebene 23 Schritt 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,
};

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

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

Schritt 4: in onCreate of Activity checkPermissions ();

Bipin Bharti
quelle
2
Vielen Dank. Dies scheint eine vielversprechende Antwort für mehrere Berechtigungen zu sein. Aber es fehlt ein bisschen an Beispielen. Wie geht es mit never ask againund ohne ein paar Berechtigungen um? Bekommt der Benutzer Feedback? Es wäre schön gewesen, ein echtes Beispiel dafür oder mehr Kommentare zu Ihren Codefragmenten zu sehen.
not2qubit
Um damit fertig zu werden, fragen Sie nicht noch einmal um das Hinzufügen zu Berechtigungen, wenn Block mit if (shouldshowpermissionrationale ()) {} ... es ist wahr, wenn die Berechtigung benötigt und nicht für immer entlassen wird
me_
Dies sollte die richtige und optimierte Antwort sein.
VikaS GuttE
21

Sofern nicht unbedingt geschrieben werden muss, können Sie Dateien jederzeit im App-Verzeichnis speichern. In meinem Fall musste ich Dateien speichern und nach 2 bis 3 Tagen fand ich heraus, ob ich den Speicherpfad von ändere

Environment.getExternalStorageDirectory()

zu

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

es funktioniert wie Charme auf allen Geräten. Dies liegt daran, dass Sie zum Schreiben in externen Speicher zusätzliche Berechtigungen benötigen, das Schreiben in ein internes App-Verzeichnis jedoch einfach ist.

Mujtaba Hassan
quelle
Wo schreibst du diesen Code? Ich kann mich nicht erinnern, Environment.getExternalStorageDiretory () für meinen Code verwendet zu haben
royjavelosa
5

Sie müssen die Laufzeitberechtigung in Marshmallow https://developer.android.com/training/permissions/requesting.html verwenden

Sie können App-Informationen einchecken -> Berechtigung

Ist Ihre App berechtigt, externen Speicher zu schreiben oder nicht?

aiwiguna
quelle
2
Eigentlich hat diese Antwort App Info -> Erlaubnis den Absturz gelöst :), aber ich habe die andere Antwort für die Details akzeptiert, was zu tun ist. Ich wünschte, ich könnte beides akzeptieren. Vielen Dank
Badr
Vielen Dank, dass der Browser beim Download-Problem im Android-Emulator
abgestürzt ist
4

Anscheinend hat der Benutzer die Berechtigung abgelehnt und die App versucht, auf eine externe Festplatte zu schreiben, was zu einem Fehler führt.

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

Überprüfen Sie https://developer.android.com/training/permissions/requesting.html

Dieses Video gibt Ihnen einen besseren Überblick über UX und behandelt die Laufzeitberechtigungen https://www.youtube.com/watch?v=iZqDdvhTZj0

VenomVendor
quelle
1

Ab der Marshmallow-Version müssen Entwickler den Benutzer um Laufzeitberechtigungen bitten. Lassen Sie mich Ihnen den gesamten Prozess zum Abfragen von Laufzeitberechtigungen geben.

Ich benutze Referenz von hier: Marshmallow Laufzeitberechtigungen Android .

Erstellen Sie zunächst eine Methode, die prüft, ob alle Berechtigungen erteilt wurden oder nicht

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

Hier ist der Code, der nach der obigen Methode ausgeführt wird. Wir werden die onRequestPermissionsResult()Methode überschreiben :

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

    }

Wenn Benutzer klickt auf Verweigern Option dann showDialogOK()wird Verfahren verwendet wird Dialog zeigen

Wenn Benutzer klickt auf Verweigern und auch klickt eine Checkbox sagen „nie wieder fragen“ , dann explain()wird Verfahren verwendet wird Dialog zu zeigen.

Methoden zum Anzeigen von Dialogen:

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

Das obige Code-Snippet fordert vier Berechtigungen gleichzeitig an. Sie können auch eine beliebige Anzahl von Berechtigungen für Ihre Aktivität gemäß Ihren Anforderungen anfordern.

user6435056
quelle
0

Nach langem Suchen funktioniert dieser Code für mich:

Überprüfen Sie, ob die Berechtigung bereits vorhanden ist: Überprüfen Sie die Berechtigung WRITE_EXTERNAL_STORAGE. Zulässig oder nicht?

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

Implementieren Sie die Override onRequestPermissionsResult-Methode, um zu überprüfen, ob der Benutzer dies zulässt oder verweigert

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

es hat bei mir funktioniert

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

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

            }
        }
Makvin
quelle
0

Bevor Sie mit dem Download beginnen, überprüfen Sie Ihre Laufzeitberechtigungen und, falls Sie keine Berechtigung haben, die Anforderungsberechtigungen wie diese Methode

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();
        }
    }
}
Balaji Rajendran
quelle
0

Auf einfache Weise kann die Berechtigung mithilfe der Datei manifest.xml erteilt werden, aber es war bis zur API Level 23 SDK Version 6 in Ordnung. Wenn wir von hier aus die Berechtigung erhalten möchten, müssen wir um die Verwendung bitten, um die Berechtigung zuzulassen welche benötigt werden.

Fügen Sie diesen Code einfach in die Datei mainActivity.java ein

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

Ersetzen Sie die KAMERA oder fügen Sie sie mit WRITE_EXTERNAL_STORAGE hinzu, wenn Sie möchten, und mit dem eindeutigen Code.

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

Dies ist der einfache Code, um die Berechtigung zu erhalten.

Pravin Ghorle
quelle