Autorisations Android M: onRequestPermissionsResult () n'est pas appelé

291

Je mets à jour notre application pour utiliser le nouveau système d'autorisations d'exécution M. Tout fonctionne, sauf onRequestPermissionsResult (). Je dois vérifier une autorisation sur une pression de bouton, et si elle réussit, envoyer un message texte. Lorsque j'accorde l'autorisation de le faire, la boîte de dialogue se ferme, mais elle ne déclenche pas l'envoi de texte jusqu'à ce que j'appuie à nouveau sur le bouton.

J'ai débogué et défini des points d'arrêt dans la méthode onRequestPermissionsResult () mais elle n'y va jamais.

Cette méthode est appelée en premier:

    private void askForPermission() {
    String[] permissions = new String[]{Manifest.permission.SEND_SMS};
    ActivityCompat.requestPermissions(getActivity(), permissions, PERMISSIONS_CODE);
}

Et puis mon rappel ressemble à ceci:

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

    if (requestCode == PERMISSIONS_CODE) {
        for (int i = 0; i < permissions.length; i++) {
            String permission = permissions[i];
            int grantResult = grantResults[i];

            if (permission.equals(Manifest.permission.SEND_SMS)) {
                if (grantResult == PackageManager.PERMISSION_GRANTED) {
                    onPPSButtonPress();
                } else {
                    requestPermissions(new String[]{Manifest.permission.SEND_SMS}, PERMISSIONS_CODE);
                }
            }
        }
    }
}

Quelqu'un a-t-il rencontré un problème similaire? Appréciez toute aide à ce sujet. Merci

AndyOHart
la source

Réponses:

576

