Можете ли вы запрашивать разрешения синхронно в модели разрешений времени запуска Marshmallow (API 23)?

Ответ 1

По сравнению с Marshmallow, я понимаю, что вы не можете.

Мне пришлось решить ту же проблему в моем приложении. Вот как я это сделал:

• Рефакторинг. Переместите каждый фрагмент кода, который зависит от каких-либо разрешений в свой собственный метод.
• Больше рефакторинга. Определите триггер для каждого метода (например, запуск активности, нажатие на элемент управления и т.д.) и групповые методы вместе, если они имеют один и тот же триггер. (Если два метода заканчиваются тем же самым триггером и требуют того же набора разрешений, рассмотрите их слияние.)
• Еще больше рефакторинга. Узнайте, что зависит от новых методов, которые были вызваны ранее, и убедитесь, что они гибки в том, когда вызывается эти методы: либо переместите его в сам метод, либо в по крайней мере, убедитесь, что все, что вы делаете, не генерирует исключений, если ваш метод еще не был вызван, и что он начинает вести себя так, как ожидалось, как только вызывается метод.
• Коды запроса. Для каждого из этих методов (или их групп) определите целочисленную константу, которая будет использоваться в качестве кода запроса.
• Проверка и запрос разрешений. Оберните каждый из этих методов/групп методов в следующий код:

.

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. Обработка ответов. Запишите реализацию для onRequestPermissionsResult() в каждом Activity, который запрашивает разрешения. Проверьте, были ли предоставлены требуемые разрешения, и используйте код запроса, чтобы определить, какой метод нужно вызывать.

Помните, что для API требуется запрос Activity для запросов времени исполнения. Если у вас есть неинтерактивные компоненты (например, Service), посмотрите Как запросить разрешения от службы в Android Marshmallow за советом о том, как справиться это. В основном, самый простой способ - отобразить уведомление, которое затем приведет к Activity, который ничего не делает, кроме как отображает диалоговое окно разрешений времени выполнения. Здесь, как я решил это в своем приложении.

Ответ 2

Короткий ответ: нет, никакой синхронизации нет. Вы должны проверить, имеете ли вы правильное разрешение до завершения операции или как последний параметр, вы можете поместить блок try/catch для исключения безопасности. В блоке catch вы можете сообщить пользователю, что операция завершилась неудачно из-за проблем с разрешением. Кроме того, есть еще один момент: когда разрешение отменено, приложение не перезапускается из основного действия, поэтому вы должны проверить разрешение даже в своем onResume().

Ответ 3

Поэтому я ненавижу отвечать на свой вопрос конкретно в отношении разрешения android.permission.WRITE_EXTERNAL_STORAGE, используемого в моем примере, но что это за черт.

Для чтения и/или записи файла на самом деле существует способ полностью избежать необходимости запрашивать и затем проверять разрешение и, таким образом, обходить весь поток, описанный выше. Таким образом, метод saveFile (Url url, String content), который я дал в качестве примера, может продолжать работать синхронно.

Решение, которое, как я полагаю, работает в API 19+, устраняет необходимость в разрешении WRITE_EXTERNAL_STORAGE, если DocumentsProvider действует как "посредник", чтобы в основном спросить пользователя от имени вашего приложения ", пожалуйста, выберите конкретный файл для записи на" (т.е. "сборщик файлов" ), а затем, как только пользователь выбирает файл (или вводит новое имя файла), приложение теперь получает магическое разрешение на это для этого Uri, поскольку пользователь имеет специально предоставил его.

Не требуется официальное разрешение WRITE_EXTERNAL_STORAGE.

Этот способ получения прав заимствования является частью Storage Access Framework, и обсуждение этого было сделано на Big BBQ BBQ by Йен-Лейк. Здесь видео, называемое Забудьте о разрешении на хранение: альтернативы для совместного использования и совместной работы, которая охватывает основные принципы и то, как вы конкретно используете он полностью обходит требование разрешения WRITE_EXTERNAL_STORAGE.

Это не полностью разрешает проблему разрешений для синхронизации/асинхронности для всех случаев, но для любого типа внешнего документа или даже того, который предлагается поставщиком (например, gDrive, Box.net, Dropbox и т.д.). это может быть решением, которое стоит проверить.

Ответ 4

Здесь, как я решил проблему "синхронности" без явного блокирования (и ожидание-ожидания) или без необходимости отдельной операции "загрузчик-загрузчик". я рефакторизованный заставку. Действие следующим образом:

update: Более полный пример можно найти здесь.

note: Поскольку API requestPermissions() вызывает startActivityForResult()

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

основная логика создания представления была перенесена с OnCreate() на OnCreate2(), а OnCreate() теперь обрабатывает проверку разрешений. Если нужно вызвать requestPermissions(), то связанный с ним OnRequestPermissionsResult() перезапустит это действие (пересылка копии исходного пакета).

[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: Переслать пакет из одного намерения в другое

примечание: Это может быть реорганизовано для обработки большего количества разрешений в целом. В настоящее время он обрабатывает только разрешение на запись sdcard, которое должно с достаточной ясностью передать соответствующую логику.

Ответ 5

Вы можете добавить вспомогательный метод блокировки следующим образом:

@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");
    }

}