Cómo verificar el permiso en un fragmento

92

Quiero verificar un permiso dentro de un fragmento.

mi código:

        // Here, thisActivity is the current activity
        if (ContextCompat.checkSelfPermission(getActivity(),
                Manifest.permission.ACCESS_FINE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {


            // Should we show an explanation?
            if (ActivityCompat.shouldShowRequestPermissionRationale(getActivity(),
                    android.Manifest.permission.ACCESS_FINE_LOCATION)) {

                // Show an explanation to the user *asynchronously* -- don't block
                // this thread waiting for the user's response! After the user
                // sees the explanation, try again to request the permission.

            } else {

                // No explanation needed, we can request the permission.

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



                // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
                // app-defined int constant. The callback method gets the
                // result of the request.
            }
        }

pero onRequestPermissionsResultno llamado después de permitir o denegar.

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

                // permission was granted, yay! Do the
                // contacts-related task you need to do.
                //yes

                Log.e("test","1");

                Intent intent = new Intent(getActivity(), MapsActivity.class);
                intent.putExtra("latitude", 35.694828);
                intent.putExtra("longitude", 51.378129);
                startActivity(intent);

            } else {
                utilityFunctions.showSweetAlertWarning(getActivity(),r.getString(R.string.str_warning_title_empty),
                        r.getString(R.string.str_you_must_allow_this_permission_toast),
                        r.getString(R.string.str_warning_btn_login));

                Log.e("test","2");
            }
            return;
        }

        // other 'case' lines to check for other
        // permissions this app might request
    }
}
S.M_Emamian
fuente
¿Posible duplicado de los permisos de tiempo
R. Zagórski

Respuestas:

50

He hecho lo siguiente para verificar un permiso dentro de un fragmento.

if (ActivityCompat.checkSelfPermission(getContext(),
            android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&
            ActivityCompat.checkSelfPermission(getContext(),
                    android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
         requestPermissions(getActivity(),
                new String[]{android.Manifest.permission.ACCESS_COARSE_LOCATION,
                        android.Manifest.permission.ACCESS_FINE_LOCATION},
                REQUEST_LOCATION);
    } else {
        Log.e("DB", "PERMISSION GRANTED");
    }
desarrollador novato
fuente
3
Todavía tenemos que pedir permiso si el usuario no lo ha concedido.
Karan Thakkar
17
Recuerde que si hace esto, el resultado de su solicitud de permiso llegará a la actividad que inició su fragmento. Consulte la respuesta de ThetNaing Mizo para conocer una forma de recibir el resultado en su fragmento.
partir del
253

Así es como lo hice, me funciona. ¡Gracias!

Para actividad:

ActivityCompat.requestPermissions(this, permissionsList, REQUEST_CODE);

Para fragmento:

requestPermissions(permissionsList, REQUEST_CODE);
ThetNaing Mizo
fuente
Fragment requestPermissions requiere Android M, pero está disponible en FragmentCompat para versiones anteriores de API.
Brian White
20
Forma correcta de solicitar permiso dentro de un fragmento
Tarun
requestPermissions es usar mariscal y subir de nivel sdk
hamid
76

Fragmento tiene requestPermissions()y onRequestPermissionsResult()métodos, úselo.

Pero checkSelfPermission()es de ActivityCompat(no requiere Activity, solo Context).

if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
    requestPermissions( //Method of Fragment
        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 
        REQUEST_PERMISSIONS_CODE_WRITE_STORAGE
    );
} else {
    downloadImage();
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if (requestCode == REQUEST_PERMISSIONS_CODE_WRITE_STORAGE) {
        if (permissions[0].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            proceedWithSdCard();
        }
    }
}
Evgeny Nozdrev
fuente
Fragment requestPermissions requiere Android M pero está disponible en FragmentCompat.
Brian White
4

onRequestPermissionsResultse invoca en la actividad, no en el fragmento. En su lugar, intente anular onRequestPermissionsResultla actividad.

Ryan
fuente
Si bien esto es cierto, carece de una explicación de por qué esto es cierto y cómo solucionarlo, cómo onRequestPermissionResultfragmentarlo. Tanto la explicación como la forma de recibir el resultado en fragmentado se explican en la respuesta de ThetNaing Mizo .
partir del
Gracias, me preguntaba por qué mi código no funciona dentro de Fragment
Azizjon Kholmatov
4

Usando Kotlin, llama requestPermissions(arrayOf(Manifest.permission.THE_PERMISSION_CODE_YOU_WANT), PERMISSION_REQUEST_CODE)y agrega la siguiente anulación a su fragmento

override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out kotlin.String>, grantResults: IntArray): Unit {

}
Erik
fuente
4

Para manejar permisos en un método de Fragmentllamada requestPermissions. Si anula el onRequestPermissionsResultmétodo tanto en el fragmento como en la actividad, que contiene ese fragmento, asegúrese de llamar super.onRequestPermissionsResult(...)al método de actividad para propagar la llamada al onRequestPermissionsResultmétodo en el fragmento.

Sergey
fuente
3

Lo que funcionó para mí fue llamar al método onRequestPermissionsResult en la actividad dentro del cual se implementa el fragmento en lugar de llamarlo en el propio fragmento. Dentro del método onCreateView en fragmento:

    Button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            int permissionCheck = ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.READ_EXTERNAL_STORAGE);

            if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST_READ_MEDIA);
            }else{
                //Do your work
                fetchMethod();
            }

        }
});

En la actividad que ayuda a implementar el fragmento, fuera del método onCreate :

    @Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_READ_MEDIA:
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                fetchMethod();

            }else{
                Toast.makeText(getApplicationContext(), "Permission not granted!", Toast.LENGTH_SHORT).show();
            }
            break;

        default:
            break;
    }
}
Pranay Anand
fuente
0

Me estaba tropezando al usar checkSelfPermission()en a Fragmenty me preguntaba cuál sería el mejor enfoque para Contextser nulo (específico de Kotlin) ... ¿debería usar !!o algo más ?

Fui con algo más basado en el código que encontré en iosched . Eche un vistazo a la muestra a continuación y recuerde, antes de que Fragmentse adjunte a un Activity, Contextserá nulo.

private fun fineLocationPermissionApproved(): Boolean {

    val context = context ?: return false

    return PackageManager.PERMISSION_GRANTED == checkSelfPermission(
        context,
        Manifest.permission.ACCESS_FINE_LOCATION
    )
}
codificación jeremy
fuente