¿Pueden solicitar permisos sincrónicamente en el modelo de permisos de ejecución de Android Marshmallow (API 23)?

En cuanto a Marshmallow, mi comprensión es que no puedes.

Tuve que resolver el mismo problema en mi aplicación. He aquí cómo lo hice:

1. Refactorización : Mueva cada fragmento de código que depende de permisos de algún tipo en un método propio.
2. Más refactorización : Identifique el disparador de cada método (como iniciar una actividad, tocar un control, etc.) y agrupar los métodos si tienen el mismo desencadenador. (Si dos métodos terminan teniendo el mismo trigger Y requiriendo el mismo conjunto de permisos, considere la posibilidad de combinarlos.)
3. Aún más refactoring : Averigüe lo que depende de los nuevos métodos que se han llamado antes, y asegúrese de que es flexible acerca de cuándo se llaman estos métodos: O bien moverlo en el método en sí, o al menos asegurarse de que lo que haces no Lanzar excepciones si su método no se ha llamado antes y que comienza a comportarse como se esperaba tan pronto como se llama al método.
4. Códigos de solicitud : Para cada uno de estos métodos (o grupos de ellos), defina una constante entera que se utilizará como un código de solicitud.
5. Comprobación y solicitud de permisos : Envuelva cada uno de estos métodos / grupos de métodos en el código siguiente:

.

 if (ContextCompat.checkSelfPermission(this, Manifest.permission.SOME_PERMISSION) == PackageManager.PERMISSION_GRANTED) doStuffThatRequiresPermission(); else ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.SOME_PERMISSION}, Const.PERM_REQUEST_DO_STUFF_THAT_REQUIRES_PERMISSION); 

6. Manejo de respuestas : Escriba una implementación para onRequestPermissionsResult() en cada Activity que solicite permisos. Compruebe si se concedieron los permisos solicitados y utilice el código de solicitud para determinar qué método debe llamarse.

Tenga en cuenta que la API requiere una Activity para las solicitudes de permisos de tiempo de ejecución. Si tiene componentes no interactivos (como un Service ), eche un vistazo a Cómo solicitar permisos de un servicio en Android Marshmallow para obtener consejos sobre cómo solucionarlo. Básicamente, la forma más fácil es mostrar una notificación que a continuación, mostrará una Activity que no hace nada, pero presentar el diálogo de permisos de tiempo de ejecución. Aquí es cómo abordé esto en mi aplicación.

Respuesta corta: no, no hay ninguna operación de sincronización hoy. Debe comprobar si tiene el permiso correcto antes de completar la operación o como última opción, podría poner un bloque try / catch para la excepción de seguridad. En el bloque catch puede informar al usuario que la operación ha fallado debido a problemas de permiso. Además, hay otro punto: cuando se revoca un permiso, la aplicación no se reinicia desde la actividad principal, por lo que debe comprobar el permiso incluso en su onResume ().

Así que odio responder a mi propia pregunta específicamente con respecto al permiso de android.permission.WRITE_EXTERNAL_STORAGE utilizado en mi ejemplo, pero qué diablos.

Para leer y / o escribir un archivo, en realidad hay una manera de evitar completamente tener que pedir y luego comprobar el permiso y así evitar el flujo completo que he descrito anteriormente. De esta manera, el saveFile (Url url, String content) que he dado como ejemplo podría seguir trabajando de forma síncrona.

La solución, que creo funciona en la API 19+, elimina la necesidad del permiso WRITE_EXTERNAL_STORAGE al tener un objeto DocumentsProvider como un "intermediario" para pedir al usuario en nombre de su aplicación "por favor seleccione el archivo específico para escribir" , Un "selector de archivos") y luego una vez que el usuario elige un archivo (o escribe un nuevo nombre de archivo), la aplicación ahora tiene permiso mágico de hacerlo para ese Uri, ya que el usuario lo ha concedido específicamente.

No se necesita permiso " WRITE_EXTERNAL_STORAGE " oficial.

Esta forma de obtener permisos de préstamo es parte del Storage Access Framework , y una discusión sobre esto fue hecha en el Big Android BBQ de Ian Lake. Este es un video llamado Forget the Storage Permission: Alternativas para compartir y colaborar que explican los conceptos básicos y cómo lo usas específicamente para evitar el requisito de permiso WRITE_EXTERNAL_STORAGE completo.

