Permisos múltiples de Android 6.0
Sé que Android 6.0 tiene nuevos permisos y sé que puedo llamarlos con algo como esto
if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE }, PERMISSION_WRITE_STORAGE); }
Hoy vi una aplicación de Google que necesita 3 permisos: contactos, sms y cámara. Se está haciendo una página 1-3 y los llama a todos juntos al mismo tiempo para activar.
- ¿Cómo comprobar si se da el permiso "android.permission.PACKAGE_USAGE_STATS"?
- Java.io.FileNotFoundException (permiso denegado) Al intentar escribir en el sdcard de Android
- ¿Cómo obtener permisos adicionales de Facebook con android sdk 3.0 beta?
- Unidad de pruebas de Android y permisos
- Permission.READ_CONTACTS no parece funcionar
¿Puede alguien decirme cómo puedo llamar a 4 permisos para activar al mismo tiempo como sms, cámara, contactos y almacenamiento?
Ejemplo (olvidó el nombre de la aplicación de Google :()
La aplicación necesita sms, contactos y cámara
La aplicación me preguntó (y hizo un cuadro de diálogo page1-3) activar sms, activar los contactos y luego la cámara. Así que esta aplicación de Google estaba llamando a todos los 3 permisos necesarios juntos y mi pregunta es ¿cómo puedo lograr lo mismo?
- Obtener los permisos del sistema de Android al poner la aplicación en / system / app?
- Permiso del receptor de facturación en la aplicación
- Lo que puede causar un error socket () "Permiso denegado"?
- Uso de permisos que android 2.1 no sabe (en android 2.1)
- Solicitud de permiso de cámara con Android SDK 23
- ¿Valgrind no puede ejecutar la herramienta memcheck en el sistema operativo Android?
- Solicitar permisos de Android M de la actividad con noHistory = "true" y / o showOnLockScreen = "true"
- Android - ¿Cómo conozco todos los métodos que requieren un cierto permiso?
Solo incluye los 4 permisos en la llamada de ActivityCompat.requestPermissions(...)
y Android automáticamente los pagará juntos como mencionaste.
Tengo un método auxiliar para comprobar permisos múltiples y ver si alguno de ellos no se conceden.
public static boolean hasPermissions(Context context, String... permissions) { if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && context != null && permissions != null) { for (String permission : permissions) { if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) { return false; } } } return true; }
A continuación, sólo tiene que enviar todos los permisos. Android solo preguntará por los que necesita.
// The request code used in ActivityCompat.requestPermissions() // and returned in the Activity's onRequestPermissionsResult() int PERMISSION_ALL = 1; String[] PERMISSIONS = {Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_SMS, Manifest.permission.CAMERA}; if(!hasPermissions(this, PERMISSIONS)){ ActivityCompat.requestPermissions(this, PERMISSIONS, PERMISSION_ALL); }
A continuación se muestra un ejemplo detallado con varias solicitudes de permisos:
La aplicación necesita 2 permisos en el inicio. SEND_SMS y ACCESS_FINE_LOCATION (ambos se mencionan en manifest.xml).
Estoy utilizando la biblioteca de soporte v4 que está preparado para manejar Android pre-Marshmallow y por lo tanto no es necesario comprobar las versiones de construcción.
Tan pronto como la aplicación se inicia, pide permisos múltiples juntos. Si ambos permisos se conceden el flujo normal va.
public static final int REQUEST_ID_MULTIPLE_PERMISSIONS = 1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if(checkAndRequestPermissions()) { // carry on the normal flow, as the case of permissions granted. } } private boolean checkAndRequestPermissions() { int permissionSendMessage = ContextCompat.checkSelfPermission(this, Manifest.permission.SEND_SMS); int locationPermission = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION); List<String> listPermissionsNeeded = new ArrayList<>(); if (locationPermission != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.ACCESS_FINE_LOCATION); } if (permissionSendMessage != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.SEND_SMS); } if (!listPermissionsNeeded.isEmpty()) { ActivityCompat.requestPermissions(this, listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]),REQUEST_ID_MULTIPLE_PERMISSIONS); return false; } return true; }
ContextCompat.checkSelfPermission (), ActivityCompat.requestPermissions (), ActivityCompat.shouldShowRequestPermissionRationale () son parte de la biblioteca de soporte.
En caso de que no se concedan uno o más permisos, ActivityCompat.requestPermissions () solicitará permisos y el control pasará al método de devolución onRequestPermissionsResult ().
Debe comprobar el valor del indicador shouldShowRequestPermissionRationale () en el método de devolución de llamada onRequestPermissionsResult ().
Sólo hay dos casos: –
Caso 1: -Cuando el usuario haga clic en Denegar permisos (incluso la primera vez), devolverá true. Así que cuando el usuario niega, podemos mostrar más explicación y seguir preguntando de nuevo
Caso 2: -Sólo si el usuario selecciona "nunca vuelve a preguntar" volverá a false. En este caso, podemos continuar con la funcionalidad limitada y guiar al usuario a activar los permisos de las configuraciones para más funcionalidades, o podemos terminar la configuración, si los permisos son triviales para la aplicación.
CASO 1
CASE-2
@Override public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) { Log.d(TAG, "Permission callback called-------"); switch (requestCode) { case REQUEST_ID_MULTIPLE_PERMISSIONS: { Map<String, Integer> perms = new HashMap<>(); // Initialize the map with both permissions perms.put(Manifest.permission.SEND_SMS, PackageManager.PERMISSION_GRANTED); perms.put(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.PERMISSION_GRANTED); // Fill with actual results from user if (grantResults.length > 0) { for (int i = 0; i < permissions.length; i++) perms.put(permissions[i], grantResults[i]); // Check for both permissions if (perms.get(Manifest.permission.SEND_SMS) == PackageManager.PERMISSION_GRANTED && perms.get(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) { Log.d(TAG, "sms & location services permission granted"); // process the normal flow //else any one or both the permissions are not granted } else { Log.d(TAG, "Some permissions are not granted ask again "); //permission is denied (this is the first time, when "never ask again" is not checked) so ask again explaining the usage of permission // // shouldShowRequestPermissionRationale will return true //show the dialog or snackbar saying its necessary and try again otherwise proceed with setup. if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.SEND_SMS) || ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)) { showDialogOK("SMS and Location Services Permission required for this app", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { switch (which) { case DialogInterface.BUTTON_POSITIVE: checkAndRequestPermissions(); break; case DialogInterface.BUTTON_NEGATIVE: // proceed with logic by disabling the related features or quit the app. break; } } }); } //permission is denied (and never ask again is checked) //shouldShowRequestPermissionRationale will return false else { Toast.makeText(this, "Go to settings and enable permissions", Toast.LENGTH_LONG) .show(); // //proceed with logic by disabling the related features or quit the app. } } } } } } private void showDialogOK(String message, DialogInterface.OnClickListener okListener) { new AlertDialog.Builder(this) .setMessage(message) .setPositiveButton("OK", okListener) .setNegativeButton("Cancel", okListener) .create() .show(); }
Código pequeño:
public static final int MULTIPLE_PERMISSIONS = 10; // code you want. String[] permissions= new String[]{ Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA, Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION}; if (checkPermissions()) // permissions granted. } private boolean checkPermissions() { int result; List<String> listPermissionsNeeded = new ArrayList<>(); for (String p:permissions) { result = ContextCompat.checkSelfPermission(getActivity(),p); if (result != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(p); } } if (!listPermissionsNeeded.isEmpty()) { ActivityCompat.requestPermissions(this, listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]),MULTIPLE_PERMISSIONS ); return false; } return true; } @Override public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) { switch (requestCode) { case MULTIPLE_PERMISSIONS:{ if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){ // permissions granted. } else { String permissions = ""; for (String per : permissionsList) { permissions += "\n" + per; } // permissions list of don't granted permission } return; } } }
Documentación de Stackoverflow
Lista de permisos de Android permisos normales y permisos peligrosos en API 23
Es fácil hacerlo de esta manera
private static final int REQUEST_READ_PHONE_STATE = 110 , REQUEST_ACCESS_FINE_LOCATION = 111, REQUEST_WRITE_STORAGE = 112;
En tu onCreate
//request permission boolean hasPermissionPhoneState = (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED); if (!hasPermissionPhoneState) { ActivityCompat.requestPermissions(LoginActivity.this, new String[]{Manifest.permission.READ_PHONE_STATE}, REQUEST_READ_PHONE_STATE); } boolean hasPermissionLocation = (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED); if (!hasPermissionLocation) { ActivityCompat.requestPermissions(LoginActivity.this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUEST_ACCESS_FINE_LOCATION); } boolean hasPermissionWrite = (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED); if (!hasPermissionWrite) { ActivityCompat.requestPermissions(LoginActivity.this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_WRITE_STORAGE); }
A continuación, compruebe el resultado
@Override public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); switch (requestCode) { case REQUEST_READ_PHONE_STATE: { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(LoginActivity.this, "Permission granted.", Toast.LENGTH_SHORT).show(); //reload my activity with permission granted or use the features what required the permission finish(); startActivity(getIntent()); } else { Toast.makeText(LoginActivity.this, "The app was not allowed to get your phone state. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show(); } } case REQUEST_ACCESS_FINE_LOCATION: { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(LoginActivity.this, "Permission granted.", Toast.LENGTH_SHORT).show(); //reload my activity with permission granted or use the features what required the permission finish(); startActivity(getIntent()); } else { Toast.makeText(LoginActivity.this, "The app was not allowed to get your location. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show(); } } case REQUEST_WRITE_STORAGE: { if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { Toast.makeText(LoginActivity.this, "Permission granted.", Toast.LENGTH_SHORT).show(); //reload my activity with permission granted or use the features what required the permission finish(); startActivity(getIntent()); } else { Toast.makeText(LoginActivity.this, "The app was not allowed to write to your storage. Hence, it cannot function properly. Please consider granting it this permission", Toast.LENGTH_LONG).show(); } } } }
En un fragmento
public class Homefragment extends Fragment { View hfrag; Context context; public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { //first we must check the permissions are already granted hfrag = inflater.inflate(R.layout.home, container, false); context = getActivity(); checkAndRequestPermissions(); } } private boolean checkAndRequestPermissions() { int permissionSendMessage = ContextCompat.checkSelfPermission(context, Manifest.permission.READ_SMS); int contactpermission = ContextCompat.checkSelfPermission(context, Manifest.permission.GET_ACCOUNTS); int writepermission = ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE); int callpermission = ContextCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE); int receivepermission = ContextCompat.checkSelfPermission(context, Manifest.permission.RECEIVE_SMS); int locationpermission = ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION); List<String> listPermissionsNeeded = new ArrayList<>(); if (locationpermission != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.ACCESS_FINE_LOCATION); } if (contactpermission != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.GET_ACCOUNTS); } if (writepermission != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.WRITE_EXTERNAL_STORAGE); } if (permissionSendMessage != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.READ_SMS); } if (receivepermission != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.RECEIVE_SMS); } if (callpermission != PackageManager.PERMISSION_GRANTED) { listPermissionsNeeded.add(Manifest.permission.CALL_PHONE); } if (!listPermissionsNeeded.isEmpty()) { requestPermissions(listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]), REQUEST_ID_MULTIPLE_PERMISSIONS); return false; } return true; } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (requestCode == REQUEST_ID_MULTIPLE_PERMISSIONS) { if (grantResults.length > 0) { for (int i = 0; i < permissions.length; i++) { if (permissions[i].equals(Manifest.permission.GET_ACCOUNTS)) { if (grantResults[i] == PackageManager.PERMISSION_GRANTED) { Log.e("msg", "accounts granted"); } } else if (permissions[i].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)) { if (grantResults[i] == PackageManager.PERMISSION_GRANTED) { Log.e("msg", "storage granted"); } } else if (permissions[i].equals(Manifest.permission.CALL_PHONE)) { if (grantResults[i] == PackageManager.PERMISSION_GRANTED) { Log.e("msg", "call granted"); } } else if (permissions[i].equals(Manifest.permission.RECEIVE_SMS)) { if (grantResults[i] == PackageManager.PERMISSION_GRANTED) { Log.e("msg", "sms granted"); } } else if (permissions[i].equals(Manifest.permission.ACCESS_FINE_LOCATION)) { if (grantResults[i] == PackageManager.PERMISSION_GRANTED) { Log.e("msg", "location granted"); } } } } } }
}
La siguiente metodología es sobre
- Pedir permisos dinámicamente;
- Mostrando un AlertDialog si el usuario niega cualquier permiso
- Bucle hasta que el usuario acepte permiso (s)
Crear una clase "estática" para los métodos de permisos
public class PermissionsUtil { public static final int PERMISSION_ALL = 1; public static boolean doesAppNeedPermissions(){ return android.os.Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP_MR1; } public static String[] getPermissions(Context context) throws PackageManager.NameNotFoundException { PackageInfo info = context.getPackageManager().getPackageInfo( context.getPackageName(), PackageManager.GET_PERMISSIONS); return info.requestedPermissions; } public static void askPermissions(Activity activity){ if(doesAppNeedPermissions()) { try { String[] permissions = getPermissions(activity); if(!checkPermissions(activity, permissions)){ ActivityCompat.requestPermissions(activity, permissions, PERMISSION_ALL); } } catch(Exception e) { e.printStackTrace(); } } } public static boolean checkPermissions(Context context, String... permissions){ if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && context != null && permissions != null) { for (String permission : permissions) { if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) { return false; } } } return true; } }
En MainActivity.java
private void checkPermissions(){ PermissionsUtil.askPermissions(this); } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); switch (requestCode) { case PermissionsUtil.PERMISSION_ALL: { if (grantResults.length > 0) { List<Integer> indexesOfPermissionsNeededToShow = new ArrayList<>(); for(int i = 0; i < permissions.length; ++i) { if(ActivityCompat.shouldShowRequestPermissionRationale(this, permissions[i])) { indexesOfPermissionsNeededToShow.add(i); } } int size = indexesOfPermissionsNeededToShow.size(); if(size != 0) { int i = 0; boolean isPermissionGranted = true; while(i < size && isPermissionGranted) { isPermissionGranted = grantResults[indexesOfPermissionsNeededToShow.get(i)] == PackageManager.PERMISSION_GRANTED; i++; } if(!isPermissionGranted) { showDialogNotCancelable("Permissions mandatory", "All the permissions are required for this app", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialogInterface, int i) { checkPermissions(); } }); } } } } } } private void showDialogNotCancelable(String title, String message, DialogInterface.OnClickListener okListener) { new AlertDialog.Builder(this) .setTitle(title) .setMessage(message) .setPositiveButton("OK", okListener) .setCancelable(false) .create() .show(); }
He encontrado esto en el ejemplo de permisos de tiempo de ejecución de github de Google.
private static String[] PERMISSIONS_CONTACT = {Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS}; private static final int REQUEST_CONTACTS = 1; ActivityCompat.requestPermissions(this, PERMISSIONS_CONTACT, REQUEST_CONTACTS);
Compruebe la sección "Solicitar varios permisos a la vez" en este artículo:
Cosas que necesita saber acerca de los permisos de Android M
Está muy bien explicado, y también puede tocar otros temas relacionados que no han pensado.
He implementado con éxito código simple para permiso Múltiple a la vez. Siga los siguientes pasos 1: Haga que la clase Utility.java sea como a continuación
public class Utility { public static final int MY_PERMISSIONS_REQUEST = 123; @TargetApi(Build.VERSION_CODES.JELLY_BEAN) public static boolean checkPermissions(Context context, String... permissions) { if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && context != null && permissions != null) { for (String permission : permissions) { if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) { if (ActivityCompat.shouldShowRequestPermissionRationale((Activity) context, permission)) { ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.CALL_PHONE,Manifest.permission.GET_ACCOUNTS}, MY_PERMISSIONS_REQUEST); } else { ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.CALL_PHONE,Manifest.permission.GET_ACCOUNTS}, MY_PERMISSIONS_REQUEST); } return false; } } } return true; } }
2: Ahora llame
boolean permissionCheck = Utility.checkPermissions(this, Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.CALL_PHONE, Manifest.permission.GET_ACCOUNTS);
En su Actividad onCreate () o de acuerdo a su lógica.
3: Ahora compruebe el permiso antes de realizar la operación para la tarea particular
if (permissionCheck) { performTaskOperation();//this method what you need to perform } else { Toast.makeText(this, "Need permission ON.", Toast.LENGTH_SHORT).show(); }
4: Ahora implementa el método onRequestPermissionsResult () en tu actividad como se muestra a continuación
@Override public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { switch (requestCode) { case Utility.MY_PERMISSIONS_REQUEST: if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { if (userChoosenTask.equals("STORAGE")) performTaskOperation();//this method what you need to perform } break; } }
Corto y dulce :). En lo que creo.
int PERMISSION_ALL = 1; String[] PERMISSIONS = {Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}; // List of permissions required public void askPermission() { for (String permission : PERMISSIONS) { if (ActivityCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) { requestPermissions(PERMISSIONS, PERMISSION_ALL); return; } } } @Override public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { switch (requestCode) { case 1:{ if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED && grantResults[1] == PackageManager.PERMISSION_GRANTED){ //Do your work. } else { Toast.makeText(this, "Until you grant the permission, we cannot proceed further", Toast.LENGTH_SHORT).show(); } return; } }
Usa el ayudante como este (los nombres de los permisos no importan).
public class MyPermission { private static final int PERMISSION_REQUEST_ALL = 127; private MainActivity mMainActivity; MyPermission(MainActivity mainActivity) { mMainActivity = mainActivity; } public static boolean hasPermission(String permission, Context context) { if (isNewPermissionModel()) { return (ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED); } return true; } private static boolean hasPermissions(Context context, String... permissions) { if (isNewPermissionModel() && context != null && permissions != null) { for (String permission : permissions) { if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) { return false; } } } return true; } private static boolean shouldShowRationale(Activity activity, String permission) { return isNewPermissionModel() && ActivityCompat.shouldShowRequestPermissionRationale(activity, permission); } private static boolean isNewPermissionModel() { return VERSION.SDK_INT > VERSION_CODES.LOLLIPOP_MR1; } /** * check all permissions */ void checkAll() { //check dangerous permissions, make request if need (Android will ask only for the ones it needs) String[] PERMISSIONS = { permission.READ_CALENDAR, permission.ACCESS_COARSE_LOCATION }; if (!hasPermissions(mMainActivity, PERMISSIONS)) { ActivityCompat.requestPermissions(mMainActivity, PERMISSIONS, PERMISSION_REQUEST_ALL); } } void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if (requestCode == PERMISSION_REQUEST_ALL) { if (grantResults.length > 0) { //for not granted for (int i = 0; i < permissions.length; i++) { if (permissions[i].equals(permission.READ_CALENDAR)) { if (grantResults[i] != PackageManager.PERMISSION_GRANTED) { smartRequestPermissions(permission.READ_CALENDAR, R.string.permission_required_dialog_read_calendar); } } else if (permissions[i].equals(permission.ACCESS_COARSE_LOCATION)) { if (grantResults[i] != PackageManager.PERMISSION_GRANTED) { smartRequestPermissions(permission.ACCESS_COARSE_LOCATION, R.string.permission_required_dialog_access_coarse_location); } } } } } } private void smartRequestPermissions(final String permissionName, int permissionRequiredDialog) { if (shouldShowRationale(mMainActivity, permissionName)) {// If the user turned down the permission request in the past and chose the Don't ask again option in the permission request system dialog, this method returns false. //Show an explanation to the user with action mMainActivity.mSnackProgressBarManager.show( new SnackProgressBar( SnackProgressBar.TYPE_ACTION, mMainActivity.getString(permissionRequiredDialog) ) .setAction("OK", new OnActionClickListener() { @Override public void onActionClick() { checkAll(); } }) .setSwipeToDismiss(true).setAllowUserInput(true) , MainActivity.SNACKBAR_WARNING_DURATION ); } // else do nothing }
}
- ¿Cómo auto importar las clases necesarias en Android Studio con acceso directo?
- Cómo crear un hilo Looper, a continuación, enviar un mensaje de inmediato?