J'ai rencontré le même problème et je viens de trouver la solution. Lorsque vous utilisez la bibliothèque de support, vous devez utiliser les appels de méthode appropriés. Par exemple:

  • Lorsque vous êtes dans AppCompatActivity , vous devez utiliser ActivityCompat.requestPermissions ;
  • Lorsque vous êtes dans android.support.v4.app.Fragment , vous devez simplement utiliser requestPermissions (il s'agit d'une méthode d'instance de android.support.v4.app.Fragment)

Si vous appelez ActivityCompat.requestPermissions dans un fragment, le rappel onRequestPermissionsResult est appelé sur l'activité et non sur le fragment.

J'espère que cela t'aides!

yavor87
la source
13
Cela se produit également avec les activités noHistory: code.google.com/p/android-developer-preview/issues/…
Anthony Bobenrieth
11
"Lorsque vous êtes dans android.support.v4.app.Fragment, vous devez simplement utiliser requestPermissions" - merci!
Tigran Sarkisian
5
@AnthonyBobenrieth alors quelle est la solution ici pour les activités noHistory? Nous ne pouvons tout simplement pas leur demander des autorisations?
Dean sauvage
2
Le lien est rompu @AnthonyBobenrieth. Existe-t-il une solution sans histoire?
fersarr
3
Lors de l'utilisation Fragment.requestPermissions(), l'activité parent reçoit réellement le onRequestPermissionsResult(). (Ceci est avec la bibliothèque de soutien 23.3.0)
Quelqu'un Quelque part
101

Vous pouvez essayer ceci:

requestPermissions(permissions, PERMISSIONS_CODE);

Si vous appelez ce code à partir d'un fragment, il a sa propre méthode requestPermissions. Je crois que le problème est que vous appelez une méthode statique.

Astuce de pro si vous voulez le onRequestPermissionsResult()dans un fragment: FragmentCompat.requestPermissions(Fragment fragment, String[] permissions, int requestCode)

Tieru
la source
Merci pour l'aide. J'ai remarqué qu'il existe une méthode requestPermissions si elle est dans un fragment. Je suis dans un fragment et j'ai essayé d'appeler simplement requestPermissions, malheureusement cela n'a pas fonctionné. J'ai également essayé ce que vous avez mentionné et cela n'a pas fonctionné non plus.
AndyOHart
Cela a fonctionné pour moi dans Android M. Mais vous vous demandez simplement si cela causerait des problèmes dans les appareils Pre-M?
Bala Vishnu
4
@goodgamerguy assurez-vous de ne pas utiliser le code de demande dans onRequestPermissionsResult of activity. si votre activité utilise également le rappel onRequestPermissionsResult, vous devez fournir la valeur par défaut: super.onRequestPermissionsResult (requestCode, permissions, grantResults);
Timmy Simons
68

J'espère que ça marche bien

Pour l'activité:

 ActivityCompat.requestPermissions(this,permissionsList,REQUEST_CODE);

Pour le fragment:

 requestPermissions(permissionsList,REQUEST_CODE);
Sanjay Mangaroliya
la source
Qu'en est-il du SDK 15 et inférieur?
zulkarnain shah
4
Vous n'avez pas besoin d'autorisation sur le SDK 15, seulement Marshmallow et la version supérieure ont besoin ..
Sanjay Mangaroliya
50

J'ai aussi rencontré ce problème. Si vous souhaitez que l'activité qui gère les autorisations ne figure pas dans l'historique / les événements récents, vous serez tenté de modifier votre AndroidManifest.xmlentrée.

Si vous définissez l'activité que vous appelez requestPermissionsou AppCompatActivity.requestPermissionsavec

android:noHistory="true"
android:excludeFromRecents="true"

dans votre AndroidManifest.xmlalors onRequestPermissionsResult()ne sera pas appelé. Cela est vrai si votre activité est dérivée de Activityou AppCompatActivity.

Cela peut être résolu en supprimant les deux indicateurs de 'AndroidManifest.xml' et en terminant votre activité à la finishAndRemoveTask()place.

Simon Featherstone
la source
J'aurais préféré ne pas avoir à supprimer l'attribut noHistory, mais c'est la solution qui a fonctionné pour moi. Merci!
Eric Schlenz
1
J'ai eu le problème sur Marshmallow mais pas sur Nougat, merci ça a marché pour moi
Yohan Dahmani
37

Si vous avez onRequestPermissionsResultà la fois une activité et un fragment, assurez-vous d'appeler l' super.onRequestPermissionsResultactivité. Il n'est pas requis en fragment, mais il est en activité.

Dusan Zivkovic
la source
Notez également que si vous ciblez une API (telle que 19 par exemple), vous serez toujours sous l'ancien système de modèle d'autorisation et, par conséquent, vous ne recevrez pas les appels de fonction liés à l'autorisation de demande
Bonatti
voir ma réponse si vous avez prolongé une autre activité qui n'appelle pas super
TouchBoarder
3
Je suis tombé sur celui-ci. FragmentActivity.onRequestPermissionsResult(..)est l'endroit vers lequel l'appel de fragment onRequestPermissionsResult(..)est transféré.
JanPl
@Bonatti Donc, si j'essaie de demander une autorisation dans Android 4.4.2, je n'obtiendrai pas de résultat? Ainsi je ne peux pas changer les permissions, seulement les voir?
Alex Fragotsis
@AlexanderFragotsis Vous obtiendrez un résultat. La seule différence est que vous ne serez pas invité à accorder l'autorisation, à la place, le système vous accordera automatiquement.
Dusan Zivkovic
33

Réponse obsolète, veuillez vous référer à: https://developer.android.com/training/permissions/requesting

Fragment intérieur, vous devez appeler:

FragmentCompat.requestPermissions(permissionsList, RequestCode)

Ne pas:

ActivityCompat.requestPermissions(Activity, permissionsList, RequestCode);
Ben.Slama.Jihed
la source
2
Concerne android.support.v13.app.FragmentCompat
Udi Oshi
1
FragmentCompat est obsolète à partir de l'API 27.1.0.
Big McLargeHuge
ma réponse est obsolète, veuillez vous référer à: developer.android.com/training/permissions/requesting
Ben.Slama.Jihed
15

Si vous utilisez requestPermissions en fragment, il accepte 2 paramètres au lieu de 3.

Tu devrais utiliser requestPermissions(permissions, PERMISSIONS_CODE);

AkKi
la source
1
En fait, il fournit une réponse à la question. En appelant requestPermissions (méthode d'instance de fragment) au lieu de ActivityCompat.requestPermissions, la méthode de résultat est déclenchée. Quel est le principal problème ici. Merci Don
Waclock
15

Si, pour une raison quelconque, vous avez étendu une activité personnalisée située dans une bibliothèque externe qui n'appelle pas le super, vous devrez appeler manuellement le fragment super.onRequestPermissionsResult vous-même dans votre activité onRequestPermissionsResult.

YourActivity extends SomeActivityNotCallingSuperOnRequestPermissionsResult{
Fragment requestingFragment;//the fragment requesting the permission
...
@Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if(requestingFragment!=null)
            requestingFragment.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
...
TouchBoarder
la source
12

Vous avez la fonction checkPermissions pour les appareils pré-guimauve dans FragmentCompat . J'utilise comme ça:

FragmentCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);
Marta Rodriguez
la source
2
Cela ne fonctionne que si l'autorisation est demandée dans android.app.fragment, et que vous devez importer la bibliothèque support-v13!
MohammadReza
4
FragmentCompat.requestPermissions () ne fonctionne pas avec android.support.v4.app.Fragment. Tout le monde sait comment gérer cela.
Jutikorn
12

J'ai découvert que c'est important où vous appelez android.support.v4.app.Fragment.requestPermissions.

Si vous le faites en onCreate(), onRequestPermissionsResult()n'est jamais appelé.

Solution: appelez-le onActivityCreated();

@Override
public void onActivityCreated(Bundle savedInstanceState) {

    super.onActivityCreated(savedInstanceState);

    if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CONTACTS) == PackageManager.PERMISSION_DENIED) 
        requestPermissions(new String[]{Manifest.permission.READ_CONTACTS}, 0);

}
almisoft
la source
1
Je suis confronté au même problème mais je ne parviens pas à entrer onActivityCreated()mon code. SDK 23.
kAmol
Je ne suis pas fragmenté, j'essaie de le faire le onCréer une activité
kAmol
Hmm, ou utiliser onPause()?
almisoft
10

