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.

¿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?

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.

Introduzca aquí la descripción de la imagen

Introduzca aquí la descripción de la imagen

 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

Introduzca aquí la descripción de la imagen

CASE-2

Introduzca aquí la descripción de la imagen

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

}

  • Listando los permisos de la aplicación de Android vía adb
  • Permisos de aplicaciones en Android Marshmallow en PhoneGap
  • Los teléfonos de Redmi no piden permisos de SMS y por lo tanto no leen sms
  • Pantalla negra de la cámara Android
  • Funciones de Android y permisos de archivo
  • Todos los permisos de mi aplicación se revocan después de presionar "Restablecer las preferencias de la aplicación"
  • Acceso a la notificación de Android TV
  • Ejecutar comandos shell desde el programa android
  • Android 6: la escritura en el almacenamiento externo falla en la primera ejecución solamente
  • Vista web de Android: descarga archivos como los navegadores
  • Permiso para escribir en la tarjeta SD android
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.