web-dev-qa-db-fra.com

Autorisation de lecture et d'écriture pour le stockage et l'utilisation de la galerie pour guimauve

Je développe une application Android dans laquelle il est nécessaire de fournir une autorisation pour lire et écrire un stockage externe. Mon exigence est de sélectionner une image de la galerie et de l’utiliser dans mon application. Tout fonctionne bien sauf les appareils Marshmallow. Je veux donner la permission à Marshmallow. Est-ce que quelqu'un peut m'aider avec ça?

androidandroid-permissionsandroid-6.0-marshmallowread-write
9
tiger

Il peut être réalisé quelque chose comme suit ...

public class MainActivity extends AppCompatActivity implements ActivityCompat.OnRequestPermissionsResultCallback{

  private static final int REQUEST_WRITE_PERMISSION = 786;

  @Override
  public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    if (requestCode == REQUEST_WRITE_PERMISSION && grantResults[0] == PackageManager.PERMISSION_GRANTED) {            
        openFilePicker();
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    requestPermission();
  }

  private void requestPermission() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        requestPermissions(new String[]{Android.Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_WRITE_PERMISSION);
    } else {
        openFilePicker();
    }
  }
}
20
Khan

Lire Autorisations d'exécution - Android M et son projet de référence .

Le flux des autorisations a été modifié, de sorte que les autorisations doivent être demandées au moment de l'exécution, de préférence en fonction des besoins. Avec les mêmes .. les autorisations ont également été catégorisées dans Normal et Dangerous qui mèneront également à des groupes d'autorisation. 

2
Pararth

Vérifier chaque situation

si refusée - affichage du dialogue d'alerte à l'utilisateur, pourquoi nous avons besoin d'une autorisation

public static final int STORAGE_PERMISSION_REQUEST_CODE= 1;


    private void askPermissions() {

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

   // we already asked for permisson & Permission granted, call camera intent
    if (permissionCheckStorage == PackageManager.PERMISSION_GRANTED) {

        //do what you want

    } else {

           // if storage request is denied
        if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setMessage("You need to give permission to access storage in order to work this feature.");
            builder.setNegativeButton("CANCEL", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    dialogInterface.dismiss();
                }
            });
            builder.setPositiveButton("GIVE PERMISSION", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    dialogInterface.dismiss();

                    // Show permission request popup
                    ActivityCompat.requestPermissions(this,
                            new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                            STORAGE_PERMISSION_REQUEST_CODE);
                }
            });
            builder.show();

        } //asking permission for first time 
          else {
             // Show permission request popup for the first time
                        ActivityCompat.requestPermissions(AddWorkImageActivity.this,
                                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                                STORAGE_PERMISSION_REQUEST_CODE);

                    }

    }
}

Vérification des résultats des autorisations 

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

    switch (requestCode) {
        case STORAGE_PERMISSION_REQUEST_CODE:
            if (grantResults.length > 0 && permissions[0].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                // check whether storage permission granted or not.
                if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    //do what you want;
                }
            }
            break;
        default:
            break;
    }
}

vous pouvez simplement copier et coller ce code, cela fonctionne bien. changez le contexte (cela) et les permissions selon vous. 

0
Adarsh Vijayan P

En outre, si vous souhaitez demander plusieurs autorisations. Tu peux le faire.

private ArrayList<String> permisos;

private void someMethod()
{
      ..

      verificarPermisos(Manifest.permission.READ_EXTERNAL_STORAGE );
      verificarPermisos(Manifest.permission.ACCESS_FINE_LOCATION );
      verificarPermisos(Manifest.permission.ACCESS_COARSE_LOCATION );
      if (permisos.size()!=0)
      {
         solicitarPermisos(permisos.toArray(new String[permisos.size()]));
      }

      ..

 }


@TargetApi(23)
void verificarPermisos(String permiso){
    if (ContextCompat.checkSelfPermission(this,permiso)
            != PackageManager.PERMISSION_GRANTED) {
        permisos.add(permiso);
        // Should we show an explanation?
        if (shouldShowRequestPermissionRationale(permiso)) {

        }

    }
}

@TargetApi(23)
void solicitarPermisos(String[] permiso){

    requestPermissions(permiso, 1);

}

Tout d'abord, je vérifie si l'autorisation est déjà accordée ou non avec la méthode " verificarPermisos () ". S'ils ne sont pas accordés, je les ajoute à " permisos ". Enfin, les autorisations non accordées sont requises en les passant au format String [] array. 

Notez que vous pouvez uniquement demander des autorisations depuis MashMellow (API 23) ou une version ultérieure. Ainsi, si votre application vise également les versions Android antérieures à MashMellow, vous pouvez utiliser l'annotation " @TargetApi () " et les méthodes d'autorisation ne doivent être appelées que lorsque la cible est l'API 23 ou supérieure.
J'espère pouvoir vous aider, salutations.

0
Gian Gomen