onRequestPermissionsResult não está sendo chamado no fragmento se definido no fragmento e na atividade

Eu tenho um fragmento no qual tenho uma visão de reciclagem e definindo dados nessa visão de reciclagem usando o adaptador de visão de reciclagem.

Agora, estou com um botão no item de lista do adaptador clicando no qual preciso verificar a permissão READ_EXTERNAL_STORAGE no android para obter um novo modelo de permissão no android.

Eu criei uma nova função no fragmento deste adaptador para verificar se a permissão foi concedida ou não e, se já não tiver sido concedida, solicitar a permissão.

Passei MyFragment.this como um parâmetro no adaptador e, chamando o método do fragmento no botão, clique no adaptador.

Eu usei o código abaixo para chamar requestPermission no fragmento.

if(ContextCompat.checkSelfPermission(mContext, Manifest.permission.READ_EXTERNAL_STORAGE)
            != PackageManager.PERMISSION_GRANTED){
       requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                ConstantVariables.READ_EXTERNAL_STORAGE);
    }

Eu substituí o onRequestPermissionsResultmétodo no fragmento usando o código abaixo:

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case ConstantVariables.READ_EXTERNAL_STORAGE:
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                // permission was granted, proceed to the normal flow.
                startImageUploading();
            } else {}

Mas não está sendo chamado, em vez do método onRequestPermissionsResult desta atividade ser chamado.

Eu defini o mesmo método onRequestPermissionsResult na atividade pai do fragmento também e está sendo chamado.

Não consigo remover o método onRequestPermissionsResult da atividade, mas quero chamar o método onRequestPermissionsResult do fragmento quando solicito permissão do fragmento. Como posso fazer isso? Estou fazendo algo errado aqui, por favor me ajude se alguém tiver idéia aqui.

Resposta editada para cobrir problemas mais amplos

Eu acho que você está confundindo o método para fragmento e atividade. Tive um problema semelhante no meu projeto no mês passado. Por favor, verifique se você finalmente tem o seguinte:

1. Em AppCompatActivity, use o método ActivityCompat.requestpermissions
2. No fragmento de suporte v4, você deve usar requestpermissions
3. O problema é que, se você chamar AppcompatActivity.requestpermissions no seu fragmento, o retorno de chamada chegará à atividade e não ao fragmento
4. Certifique-se de ligar super.onRequestPermissionsResultda atividade onRequestPermissionsResult.

Veja se isso ajuda.

Solicitei permissão de localização de um fragmento e, no fragmento, precisava alterar isso:

            ActivityCompat.requestPermissions(getActivity(), new String[]{
                Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION}, LOCATION_REQ_CODE);

para isso:

            requestPermissions(new String[]{
                Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION}, LOCATION_REQ_CODE);

o onRequestPermissionsResult foi chamado no fragmento.

Esse é um erro comum que as pessoas cometem ao codificar marshmallow.

Quando em AppCompatActivity, você deve usar ActivityCompat.requestPermissions; Quando em android.support.v4.app.Fragment, você deve simplesmente solicitar 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 a atividade e não o fragmento.

requestPermissions(permissions, PERMISSIONS_CODE);

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,
                            new String[]{Manifest.permission.CAMERA},
                            MY_PERMISSIONS_REQUEST_CAMERA);

e se estiver em um fragmento, basta ligar

requestPermissions(new String[]{Manifest.permission.CAMERA},
                            MY_PERMISSIONS_REQUEST_CAMERA);

Para referência, obtive a resposta neste link https://www.coderzheaven.com/2016/10/12/onrequestpermissionsresult-not-called-on-fragments/

O método requestPermissionsem fragmentos requer API nível 23 ou superior.
Se seu aplicativo segmentar uma versão inferior, você poderá usar

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

Primeiro você precisa adicionar a dependência support-v13:

implementation "com.android.support:support-v13:$supportLibVersion"

mude isso :

ActivityCompat.requestPermissions(
    activity,
    arrayOf(Manifest.permission.READ_CONTACTS),
    PERMISSIONS_REQUEST_READ_CONTACTS
)

para isso :

requestPermissions(
     arrayOf(Manifest.permission.READ_CONTACTS),
     PERMISSIONS_REQUEST_READ_CONTACTS
)

private void showContacts() {
 if (getActivity().checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE)
         != PackageManager.PERMISSION_GRANTED) {
     requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
             PERMISSIONS_REQUEST_READ_STORAGE);
 } else {
     doShowContacts();
 }
}

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

alterar permissão

Esta resposta aceita não foi trabalhada para mim, então encontrei minha própria solução, explicada abaixo:

Primeiro, criei um método, no fragmento:

public static void MyOnRequestPermissionResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults){
        if (requestCode == 1 && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "Permission: true");
        } else {
            Log.d(TAG, "permission: false");
        }
}

2.E então o chamou de sua atividade subjacente:

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if(requestCode ==1){
        SignupFragment.MyOnRequestPermissionResult(requestCode, permissions, grantResults);
    }
}

E está funcionando ...

Verifique se tanto PERMISSION_REQUEST_CODEem onRequestPermissionsResulte dentro de sua Fragmentcontém o mesmo valor.

Para o tragetSDK 28, a verificação do SDK (> 23) e as permissões de solicitação do fragmento funcionariam. O ActivityCompat.requestPermissions está falhando (se você definir o código de solicitação abaixo de 65536, a caixa de diálogo de permissão será exibida e, se o usuário permitir, as permissões serão fornecidas, mas não haverá retorno de chamada. Mas se você definir acima de 65536, o ActivityCompat.requestPermissions ocorrerá. falhe imediatamente. não sei o raciocínio por trás dessa lógica. pode ser um bug ou intencional).

Código de trabalho:

  if (Build.VERSION.SDK_INT >= 23) {
                        requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION}, LOCATION_ACCESS_REQUEST);
                    }

Se você estiver trabalhando com o Kotlin, especifique exatamente que está chamando o método de fragmento, não a atividade

 fragment.requestPermissions(permissions, PERMISSIONS_CODE);

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

Solicite permissões de tempo de execução da v4.Fragment e o retorno de chamada vá para Fragment?

Eu tive o mesmo problema. Seu fragmento pode ser inicializado a partir do layout da atividade. Curtiu isso:

main_activty.xml

<fragment
    android:id="@+id/fragment"
    android:name="com.exampe.SomeFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Esse problema foi resolvido para mim quando eu usei FragmentTransactionvez

nas APIs abaixo de 23, você pode criar uma interface na atividade e implementá-la no fragmento filho. Quando você obtiver uma solicitação de permissão, a atividade passará para a interface implementada no fragmento. É simples assim :)

você pode chamar o método Fragment abaixo

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode) {
        case REQUEST_CODE:
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0 &&
                    grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission is granted. Continue the action or workflow
                // in your app.
                doActionBecauseNowYouCanBro();
            } else {
                // Explain to the user that the feature is unavailable because
                // the features requires a permission that the user has denied.
                // At the same time, respect the user's decision. Don't link to
                // system settings in an effort to convince the user to change
                // their decision.
                showWhyRequestPermissionsAndDontBlockUserItsCalledManners();
            }
            return;
    }
    // Other 'case' lines to check for other
    // permissions this app might request.

}

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