web-dev-qa-db-fra.com

Demander une autorisation d'exécution pour Android Marshmallow 6.0

Je teste mon application sur Marshmallow 6.0 et sa fermeture est forcée pour le Android.permission.READ_EXTERNAL_STORAGE, même si cela est déjà défini dans le manifeste. Quelque part, j'ai lu que si je demandais une autorisation au moment de l'exécution, cela ne forcerait pas la fermeture de votre application. J'ai lu ce document Android aussi, qui sert à demander une autorisation d'exécution. 

Donc, j'ai appris que nous pouvons demander une permission comme celle indiquée ci-dessous, qui est mentionnée dans le document Android.

// Here, thisActivity is the current activity
if (ContextCompat.checkSelfPermission(thisActivity,
                Manifest.permission.READ_CONTACTS)
        != PackageManager.PERMISSION_GRANTED) {

    // Should we show an explanation?
    if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
            Manifest.permission.READ_CONTACTS)) {

        // Show an expanation to the user *asynchronously* -- don't block
        // this thread waiting for the user's response! After the user
        // sees the explanation, try again to request the permission.

    } else {

        // No explanation needed, we can request the permission.

        ActivityCompat.requestPermissions(thisActivity,
                new String[]{Manifest.permission.READ_CONTACTS},
                MY_PERMISSIONS_REQUEST_READ_CONTACTS);

        // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
        // app-defined int constant. The callback method gets the
        // result of the request.
    }
}

Le code ci-dessus a une méthode de rappel onRequestPermissionsResult qui obtient le résultat.

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

     }
}

Ma question est où demander exactement la permission à l'utilisateur? Devrions-nous utiliser l'autorisation de demande au début de l'application ou devrions-nous le faire comme lorsque l'autorisation était requise?

javaandroidandroid-6.0-marshmallowruntime-permissions
13
Pankaj

En général, demandez les autorisations nécessaires dès que vous en avez besoin. De cette façon, vous pouvez expliquer à l'utilisateur pourquoi vous avez besoin de cette autorisation et gérer les refus d'autorisations beaucoup plus facilement.

Pensez à des scénarios dans lesquels l'utilisateur révoque l'autorisation lors de l'exécution de votre application: si vous le demandez au démarrage et ne le vérifiez jamais plus tard, cela pourrait entraîner un comportement inattendu ou des exceptions.

3
Jörn Buitink

Ceci a fonctionné pour moi !!! Dans votre activité Splash de votre application, procédez comme suit:

1) Déclarer une variable int pour le code de requête,

private static final int REQUEST_CODE_PERMISSION = 2;

2) Déclarez un tableau de chaînes avec le nombre de permissions dont vous avez besoin,

 String[] mPermission = {Manifest.permission.READ_CONTACTS, Manifest.permission.READ_SMS,
 Manifest.permission.ACCESS_FINE_LOCATION,
 Manifest.permission.WRITE_EXTERNAL_STORAGE};

3) Next Vérifiez la condition d’autorisation d’exécution sur votre méthode onCreate,

try {
            if (ActivityCompat.checkSelfPermission(this, mPermission[0])
                    != MockPackageManager.PERMISSION_GRANTED ||
                    ActivityCompat.checkSelfPermission(this, mPermission[1])
                            != MockPackageManager.PERMISSION_GRANTED ||
                    ActivityCompat.checkSelfPermission(this, mPermission[2])
                            != MockPackageManager.PERMISSION_GRANTED ||
                    ActivityCompat.checkSelfPermission(this, mPermission[3])
                            != MockPackageManager.PERMISSION_GRANTED) {

                ActivityCompat.requestPermissions(this,
                        mPermission, REQUEST_CODE_PERMISSION);

              // If any permission aboe not allowed by user, this condition will execute every tim, else your else part will work
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

4) Déclarez maintenant la méthode onRequestPermissionsResult pour vérifier le code de la demande,

@Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        Log.e("Req Code", "" + requestCode);
        if (requestCode == REQUEST_CODE_PERMISSION) {
            if (grantResults.length == 4 &&
                    grantResults[0] == MockPackageManager.PERMISSION_GRANTED &&
                    grantResults[1] == MockPackageManager.PERMISSION_GRANTED &&
                    grantResults[2] == MockPackageManager.PERMISSION_GRANTED &&
                    grantResults[3] == MockPackageManager.PERMISSION_GRANTED) {

               // Success Stuff here

            }
        }

    }