Esto no soluciona completamente el problema de permisos de sincronización / asincronización para todos los casos, pero para cualquier tipo de documento externo, o incluso uno que es ofrecido por un proveedor (como gDrive, Box.net, Dropbox, etc.) esto puede ser Una solución que merece la pena echarle un vistazo.

He aquí cómo solucioné el problema de "sincronicidad" sin tener que bloquear explícitamente (y esperar ocupado), o sin requerir una actividad separada de "cargador de arranque". I refactored pantalla de presentación Actividad de la siguiente manera :

Actualización: Un ejemplo más completo se puede encontrar aquí.

Note: Debido a que la API startActivityForResult() llama a startActivityForResult()

 public final void requestPermissions(@NonNull String[] permissions, int requestCode) { Intent intent = getPackageManager().buildRequestPermissionsIntent(permissions); startActivityForResult(REQUEST_PERMISSIONS_WHO_PREFIX, intent, requestCode, null); } 

La lógica de creación de vista principal se movió de OnCreate() a OnCreate2() y OnCreate() ahora controla la comprobación de permisos. Si RequestPermissions() necesita ser llamado, entonces el OnRequestPermissionsResult() asociado reinicia esta actividad (reenviando una copia del paquete original).

 [Activity(Label = "MarshmellowActivated", MainLauncher = true, Theme = "@style/Theme.Transparent", Icon = "@drawable/icon" //////////////////////////////////////////////////////////////// // THIS PREVENTS OnRequestPermissionsResult() from being called //NoHistory = true )] public class MarshmellowActivated : Activity { private const int ANDROID_PERMISSION_REQUEST_CODE__SDCARD = 112; private Bundle _savedInstanceState; public override void OnRequestPermissionsResult(int requestCode, string[] permissions, [GeneratedEnum] Permission[] grantResults) { base.OnRequestPermissionsResult(requestCode, permissions, grantResults); switch (requestCode) { case ANDROID_PERMISSION_REQUEST_CODE__SDCARD: if (grantResults.Length > 0 && grantResults[0] == Permission.Granted) { Intent restartThisActivityIntent = new Intent(this, this.GetType()); if (_savedInstanceState != null) { // *ref1: Forward bundle from one intent to another restartThisActivityIntent.PutExtras(_savedInstanceState); } StartActivity(restartThisActivityIntent); } else { throw new Exception("SD Card Write Access: Denied."); } break; } } protected override void OnCreate(Bundle savedInstanceState) { base.OnCreate(savedInstanceState); /////////////////////////////////////////////////////////////////////////////////////////////////////////// // Android v6 requires explicit permission granting from user at runtime for extra sweet security goodness Permission extStoragePerm = ApplicationContext.CheckSelfPermission(Android.Manifest.Permission.WriteExternalStorage); //if(extStoragePerm == Permission.Denied) if (extStoragePerm != Permission.Granted) { _savedInstanceState = savedInstanceState; // **calls startActivityForResult()** RequestPermissions(new[] { Android.Manifest.Permission.WriteExternalStorage }, ANDROID_PERMISSION_REQUEST_CODE__SDCARD); } else { OnCreate2(savedInstanceState); } } private void OnCreate2(Bundle savedInstanceState) { //... } } 

Ref1: Reenviar paquete de una intención a otra

Note: Esto puede ser refactorizado para manejar más permisos en general. En la actualidad maneja el permiso de escritura sdcard sólo, que debe transmitir la lógica pertinente con suficiente claridad.

Puede agregar un método de ayuda de bloqueo como este:

 @TargetApi(23) public static void checkForPermissionsMAndAboveBlocking(Activity act) { Log.i(Prefs.TAG, "checkForPermissions() called"); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { // Here, thisActivity is the current activity if (act.checkSelfPermission( Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { // No explanation needed, we can request the permission. act.requestPermissions( new String[]{ Manifest.permission.WRITE_EXTERNAL_STORAGE }, 0); while (true) { if (act.checkSelfPermission( Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) { Log.i(Prefs.TAG, "Got permissions, exiting block loop"); break; } Log.i(Prefs.TAG, "Sleeping, waiting for permissions"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } // permission already granted else { Log.i(Prefs.TAG, "permission already granted"); } } else { Log.i(Prefs.TAG, "Below M, permissions not via code"); } }