onRequestPermissionsResult no se llama en fragmento si se define tanto en fragmento como en actividad

Tengo un fragmento en el que tengo vista de reciclaje y datos de configuración en esta vista de reciclaje usando el adaptador de vista de reciclaje.

Ahora, tengo un botón en el elemento de la lista del adaptador haciendo clic en el cual necesito verificar el permiso READ_EXTERNAL_STORAGE en Android para obtener un nuevo modelo de permiso en Android.

He creado una nueva función en el fragmento de este adaptador para verificar si se otorga el permiso o no y solicitar permiso si ya no se ha otorgado.

He pasado MyFragment.this como parámetro en el adaptador y llamando al método del fragmento al hacer clic en el botón en el adaptador.

He usado el siguiente código para llamar a requestPermission en 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);
    }

He anulado el onRequestPermissionsResultmétodo fragmentado usando el siguiente código:

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

Pero no se llama, en lugar del método onRequestPermissionsResult de esta actividad se llama.

También he definido el mismo método onRequestPermissionsResult en la actividad principal del fragmento y se está llamando.

No puedo eliminar el método onRequestPermissionsResult de la actividad, pero quiero llamar al método onRequestPermissionsResult del fragmento cuando solicito permiso del fragmento. ¿Cómo puedo hacer esto? ¿Estoy haciendo algo mal aquí? Ayúdenme si alguien tiene una idea aquí.

Respuesta editada para cubrir problemas más amplios

Creo que estás confundiendo el método para el fragmento y la actividad. Tuve un problema similar en mi proyecto el mes pasado. Por favor, compruebe si finalmente tiene lo siguiente:

1. En AppCompatActivity use el método ActivityCompat.requestpermissions
2. En el fragmento de soporte v4, debe usar permisos de solicitud
3. La captura es si llama a AppcompatActivity.requestpermissions en su fragmento, la devolución de llamada se activará y no se fragmentará
4. Asegúrese de llamar super.onRequestPermissionsResultdesde la actividad onRequestPermissionsResult.

A ver si ayuda.

Solicité permiso de ubicación de un fragmento y en el fragmento, necesitaba cambiar esto:

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

a esto:

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

entonces se llamó a onRequestPermissionsResult en el fragmento.

Este es un error común que la gente comete al codificar malvavisco.

Cuando esté en AppCompatActivity, debe usar ActivityCompat.requestPermissions; Cuando esté en android.support.v4.app.Fragment, debe usar simplemente requestPermissions (este es un método de instancia de android.support.v4.app.Fragment) Si llama a ActivityCompat.requestPermissions en un fragmento, se llama a la devolución de llamada onRequestPermissionsResult la actividad y no el fragmento

requestPermissions(permissions, PERMISSIONS_CODE);

Si está llamando a este código desde un fragmento, tiene su propio método requestPermissions.

Entonces, el concepto básico es: si está en una actividad, llame al

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

y si está en un fragmento, solo llame

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

Para la referencia, obtuve la respuesta de este enlace https://www.coderzheaven.com/2016/10/12/onrequestpermissionsresult-not-called-on-fragments/

El método requestPermissionsen Fragments requiere un nivel de API 23 o superior.
Si su aplicación está dirigida a una versión inferior, puede usar

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

Primero debe agregar la dependencia support-v13:

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

cambia esto :

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

a esto :

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

cambiar permiso

Esta respuesta aceptada no me funcionó, así que encontré mi propia solución, que se explica a continuación:

1.Primero creé un método, en 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. Y luego lo llamó desde su actividad subyacente:

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

Y está funcionando ...

Verifique que tanto PERMISSION_REQUEST_CODEdentro onRequestPermissionsResultcomo dentro de su Fragmentcontiene el mismo valor.

Para el tragetSDK 28, la verificación SDK (> 23) y los permisos de solicitud del fragmento funcionarían. ActivityCompat.requestPermissions está fallando (si establece el código de solicitud por debajo de 65536, aparecerá el cuadro de diálogo de permiso y si el usuario lo permite, se otorgan los permisos, pero no se producirá una devolución de llamada. Pero si establece por encima de 65536, ActivityCompat.requestPermissions aparecerá falla inmediatamente. No sé el razonamiento detrás de esta lógica. Puede ser un error o intencional).

Código de trabajo:

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

Si está trabajando con Kotlin, debe especificar de manera explícita que está llamando al método de fragmento, no a la actividad

 fragment.requestPermissions(permissions, PERMISSIONS_CODE);

Permisos de Android M: no se llama a onRequestPermissionsResult ()

Solicite permisos de tiempo de ejecución de v4.Fragment y haga que la devolución de llamada vaya a Fragment?

Tuve el mismo problema. Su fragmento se puede inicializar desde el diseño de la actividad. Como eso:

main_activty.xml

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

Este problema se solucionó para mí cuando he usado FragmentTransactionen vez

en las API inferiores a 23, puede crear una interfaz en la actividad, luego implementarla en el fragmento secundario y, cuando obtiene la solicitud de permiso, la actividad la pasa a la interfaz implementada en fragmento. Es así de simple :)

puedes llamar al método Fragment a continuación

@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.

}

Este problema fue causado realmente por NestedFragments. Básicamente, en la mayoría de los fragmentos hemos extendido un HostedFragment que a su vez extiende un CompatFragment. Tener estos fragmentos anidados causó problemas que finalmente fueron resueltos por otro desarrollador en el proyecto.

Estaba haciendo algunas cosas de bajo nivel, como el cambio de bits para que esto funcione, así que no estoy muy seguro de la solución final real