8
Nanda Gopal

À mon avis, il n'y a pas une seule réponse correcte à votre question. Je vous suggère fortement de regarder cette page officielle de modèles de permissions .

Quelques suggestions de Google:

"Votre stratégie d'autorisations dépend de la clarté et de l'importance du type d'autorisation que vous demandez. Ces modèles offrent différents moyens d'introduire des autorisations à l'utilisateur."

"Les autorisations critiques doivent être demandées au préalable. Des autorisations secondaires peuvent être demandées dans le contexte."

"Les autorisations moins claires doivent renseigner sur les implications de l'autorisation, qu'elle soit faite au début ou dans son contexte."

Cette illustration pourrait vous donner une meilleure compréhension.

Peut-être que la chose la plus importante ici est que, que vous demandiez l'autorisation au début ou dans le contexte, vous devez toujours garder à l'esprit que ces autorisations peuvent être révoquées à tout moment par l'utilisateur (par exemple, votre application est toujours en cours d'exécution en arrière-plan). 

Assurez-vous que votre application ne plante pas juste parce que vous avez demandé la permission au tout début de l'application et supposez que l'utilisateur n'a pas changé sa préférence à propos de cette permission.

3
Can Elmas

Fait comme ça 

private static final int  REQUEST_ACCESS_FINE_LOCATION = 111;

Dans votre onCreate

boolean hasPermissionLocation = (ContextCompat.checkSelfPermission(getApplicationContext(),
            Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED);
    if (!hasPermissionLocation) {
        ActivityCompat.requestPermissions(ThisActivity.this,
                new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                REQUEST_ACCESS_FINE_LOCATION);
    }

puis vérifier le résultat

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

        case REQUEST_ACCESS_FINE_LOCATION: {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED)
            {
                Toast.makeText(ThisActivity.this, "Permission granted.", Toast.LENGTH_SHORT).show();

                //reload my activity with permission granted
                finish();
                startActivity(getIntent());

            } else
            {
                Toast.makeText(ThisActivity.this, "The app was not allowed to get your location. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show();
            }
        }

    }

}
2
Tharindu Bandara

Pour demander l'autorisation d'exécution, j'utilise Bibliothèque GitHub

Ajouter une bibliothèque dans le fichier Build.gradle

dependencies {
     compile 'gun0912.ted:tedpermission:1.0.3'
}

Créer une activité et ajouter PermissionListener

public class MainActivity extends AppCompatActivity{

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);



    PermissionListener permissionlistener = new PermissionListener() {
        @Override
        public void onPermissionGranted() {
            Toast.makeText(RationaleDenyActivity.this, "Permission Granted", Toast.LENGTH_SHORT).show();
            //Camera Intent and access Location logic here
        }

        @Override
        public void onPermissionDenied(ArrayList<String> deniedPermissions) {
            Toast.makeText(RationaleDenyActivity.this, "Permission Denied\n" + deniedPermissions.toString(), Toast.LENGTH_SHORT).show();
        }
    };


    new TedPermission(this)
            .setPermissionListener(permissionlistener)
            .setRationaleTitle(R.string.rationale_title)
            .setRationaleMessage(R.string.rationale_message) // "we need permission for access camera and find your location"
            .setDeniedTitle("Permission denied")
            .setDeniedMessage("If you reject permission,you can not use this service\n\nPlease turn on permissions at [Setting] > [Permission]")
            .setGotoSettingButtonText("Settings")
            .setPermissions(Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE)
            .check();
   }
}

string.xml

<resources>

    <string name="rationale_title">Permission required</string>
    <string name="rationale_message">we need permission for read <b>camera</b> and find your <b>location</b></string>