Ce problème était en fait provoqué par NestedFragments. Fondamentalement, la plupart des fragments que nous avons étendent un HostedFragment qui à son tour étend un CompatFragment. La présence de ces fragments imbriqués a provoqué des problèmes qui ont finalement été résolus par un autre développeur du projet.

Il faisait des choses de bas niveau comme la commutation de bits pour que cela fonctionne, donc je ne suis pas trop sûr de la solution finale réelle

AndyOHart
la source
Cela m'a aidé à résoudre mon problème: j'ai dû rediriger le onRequestPermissionsResult du fragment parent vers le fragment enfant (imbriqué). Merci pour le conseil!
Murphy
9
 /* use the object of your fragment to call the 
 * onRequestPermissionsResult in fragment after
 * in activity and use different request Code for 
 * both Activity and Fragment */

   if (isFragment)
    mFragment.requestPermissions(permissions.toArray(new
    String[permissions.size()]),requestPermission);

   else
    ActivityCompat.requestPermissions(mActivity,permissions.toArray(new
    String[permissions.size()]),requestPermission);
Shahab Rauf
la source
6

Cela fonctionnera ..

@Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
Sumit khare
la source
la super implémentation appelle la mise en œuvre des fragments pas le cadre hte
Mohammad Yahia
5

Si vous appelez ce code à partir d'un fragment, il a sa propre méthode requestPermissions.

Donc, le concept de base est, si vous êtes dans une activité, appelez

ActivityCompat.requestPermissions(this,
                            permissionsList,
                            permissionscode);

