Permissões do Android M: onRequestPermissionsResult () não sendo chamado

Estou atualizando nosso aplicativo para usar o novo sistema de permissões de tempo de execução M. Está tudo funcionando, exceto onRequestPermissionsResult (). Preciso verificar uma permissão pressionando o botão e, se tiver êxito, enviar uma mensagem de texto. Quando concedo permissão para fazê-lo, a caixa de diálogo é fechada, mas não aciona o envio de texto até que eu pressione o botão novamente.

Depurei e defini pontos de interrupção no método onRequestPermissionsResult (), mas ele nunca entra nele.

Este método é chamado primeiro:

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

E então meu retorno de chamada fica assim:

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

Alguém já teve um problema semelhante? Agradeço qualquer ajuda com isso. obrigado

Encontrei o mesmo problema e encontrei a solução. Ao usar a biblioteca de Suporte, você deve usar as chamadas de método corretas. Por exemplo:

• Quando em AppCompatActivity , você deve usar ActivityCompat.requestPermissions ;
• Quando em android.support.v4.app.Fragment , você deve usar simplesmente requestPermissions (este é um método de instância de android.support.v4.app.Fragment)

Se você chamar ActivityCompat.requestPermissions em um fragmento, o retorno de chamada onRequestPermissionsResult será chamado na atividade e não no fragmento.

Espero que isto ajude!

Você pode tentar isso:

requestPermissions(permissions, PERMISSIONS_CODE);

Se você está chamando esse código de um fragmento, ele possui seu próprio método requestPermissions. Acredito que o problema é que você está chamando método estático.

Dica profissional, se você quiser o onRequestPermissionsResult()fragmento: FragmentCompat.requestPermissions(Fragment fragment, String[] permissions, int requestCode)

Espero que funcione bem

Para atividade:

 ActivityCompat.requestPermissions(this,permissionsList,REQUEST_CODE);

Para Fragmento:

 requestPermissions(permissionsList,REQUEST_CODE);

Eu também encontrei esse problema. Se você deseja que a atividade que lida com permissões não esteja no histórico / recentes, será tentada a alterar sua AndroidManifest.xmlentrada.

Se você definir a atividade que você chama requestPermissionsou AppCompatActivity.requestPermissionscom

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

no seu AndroidManifest.xmlentão onRequestPermissionsResult()não será chamado. Isso é verdade se sua atividade é derivada de Activityou AppCompatActivity.

Isso pode ser corrigido removendo os dois sinalizadores de 'AndroidManifest.xml' e finalizando sua atividade finishAndRemoveTask().

Se você possui onRequestPermissionsResultatividade e fragmento, lembre-se de chamar a super.onRequestPermissionsResultatividade. Não é necessário no fragmento, mas está em atividade.

Resposta descontinuada, consulte: https://developer.android.com/training/permissions/requesting

Fragmento interno, você precisa chamar:

FragmentCompat.requestPermissions(permissionsList, RequestCode)

Não:

ActivityCompat.requestPermissions(Activity, permissionsList, RequestCode);

Se você estiver usando requestPermissions no fragmento, ele aceitará 2 parâmetros em vez de 3.

Você deveria usar requestPermissions(permissions, PERMISSIONS_CODE);

Se, por algum motivo, você estendeu uma Atividade personalizada localizada em alguma biblioteca externa que não chama o super, precisará chamar manualmente o Fragmento super.onRequestPermissionsResult na sua Atividade 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);
    }
...

Você tem a função checkPermissions para dispositivos anteriores ao Marshmallow no FragmentCompat . Eu uso assim:

FragmentCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);

Eu descobri que é importante onde você chama android.support.v4.app.Fragment.requestPermissions .

Se você fizer isso onCreate(),onRequestPermissionsResult() nunca será chamado.

Solução: Ligue 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);

}

Esse problema estava realmente sendo causado por NestedFragments. Basicamente, na maioria dos fragmentos, estendemos um HostedFragment que, por sua vez, estende um CompatFragment. A presença desses fragmentos aninhados causou problemas que foram resolvidos por outro desenvolvedor no projeto.

Ele estava fazendo algumas coisas de baixo nível, como troca de bits, para que isso funcionasse, então não tenho certeza da solução final real

 /* 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);

Isso vai funcionar ..

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

Se você está chamando esse código de um fragmento, ele possui seu próprio método requestPermissions.

O conceito básico é que, se você estiver em uma atividade, chame

ActivityCompat.requestPermissions(this,
                            permissionsList,
                            permissionscode);

e se em um fragmento, basta ligar

requestPermissions(permissionsList,
                            permissionscode);

Eu tive um problema semelhante, exceto que estava pressionando um botão para fazer uma chamada, o que aciona o callIntent. Verifiquei a permissão primeiro, se não for concedida, peço permissão e onRequestPermissionResult chamo a permissão de verificação e ligo novamente.

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

Com base na resposta da goodgamerguy, a solução é:

myFragment.this.requestPermissions(....)

Antes de verificar tudo de acordo com as respostas acima, verifique se o seu código de solicitação não é 0 !!!

verifique o código de onRequestPermissionsResult () em 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);
        }
    }
}

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

Eu tenho uma solução incrível para conseguir isso, faça uma BaseActivity como esta.

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

}

Agora você pode chamar o código para pedir permissão como esta

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

Agora, toda vez que isso acontece em qualquer lugar, seja no seu fragmento ou em qualquer atividade, a atividade base seria chamada.

obrigado

Você pode usar requestPermissions(PERMISSIONS, MULTIPLE_PERMISSIONS_CODE);. Não use FragmentCompat se você estiver usando a v4.

Detalhes

• Kotlin 1.2.70
• verificado minSdkVersion 19
• Android studio 3.1.4

Algoritmo

módulo - câmera, localização, ....

1. Verifique se hasSystemFeature (se o módulo existir no telefone)
2. Verifique se o usuário tem acesso ao módulo
3. Enviar solicitação de permissão (peça ao usuário para permitir o uso do módulo )

Recursos

1. Trabalhar com atividades e fragmentos
2. Tem apenas uma resposta de resultado
3. Pode verificar vários módulos em uma solicitação

Solução

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

Uso em atividade (no mesmo fragmento)

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 -> {
//                }
//            }
        }
    }
}

Aqui eu quero mostrar meu código como eu gerenciei isso.

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

Aqui nesta classe, quero verificar a permissão concedida ou não. Não é, então irei chamar a permissão da minha MainActivity como

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

Agora, no método onCreate, você precisa chamar a função requestForPermission ().

Além disso, você também pode solicitar várias permissões de cada vez.

UPDATE: vi a resposta de outra pessoa sobre chamar super.onRequestPermissionResult()Activity e isso corrige o problema do código de solicitação que mencionei e chama o onRequestPermissionResult do fragmento.

ignore essas coisas:

Para mim, estava chamando o onRequestPermissionResultde Activity, apesar de eu ter chamadofragment.requestPermission(...) , mas retornou o resultado com um requestCode incorreto (111 se transformou em 65647 por que ??? eu nunca vou saber).

Felizmente, esta é a única permissão que solicitamos nessa tela, então eu simplesmente ignoro o código de solicitação (não tenha tempo para descobrir por que não está correto no momento)

Também encontrei um problema que, mesmo se você chamar requestPermissions, ainda poderá ter esse problema. O problema é que a atividade pai pode substituir esse método sem chamar super. Adicione super e será corrigido.