</resources>
1
Android Player _Shree

En appelant cette fonction, nous pouvons autoriser l’utilisateur à ouvrir une boîte de dialogue pour demander l’autorisation d’autoriser la caméra et l’enregistrement audio. 

    if ( ActivityCompat.shouldShowRequestPermissionRationale (this, Manifest.permission.CAMERA) ||
            ActivityCompat.shouldShowRequestPermissionRationale (this,
                    Manifest.permission.RECORD_AUDIO) ) {
        Toast.makeText (this,
                R.string.permissions_needed,
                Toast.LENGTH_LONG).show ();
    } else {
        ActivityCompat.requestPermissions (
                this,
                new String[]{Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO},
                CAMERA_MIC_PERMISSION_REQUEST_CODE);
    }
0
Deepika kapila

Une bonne explication et HowTo peuvent être trouvés ici:

https://inthecheesefactory.com/blog/things-you-neo-to-know-about-Android-m-permission-developer-edition/fr

J'ai écrit ce code pour vérifier et demander les autorisations au moment de l'exécution dans un BaseActivity.class, parent de tous les autres Activity.class que j'ai implémentés:

public static final int PERMISSION_REQUEST = 42;
public static final int MULTIPLE_PERMISSION_REQUEST = 43;

//Marshmallow Permission Model
public boolean requestPermission(String permission /* Manifest.permission...*/) {
    if (ContextCompat.checkSelfPermission(this,
            permission) != PackageManager.PERMISSION_GRANTED) {
        if (Utils.hasMarshmallow())
            ActivityCompat.requestPermissions(this,
                    new String[]{permission}, PERMISSION_REQUEST
            );
        else {
            requestPermissions(new String[]{permission},
                    PERMISSION_REQUEST);
        }
        return false;
    } else {
        return true;
    }
}

public boolean requestPermission(String... permissions) {
    final List<String> permissionsList = new ArrayList<String>();

    for (String perm : permissions) {
        addPermission(permissionsList, perm);
    }

    if (permissionsList.size() > 0) {
        if (Utils.hasMarshmallow())
            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                    MULTIPLE_PERMISSION_REQUEST);
        else
            ActivityCompat.requestPermissions(this, permissionsList.toArray(new String[permissionsList.size()]),
                    MULTIPLE_PERMISSION_REQUEST);
        return false;
    } else
        return true;
}


private boolean addPermission(List<String> permissionsList, String permission) {
    if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
        permissionsList.add(permission);
        // Check for Rationale Option
        if (Utils.hasMarshmallow())
            if (!shouldShowRequestPermissionRationale(permission))
                return false;
    }
    return true;
}

@Override
public void onRequestPermissionsResult(int requestCode,
                                       String permissions[], int[] grantResults) {
    switch (requestCode) {
        case PERMISSION_REQUEST:
        case MULTIPLE_PERMISSION_REQUEST: {
            // 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
    }
}

Par exemple, appelez:

activity.requestPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE);

Le résultat renvoyé vous permettra de savoir si l'autorisation est déjà accordée ou non.

0
Code.IT

https://material.io/guidelines/patterns/permissions.html Ce lien vous donnera différents types de scénarios où des autorisations peuvent être demandées. Choisissez en fonction de vos besoins.

0
Abhigyan

J'aime le code court. J'utilise RxPermission pour les autorisations.

RxPermission est la meilleure bibliothèque, ce qui rend le code d'autorisation inattendu d'une seule ligne.

RxPermissions rxPermissions = new RxPermissions(this);
rxPermissions
.request(Manifest.permission.CAMERA,
         Manifest.permission.READ_PHONE_STATE) // ask single or multiple permission once
.subscribe(granted -> {
    if (granted) {
       // All requested permissions are granted
    } else {
       // At least one permission is denied
    }
});

ajoutez dans votre build.gradle

allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}

dependencies {
    implementation 'com.github.tbruyelle:rxpermissions:0.10.1'
    implementation 'com.jakewharton.rxbinding2:rxbinding:2.1.1'
}

N'est-ce pas facile?

0
Khemraj