et si dans un fragment, il suffit d'appeler

requestPermissions(permissionsList,
                            permissionscode);
PounKumar Purushothaman
la source
1
Nécessite l'API niveau 23 ... Sur les versions antérieures, utilisez FragmentCompat.requestPermissions().
Minas Mina
5

J'ai eu un problème similaire, sauf que j'appuyais sur un bouton pour passer un appel, ce qui déclenche l'appelIntent. J'ai vérifié l'autorisation d'abord, si elle n'est pas accordée, je demande l'autorisation et onRequestPermissionResult j'appelle l'autorisation de vérification et j'appelle à nouveau.

 @Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case Constants.PERMISSIONS_REQUEST_CALL_PHONE: {
            if ( grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                checkPermissionsAndCall();
            }
        }
    }
}

public void checkPermissionsAndCall(){
    if (Build.VERSION.SDK_INT > 22) {
        if(ContextCompat.checkSelfPermission(getContext(),
                Manifest.permission.CALL_PHONE)
                != PackageManager.PERMISSION_GRANTED){
            requestPermissions( new String[]{Manifest.permission.CALL_PHONE}, Constants.PERMISSIONS_REQUEST_CALL_PHONE);
        }
        else{
            callIntent();
        }
    }
}
Ndheti
la source
2

Avant de tout vérifier selon les réponses ci-dessus, assurez-vous que votre code de demande n'est pas 0 !!!

vérifiez le code de onRequestPermissionsResult () dans FragmentActivity.java:

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
        @NonNull int[] grantResults) {
    int index = (requestCode>>16)&0xffff;
    if (index != 0) {
        index--;

        String who = mPendingFragmentActivityResults.get(index);
        mPendingFragmentActivityResults.remove(index);
        if (who == null) {
            Log.w(TAG, "Activity result delivered for unknown Fragment.");
            return;
        }
        Fragment frag = mFragments.findFragmentByWho(who);
        if (frag == null) {
            Log.w(TAG, "Activity result no fragment exists for who: " + who);
        } else {
            frag.onRequestPermissionsResult(requestCode&0xffff, permissions, grantResults);
        }
    }
}
Chandler
la source
2
private void showContacts() {
    if (getActivity().checkSelfPermission(Manifest.permission.READ_CONTACTS)
        != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.READ_CONTACTS}, PERMISSIONS_REQUEST_READ_CONTACTS);
    } else {
        doShowContacts();
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    if (requestCode == PERMISSIONS_REQUEST_READ_CONTACTS && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        doShowContacts();
    }
}
user2002721
la source
2

J'ai une solution incroyable pour y parvenir, faites une BaseActivity comme celle-ci.

