Demander les autorisations de l'utilisateur par programmation?

Je veux ajouter la fonctionnalité de donner à l'utilisateur la liste des autorisations d'approuver juste après l'ouverture de l'application pour la première fois.

J'ai lu de cette article sur la façon de le faire.

Mais j'ai encore quelques questions à ce sujet, pour rendre cette fonctionnalité de mon appli vraiment dynamique:

Comment lire fichier manifeste de la liste des autorisations éventuellement nécessaires?
(Ceci afin d'éviter explicite codée en dur de vérification de chaque
autorisations)
Comment par programmation classer ces autorisations que NORMAL et DANGEREUX, car j'ai besoin d'une demande explicite de l'utilisateur uniquement si l'autorisation est de dangereux genre? (Selon la documentation, normal autorisations sont accordées automatiquement par l'OS, sans demander à l'utilisateur)

OriginalL'auteur SoulRayder | 2016-11-27

Vous avez besoin de vérifier à chaque fois que la météo de l'autorisation est accordée ou non à votre application lorsque vous souhaitez effectuer une opération liée à celle des autorisations.

Parce que l'utilisateur peut désactiver l'autorisation de paramètres à tout moment.

Dangereux autorisations et les groupes d'autorisations:

CALENDRIER

READ_CALENDAR

WRITE_CALENDAR

CAMÉRA

CAMERA

CONTACTS

READ_CONTACTS
WRITE_CONTACTS
GET_ACCOUNTS

EMPLACEMENT

ACCESS_FINE_LOCATION
ACCESS_COARSE_LOCATION

MICROPHONE

RECORD_AUDIO

TÉLÉPHONE

READ_PHONE_STATE
CALL_PHONE
READ_CALL_LOG
WRITE_CALL_LOG
ADD_VOICEMAIL
USE_SIP
PROCESS_OUTGOING_CALLS

CAPTEURS

BODY_SENSORS

SMS

SEND_SMS
RECEIVE_SMS
READ_SMS
RECEIVE_WAP_PUSH
RECEIVE_MMS

De STOCKAGE

READ_EXTERNAL_STORAGE
WRITE_EXTERNAL_STORAGE

Source Dangereux autorisations

Normal Autorisations:

ACCESS_LOCATION_EXTRA_COMMANDS
ACCESS_NETWORK_STATE
ACCESS_NOTIFICATION_POLICY
ACCESS_WIFI_STATE
BLUETOOTH
BLUETOOTH_ADMIN
BROADCAST_STICKY
CHANGE_NETWORK_STATE
CHANGE_WIFI_MULTICAST_STATE
CHANGE_WIFI_STATE
DISABLE_KEYGUARD
EXPAND_STATUS_BAR
GET_PACKAGE_SIZE
INSTALL_SHORTCUT
INTERNET
KILL_BACKGROUND_PROCESSES
MODIFY_AUDIO_SETTINGS
NFC
READ_SYNC_SETTINGS
READ_SYNC_STATS
RECEIVE_BOOT_COMPLETED
REORDER_TASKS
REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
REQUEST_INSTALL_PACKAGES
SET_ALARM
SET_TIME_ZONE
SET_WALLPAPER
SET_WALLPAPER_HINTS
TRANSMIT_IR
UNINSTALL_SHORTCUT
USE_FINGERPRINT
VIBRATE
WAKE_LOCK
WRITE_SYNC_SETTINGS

Source Normal autorisations

Obtenir la liste des autorisations requises par programme:

public void readPermission()
{
    try {
        PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_PERMISSIONS);
        if (info.requestedPermissions != null) {
            for (String p : info.requestedPermissions) {
                Log.d(TAG, "Permission : " + p);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Merci pour l'information. Il a été très utile. Cependant, pouvez-vous svp répondre à mes questions?
Merci une tonne 🙂 Donc, parmi ces autorisations, si j'utilise le code décrit dans le lien que j'ai mentionné, le dialogue ne serait pas de pop up pour une normale de l'autorisation de droite? Seulement dangereux pour les autorisations d'une boîte de dialogue affichée à l'utilisateur, ai-je le droit?
Oui, vous devez demander à l'utilisateur pour dangereux la permission à chaque fois quand vous nécessaire si pas déjà reconnus.

OriginalL'auteur Priyank Patel

Autant que je sache, il n'y a aucun moyen de lire toutes les autorisations dans le manifeste de la programmation. Cependant, puisque vous les avez déjà répertoriés dans le Manifeste avant de relâcher votre APK, vous connaissez déjà les autorisations dont vous avez besoin de demander. N'est-ce pas?

Disons que vous avez READ_PHONE_STATE et WRITE_EXTERNAL_STORAGE dans votre manifeste, vous pouvez les ajouter dans votre vérification d'autorisation dans votre MainActivity.java:

ArrayList<String> arrPerm = new ArrayList<>();
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
    arrPerm.add(Manifest.permission.READ_PHONE_STATE);
}
if(ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
    arrPerm.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
}
if(!arrPerm.isEmpty()) {
    String[] permissions = new String[arrPerm.size()];
    permissions = arrPerm.toArray(permissions);
    ActivityCompat.requestPermissions(this, permissions, MY_PERMISSIONS_REQUEST);
}

Cela va déclencher la demande d'autorisation, pour les deux WRITE_EXTERNAL_STORAGE et READ_PHONE_STATE, l'un après l'autre. Pour vérifier les autorisations lorsqu'il est accordé, ce faire:

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

    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST: {
            //If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0) {
                for(int i = 0; i < grantResults.length; i++) {
                    String permission = permissions[i];
                    if(Manifest.permission.READ_PHONE_STATE.equals(permission)) {
                        if(grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                            //you now have permission
                        }
                    }
                    if(Manifest.permission.WRITE_EXTERNAL_STORAGE.equals(permission)) {
                        if(grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                            //you now have permission
                        }
                    }
                }
            } else {
                //permission denied, boo! Disable the
                //functionality that depends on this permission.
            }
            break;
        }
    }

    //other 'case' lines to check for other
    //permissions this app might request
}

OriginalL'auteur user1506104

0

Moment de l'exécution des autorisations sont ajoutés à partir d'Android Android 6.0 (API level 23), avant que les autorisations ne devraient être définis dans le manifeste. Mais Android 6 et plus vous avez besoin de prendre le temps d'exécution de l'autorisation (danger) de droit de l'utilisateur avant d'effectuer la tâche.

À partir de la documentation inclus dans la question

Si votre application a besoin d'une autorisation dangereuse, vous devez vérifier si vous
ont que l'autorisation à chaque fois que vous effectuez une opération qui nécessite
cette permission.

Donc, si vous effectuez une tâche qui nécessite danger autorisation doit demander à l'utilisateur de prendre et qui, sinon, il va lever une exception.

Vous pouvez lire cette pour prendre des autorisations de meilleure façon

Oui je suis au courant de la première partie, mais ma question est de savoir comment dynamiquement lire ces autorisations de manifester et comment classer par programmation?
Quels sont les documents enseigne, c'est de prendre l'autorisation par le codage en dur dans le code avant d'effectuer que des tâches qui ont besoin de ces autorisations. Ce que vous voulez, lire toutes les autorisations de manifester et de prendre la forme de l'utilisateur dans une boucle ? Je ne sais pas comment notre application intelligemment sais, ce que je devrais demander l'autorisation maintenant la forme de l'utilisateur avant d'effectuer la tâche spécifique

OriginalL'auteur Bills
0

les autorisations définies dans le manifeste avec
<uses-permission android:name="..."/>
automatiquement pour les appareils android avec l'API de niveau en dessous de 23. Pour les appareils android (6.0), vous aurez pour vérifier les autorisations lors de l'exécution.

https://developer.android.com/guide/topics/security/permissions.html
ce lien a une liste de dangereux autorisations

OriginalL'auteur Jay Pandya

Vous devez vous connecter pour publier un commentaire.