public class BaseActivity extends AppCompatActivity {

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler(this));


}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
    switch (requestCode) {
        case 1: {
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                CustomToast.getInstance().setCustomToast("Now you can share the Hack.");

            } else {
                Toast.makeText(this, "Permission denied to read your External storage", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

}

Maintenant, vous pouvez appeler le code pour demander une autorisation comme celle-ci

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

Maintenant, chaque fois que cela se produit, que ce soit dans votre fragment ou dans n'importe quelle activité, l'activité de base sera appelée.

Merci

Abhishek Dubey
la source
1

Vous pouvez utiliser requestPermissions(PERMISSIONS, MULTIPLE_PERMISSIONS_CODE);. N'utilisez pas FragmentCompat si vous utilisez v4.

Remario
la source
Veuillez expliquer pourquoi.
Placeable le
1

Détails

  • Kotlin 1.2.70
  • vérifié dans minSdkVersion 19
  • Android studio 3.1.4

Algorithme

module - caméra, emplacement, ....

  1. Vérifiez si hasSystemFeature (si le module existe dans le téléphone)
  2. Vérifiez si l'utilisateur a accès au module
  3. Envoyer une demande d'autorisation (demander à l'utilisateur d'autoriser l' utilisation du module )

Caractéristiques

  1. Travailler avec des activités et des fragments
  2. N'a qu'une seule réponse
  3. Peut vérifier plusieurs modules en une seule demande

Solution

class PermissionType(val manifest_permission: String, val packageManager: String) {
    object Defined {
        val camera = PermissionType(Manifest.permission.CAMERA, PackageManager.FEATURE_CAMERA)
        val currentLocation = PermissionType(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.FEATURE_LOCATION_GPS)
    }
}

class  Permission {

    enum class PermissionResult {
        ACCESS_ALLOWED, ACCESS_DENIED, NO_SYSTEM_FEATURE;
    }

    interface ManagerDelegate {
        fun permissionManagerDelegate(result: Array<Pair<String, PermissionResult>>)
    }

    class Manager internal constructor(private val delegate: ManagerDelegate?) {

        private var context: Context? = null
        private var fragment: Fragment? = null
        private var activity: AppCompatActivity? = null
        private var permissionTypes: Array<PermissionType> = arrayOf()
        private val REQUEST_CODE = 999
        private val semaphore = Semaphore(1, true)
        private var result: Array<Pair<String, PermissionResult>> = arrayOf()


        constructor(permissionType: PermissionType, delegate: ManagerDelegate?): this(delegate) {
            permissionTypes = arrayOf(permissionType)
        }

        constructor(permissionTypes: Array<PermissionType>, delegate: ManagerDelegate?): this(delegate) {
            this.permissionTypes = permissionTypes
        }

        init {
            when (delegate) {
                is Fragment -> {
                    this.fragment = delegate
                    this.context = delegate.context
                }

                is AppCompatActivity -> {
                    this.activity = delegate
                    this.context = delegate
                }
            }
        }

        private fun hasSystemFeature(permissionType: PermissionType) : Boolean {
            return context?.packageManager?.hasSystemFeature(permissionType.packageManager) ?: false
        }

        private fun hasAccess(permissionType: PermissionType) : Boolean {
            return if (Build.VERSION.SDK_INT < 23) true else {
                context?.checkSelfPermission(permissionType.manifest_permission) == PackageManager.PERMISSION_GRANTED
            }
        }

        private fun sendRequest(permissionTypes: Array<String>) {

            if (fragment != null) {
                fragment?.requestPermissions(permissionTypes, REQUEST_CODE)
                return
            }

            if (activity != null){
                ActivityCompat.requestPermissions(activity!!, permissionTypes, REQUEST_CODE)
            }
        }

        fun check() {

            semaphore.acquire()
            AsyncTask.execute {
                var permissionsForSendingRequest: Array<String> = arrayOf()
                this.result = arrayOf()

                for (it in permissionTypes) {
                    if (!hasSystemFeature(it)) {
                        result += Pair(it.manifest_permission, PermissionResult.NO_SYSTEM_FEATURE)
                        continue
                    }

                    if (hasAccess(it)) {
                        result += Pair(it.manifest_permission, PermissionResult.ACCESS_ALLOWED)
                    } else {
                        permissionsForSendingRequest += it.manifest_permission
                    }
                }

                if (permissionsForSendingRequest.isNotEmpty()) {
                    sendRequest(permissionsForSendingRequest)
                } else {
                    delegate?.permissionManagerDelegate(result)
                }
            }
        }

        fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
            when (requestCode) {
                REQUEST_CODE -> {
                    if (grantResults.isEmpty()) {
                        return
                    }
                    for ((i,permission) in permissions.withIndex()) {
                        for (item in this.permissionTypes) {
                            if (permission == item.manifest_permission && i < grantResults.size) {
                                result += if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                                    Pair(item.manifest_permission, PermissionResult.ACCESS_ALLOWED)
                                } else {
                                    Pair(item.manifest_permission, PermissionResult.ACCESS_DENIED)
                                }
                                break
                            }
                        }
                    }
                    delegate?.permissionManagerDelegate(result)
                }
            }
            semaphore.release()
        }
    }
}

Utilisation dans l'activité (dans le même fragment)

class BaseActivity : AppCompatActivity(), Permission.ManagerDelegate {

    private lateinit var permissionManager: Permission.Manager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.base_activity)

        permissionManager = Permission.Manager(arrayOf(PermissionType.Defined.camera, PermissionType.Defined.currentLocation), this)
        permissionManager.check()
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        permissionManager.onRequestPermissionsResult(requestCode, permissions, grantResults)
    }


    override fun permissionManagerDelegate(result: Array<Pair<String, Permission.PermissionResult>>) {
        result.forEach {
            println("!!! ${it.first} ${it.second}")
//            when (it.second) {
//                Permission.PermissionResult.NO_SYSTEM_FEATURE -> {
//                }
//
//                Permission.PermissionResult.ACCESS_DENIED  -> {
//                }
//
//                Permission.PermissionResult.ACCESS_ALLOWED -> {
//                }
//            }
        }
    }
}
Vasily Bodnarchuk
la source
1

Ici, je veux montrer à mon code comment j'ai géré cela.

public class CheckPermission {

public Context context;

public static final int PERMISSION_REQUEST_CODE =  200;

public CheckPermission(Context context){
    this.context = context;
}

public boolean isPermissionGranted(){
    int read_contact = ContextCompat.checkSelfPermission(context.getApplicationContext() , READ_CONTACTS);
    int phone = ContextCompat.checkSelfPermission(context.getApplicationContext() , CALL_PHONE);

    return read_contact == PackageManager.PERMISSION_GRANTED && phone == PackageManager.PERMISSION_GRANTED;
   }
}

Ici, dans cette classe, je veux vérifier l'autorisation accordée ou non. N'est-ce pas alors que j'appellerai la permission de mon activité principale comme

public void requestForPermission() {
       ActivityCompat.requestPermissions(MainActivity.this, new String[]    {READ_CONTACTS, CALL_PHONE}, PERMISSION_REQUEST_CODE);
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode) {
        case PERMISSION_REQUEST_CODE:
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                if (shouldShowRequestPermissionRationale(ACCESS_FINE_LOCATION)) {
                    showMessageOKCancel("You need to allow access to both the permissions",
                            new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                                        requestPermissions(new String[]{Manifest.permission.READ_CONTACTS, Manifest.permission.CALL_PHONE},
                                                PERMISSION_REQUEST_CODE);
                                    }
                                }
                            });
                    return;
                }
            }
    }
}

Maintenant, dans la méthode onCreate, vous devez appeler la fonction requestForPermission ().

Vous pouvez également demander plusieurs autorisations à la fois.

pavel
la source
1

MISE À JOUR: vu la réponse de quelqu'un d'autre à propos de l'appel super.onRequestPermissionResult()dans Activity et qui résout le problème de code de demande que j'ai mentionné et appelle le onRequestPermissionResult du fragment.

ignorer ce genre de choses:

Pour moi, il appelait l' onRequestPermissionResultActivity malgré moi fragment.requestPermission(...), MAIS il a renvoyé le résultat avec un requestCode incorrect (111 transformé en 65647 pourquoi ??? je ne saurai jamais).

Heureusement, c'est la seule autorisation que nous demandons sur cet écran, donc j'ignore simplement le code de demande (je n'ai pas le temps de comprendre pourquoi il n'est pas correct en ce moment)

grgrssll
la source
Ajoutez 65536 et 111 et vous l'obtiendrez. C'est à cause des masques de bits. Voir quelques sujets.
CoolMind
0

J'ai également rencontré un problème selon lequel même si vous appelez les requestPermissions correctes, vous pouvez toujours avoir ce problème. Le problème est que l'activité parent peut remplacer cette méthode sans appeler super. Ajoutez super et ce sera corrigé.

VolodymyrH
la source