Android Mの権限:shouldShowRequestPermissionRationale()関数の使用について混乱


148

私はAndroid Mの新しいPermissionsモデルに関する公式ドキュメントを調べてshouldShowRequestPermissionRationale()いました。これはtrue、アプリが以前にこの権限をリクエストし、ユーザーがリクエストを拒否した場合に返される関数について説明しています。ユーザーが過去に許可リクエストを却下し、今後は表示しないオプションを選択した場合、このメソッドはを返しますfalse

しかし、次の2つのケースをどのように区別できますか?

ケース1:アプリに権限がなく、ユーザーは以前に権限を要求されていません。この場合、ユーザーに初めて問い合わせるので、shouldShowRequestPermissionRationale()はfalseを返します。

事例2:ユーザーが権限を拒否し、「今後は表示しない」を選択した場合、この場合もshouldShowRequestPermissionRationale()はfalseを返します。

ケース2のアプリの設定ページにユーザーを送信したいのですが、これら2つのケースを区別するにはどうすればよいですか?


1
受け入れられた答えは良いです。代わりに、共有設定を使用して、アプリが以前に許可をリクエストしたかどうかを知ることもできます。他の誰かの状況により適している場合に備えて、それを捨てるだけです。
Rockin4Life33

4
ケース3もあります。ユーザーは許可を求められ、許可/拒否されましたが、許可設定を使用して「毎回尋ねる」に戻っています。shouldShowRequestPermissionRationale()この場合、テストはfalse を返すことを示しています。これは、「以前に尋ねたことがある」フラグに依存しているコードに悪影響を及ぼします。
ローガンピックアップ、

permissionsAndroid でのベストプラクティスを示すGoogleのサンプルは次のとおりです。github.com/android/permissions-samples
itabdullah

回答:


172

Mプレビュー1の後、ダイアログが初めて表示された場合、二度と尋ねないことはありませチェックボックス。

ユーザーが許可要求を拒否すると、2回目の許可が要求されたときに、許可ダイアログに今後確認しない」チェックボックスが表示されます。

したがって、ロジックは次のようになります。

  1. 許可をリクエスト:

    if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(context, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_CODE);
    } else {
        //Do the stuff that requires permission...
    }
  2. で許可が拒否または付与されたかどうかを確認しonRequestPermissionsResultます。

    以前に許可が拒否されていた場合、今回は許可ダイアログに「今後確認しない」チェックボックスが表示されます。

    電話shouldShowRequestPermissionRationaleをかけて、ユーザーが[今後は確認しない]をオンにしたかどうかを確認します。shouldShowRequestPermissionRationaleメソッドがfalseを返すのは、ユーザーが[今後確認しない]を選択した場合、またはデバイスポリシーでアプリがその権限を持つことを禁止している場合のみです。

    if (grantResults.length > 0){
        if(grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            //Do the stuff that requires permission...
        }else if (grantResults[0] == PackageManager.PERMISSION_DENIED){
            // Should we show an explanation?
            if (ActivityCompat.shouldShowRequestPermissionRationale(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                //Show permission explanation dialog...
            }else{
                //Never ask again selected, or device policy prohibits the app from having that permission.
                //So, disable that feature, or fall back to another situation...
            }
        }
    }

したがって、ユーザーが[今後は確認しない]をオンにしたかどうかを追跡する必要はありません。


48
明確化の1つのポイント、shouldShowRequestPermissionRationale()は、ユーザーが許可を求められたことがない場合(つまり、アプリケーションが初めて実行されたとき)もfalseを返します。提供されている例のロジックに従えば、そのようなケースに遭遇することはありません。しかし、2歳未満の表現は少し誤解を招くものです。
ベン

1
@Canc非常に素晴らしい説明。ありがとう:)
AndoAiron

14
よくわかりませんが、これには欠陥があるようです。ユーザーが最初に質問されたかどうかを知るにはどうすればよいですか?ユーザーに質問されたかどうかを追跡する必要があります。質問された場合は、ロジックを逆にする必要があります。私には意味がありません。
ダニエルF

4
私はそれはあなたが渡しているところということは注目に値すると思うcontextにはActivityCompat.shouldShowRequestPermissionRationale(...)、パラメータが実際の型のですActivity。すべてに影響はありませんが、私の場合は影響があります。
aProperFox 2017

7
このアンドロイドのロジックはとても愚かです!shouldコールバックでを呼び出し、そのカウンター値をNVMに保存して、次にアプリが開いたときにもう一度要求を要求する必要があるかどうかを確認する必要があります。...うわー(facepalm)...ステータス列挙を返す呼び出しを1つだけ行うのは難しすぎましたか?
Shockwaver

22

私は同じ問題を抱えていて、それを理解しました。人生をずっと単純にするために、ランタイムアクセス許可を処理するutilクラスを作成しました。

public class PermissionUtil {
    /*
    * Check if version is marshmallow and above.
    * Used in deciding to ask runtime permission
    * */
    public static boolean shouldAskPermission() {
        return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M);
    }
private static boolean shouldAskPermission(Context context, String permission){
        if (shouldAskPermission()) {
            int permissionResult = ActivityCompat.checkSelfPermission(context, permission);
            if (permissionResult != PackageManager.PERMISSION_GRANTED) {
                return true;
            }
        }
        return false;
    }
public static void checkPermission(Context context, String permission, PermissionAskListener listener){
/*
        * If permission is not granted
        * */
        if (shouldAskPermission(context, permission)){
/*
            * If permission denied previously
            * */
            if (((Activity) context).shouldShowRequestPermissionRationale(permission)) {
                listener.onPermissionPreviouslyDenied();
            } else {
                /*
                * Permission denied or first time requested
                * */
if (PreferencesUtil.isFirstTimeAskingPermission(context, permission)) {
                    PreferencesUtil.firstTimeAskingPermission(context, permission, false);
                    listener.onPermissionAsk();
                } else {
                    /*
                    * Handle the feature without permission or ask user to manually allow permission
                    * */
                    listener.onPermissionDisabled();
                }
            }
        } else {
            listener.onPermissionGranted();
        }
    }
/*
    * Callback on various cases on checking permission
    *
    * 1.  Below M, runtime permission not needed. In that case onPermissionGranted() would be called.
    *     If permission is already granted, onPermissionGranted() would be called.
    *
    * 2.  Above M, if the permission is being asked first time onPermissionAsk() would be called.
    *
    * 3.  Above M, if the permission is previously asked but not granted, onPermissionPreviouslyDenied()
    *     would be called.
    *
    * 4.  Above M, if the permission is disabled by device policy or the user checked "Never ask again"
    *     check box on previous request permission, onPermissionDisabled() would be called.
    * */
    public interface PermissionAskListener {
/*
        * Callback to ask permission
        * */
        void onPermissionAsk();
/*
        * Callback on permission denied
        * */
        void onPermissionPreviouslyDenied();
/*
        * Callback on permission "Never show again" checked and denied
        * */
        void onPermissionDisabled();
/*
        * Callback on permission granted
        * */
        void onPermissionGranted();
    }
}

また、PreferenceUtilメソッドは次のとおりです。

public static void firstTimeAskingPermission(Context context, String permission, boolean isFirstTime){
SharedPreferences sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE;
 sharedPreference.edit().putBoolean(permission, isFirstTime).apply();
 }
public static boolean isFirstTimeAskingPermission(Context context, String permission){
return context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE).getBoolean(permission, true);
}

ここで必要なのは、適切な引数を指定してメソッドcheckPermissionを使用することだけです。

ここに例があります

PermissionUtil.checkPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE,
                    new PermissionUtil.PermissionAskListener() {
                        @Override
                        public void onPermissionAsk() {
                            ActivityCompat.requestPermissions(
                                    thisActivity,
              new String[]{Manifest.permission.READ_CONTACTS},
                            REQUEST_EXTERNAL_STORAGE
                            );
                        }
@Override
                        public void onPermissionPreviouslyDenied() {
                       //show a dialog explaining permission and then request permission
                        }
@Override
                        public void onPermissionDisabled() {
Toast.makeText(context, "Permission Disabled.", Toast.LENGTH_SHORT).show();
                        }
@Override
                        public void onPermissionGranted() {
                            readContacts();
                        }
                    });

ケース1:アプリには権限がなく、ユーザーは以前に権限を要求されていません。この場合、ユーザーに初めて問い合わせるので、shouldShowRequestPermissionRationale()はfalseを返します。

ケース2:ユーザーが権限を拒否し、「今後表示しない」を選択した場合、この場合もshouldShowRequestPermissionRationale()はfalseを返します。

ケース2のアプリの設定ページにユーザーを送信したいのですが、これら2つのケースを区別するにはどうすればよいですか?

ケース1ではonPermissionAskで、ケース2 ではonPermissionDisabledでコールバックを取得します。

ハッピーコーディング:)


素晴らしい説明仲間。まったく同じ手順に従ってください。:)
Sumit Jha

thisActivityには何を入力しますか?public void onPermissionAsk() { ActivityCompat.requestPermissions( thisActivity, ...
Mardymar 2017年

@Mardymar thisActivityは他にありませんYourActivity.this
muthuraj 2017年

1
複数の権限を処理する方法と、このコードをフラグメント内に統合する方法。
Taimur

contextを使っていますか?shouldShowRequestPermissionRationale(permission)に存在しませんandroid.content.Context。それはActivityCompatにあります
Hilikus 2018

8

更新

以下のCanCの答えは、従うべき正しい答えだと思います。確実に知る唯一の方法は、shouldShowPermissionRationaleを使用してonRequestPermissionResultコールバックでこれを確認することです。

==

私の元の答え:

私が見つけた唯一の方法は、これが初めてかどうかを自分で追跡することです(たとえば、共有設定を使用)。初めてではない場合は、を使用shouldShowRequestPermissionRationale()して区別します。

Android M-ランタイム権限を確認する-ユーザーが「二度と尋ねない」をチェックしたかどうかを確認する方法も参照してください


1
はい、CanCの方法が従うべきであることに私も同意します。承認済みの回答としてマークします。
akshayt23

6

私が理解している方法では、shouldShowRequestPermissionRationale()は内部で多数のユースケースを実行し、要求されている権限に関する説明を表示するかどうかをアプリに通知します。

ランタイムアクセス許可の背後にある考え方は、ほとんどの場合、ユーザーはアクセス許可要求に対して「はい」と言うことです。そうすれば、ユーザーはワンクリックするだけで済みます。もちろん、リクエストは正しいコンテキストで使用する必要があります。つまり、「カメラ」ボタンが押されたときにカメラの許可を求めます。

ユーザーがリクエストを拒否した後、しばらくしてからもう一度[カメラ]ボタンを押すと、shouldShowRequestPermissionRationale()がtrueを返すため、アプリは、アクセス許可がリクエストされた理由と、アプリが実行されない理由を説明できます。それなしで正しく動作します。通常、そのダイアログウィンドウには、再度拒否/後で決定するためのボタンと、権限を付与するためのボタンを表示します。根拠ダイアログの権限付与ボタンは、再度権限リクエストを開始するはずです。今回は、ユーザーには[今後表示しない]チェックボックスも表示されます。彼がそれを選択し、再度許可を拒否することを決定した場合、ユーザーとアプリが同じページ上にないことをAndroidシステムに通知します。そのアクションには2つの結果があります。shouldShowRequestPermissionRationale()は常にfalseを返します。

ただし、onRequestPermissionsResultを使用できる別のシナリオも考えられます。たとえば、一部のデバイスには、カメラを無効にするデバイスポリシーがある場合があります(CIA、DARPAなどで機能)。これらのデバイスでは、onRequestPermissionsResultは常にfalseを返し、requestPermissions()メソッドは暗黙のうちに要求を拒否します。

それは、AndroidフレームワークのプロダクトマネージャーであるBen Poieszと一緒にポッドキャストを聞いて集めたものです。
http://androidbackstage.blogspot.jp/2015/08/episode-33-permission-mission.html


6

誰かがそう思うかもしれない場合は、別のオプションを投稿してください。Googleが提供するEasyPermissionsを使用して、「Android Mシステムの権限を簡素化する」ことができます。

その後、shouldShowRequestPermissionRationale直接処理する必要はありません。


なぜ私はこのプロジェクトを前もって見なかったのですか:)
Vlad

EasyPermissionsの問題はほとんど同じままです。頼むpermissionPermanentlyDenied内部だけのコールshouldShowPermissionsRationaleとリターンtrueユーザーが権限を付与するように要求されなかったんとき場合を。
hgoebl 2018年

4

Kotlinソリューションに興味がある人がいる場合は、@ muthurajの回答をKotlinにリファクタリングしました。また、リスナーの代わりに完了ブロックを持つように少し近代化しました。

PermissionUtil

object PermissionUtil {
    private val PREFS_FILE_NAME = "preference"

    fun firstTimeAskingPermission(context: Context, permission: String, isFirstTime: Boolean) {
        val sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE)
        sharedPreference.preferences.edit().putBoolean(permission,
                isFirstTime).apply()
    }

    fun isFirstTimeAskingPermission(context: Context, permission: String): Boolean {
        val sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE)
        return sharedPreference.preferences.getBoolean(permission,
                true)
    }
}

PermissionHandler

enum class CheckPermissionResult {
    PermissionAsk,
    PermissionPreviouslyDenied,
    PermissionDisabled,
    PermissionGranted
}

typealias PermissionCheckCompletion = (CheckPermissionResult) -> Unit


object PermissionHandler {

    private fun shouldAskPermission(context: Context, permission: String): Boolean {
        return ContextCompat.checkSelfPermission(context,
                permission) != PackageManager.PERMISSION_GRANTED
    }

    fun checkPermission(context: Context, permission: String, completion: PermissionCheckCompletion) {
        // If permission is not granted
        if (shouldAskPermission(context, permission)) {
            //If permission denied previously
            if ((context as Activity).shouldShowRequestPermissionRationale(permission)) {
                completion(CheckPermissionResult.PermissionPreviouslyDenied)
            } else {
                // Permission denied or first time requested
                if (PermissionUtil.isFirstTimeAskingPermission(context,
                                permission)) {
                    PermissionUtil.firstTimeAskingPermission(context,
                            permission,
                            false)
                    completion(CheckPermissionResult.PermissionAsk)
                } else {
                    // Handle the feature without permission or ask user to manually allow permission
                    completion(CheckPermissionResult.PermissionDisabled)
                }
            }
        } else {
            completion(CheckPermissionResult.PermissionGranted)
        }
    }
}

実装

PermissionHandler.checkPermission(activity,
                    Manifest.permission.CAMERA) { result ->
                when (result) {
                    CheckPermissionResult.PermissionGranted -> {
                        // openCamera()
                    }
                    CheckPermissionResult.PermissionDisabled -> {
                        // displayAlert(noPermissionAlert)
                    }
                    CheckPermissionResult.PermissionAsk -> {
                        // requestCameraPermissions()
                    }
                    CheckPermissionResult.PermissionPreviouslyDenied -> {
                        // displayAlert(permissionRequestAlert)
                    }
                }
            }

3

この実装を確認してください。私にはかなり良い仕事をしています。基本的には、権限のリストを渡してcheckPermissions()メソッドで権限を確認します。onRequestPermissionsResult()でパーミッションリクエストの結果を確認します。この実装により、ユーザーが「二度と尋ねない」を選択した場合としない場合の両方のケースに対処できます。この実装では、seが「二度と尋ねない」を選択した場合、ダイアログに、アプリ設定アクティビティに移動するオプションがあります。

このコードはすべて私のフラグメントの中にあります。これを行うには、PermissionManagerのような特殊なクラスを作成する方がよいと考えていましたが、それについてはよくわかりません。

/**
     * responsible for checking if permissions are granted. In case permissions are not granted, the user will be requested and the method returns false. In case we have all permissions, the method return true.
     * The response of the request for the permissions is going to be handled in the onRequestPermissionsResult() method
     * @param permissions list of permissions to be checked if are granted onRequestPermissionsResult().
     * @param requestCode request code to identify this request in
     * @return true case we already have all permissions. false in case we had to prompt the user for it.
     */
    private boolean checkPermissions(List<String> permissions, int requestCode) {
        List<String> permissionsNotGranted = new ArrayList<>();
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(getActivity(), permission) != PackageManager.PERMISSION_GRANTED)
                permissionsNotGranted.add(permission);
        }

        //If there is any permission we don't have (it's going to be in permissionsNotGranted List) , we need to request.
        if (!permissionsNotGranted.isEmpty()) {
            requestPermissions(permissionsNotGranted.toArray(new String[permissionsNotGranted.size()]), requestCode);
            return false;
        }
        return true;
    }

    /**
     * called after permissions are requested to the user. This is called always, either
     * has granted or not the permissions.
     * @param requestCode  int code used to identify the request made. Was passed as parameter in the
     *                     requestPermissions() call.
     * @param permissions  Array containing the permissions asked to the user.
     * @param grantResults Array containing the results of the permissions requested to the user.
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case YOUR_REQUEST_CODE: {
                boolean anyPermissionDenied = false;
                boolean neverAskAgainSelected = false;
                // Check if any permission asked has been denied
                for (int i = 0; i < grantResults.length; i++) {
                    if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                        anyPermissionDenied = true;
                        //check if user select "never ask again" when denying any permission
                        if (!shouldShowRequestPermissionRationale(permissions[i])) {
                            neverAskAgainSelected = true;
                        }
                    }
                }
                if (!anyPermissionDenied) {
                    // All Permissions asked were granted! Yey!
                    // DO YOUR STUFF
                } else {
                    // the user has just denied one or all of the permissions
                    // use this message to explain why he needs to grant these permissions in order to proceed
                    String message = "";
                    DialogInterface.OnClickListener listener = null;
                    if (neverAskAgainSelected) {
                        //This message is displayed after the user has checked never ask again checkbox.
                        message = getString(R.string.permission_denied_never_ask_again_dialog_message);
                        listener = new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                //this will be executed if User clicks OK button. This is gonna take the user to the App Settings
                                startAppSettingsConfigActivity();
                            }
                        };
                    } else {
                        //This message is displayed while the user hasn't checked never ask again checkbox.
                        message = getString(R.string.permission_denied_dialog_message);
                    }
                    new AlertDialog.Builder(getActivity(), R.style.AlertDialogTheme)
                            .setMessage(message)
                            .setPositiveButton(getString(R.string.label_Ok), listener)
                            .setNegativeButton(getString(R.string.label_cancel), null)
                            .create()
                            .show();
                }
            }
            break;
            default:
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }

    /**
     * start the App Settings Activity so that the user can change
     * settings related to the application such as permissions.
     */
    private void startAppSettingsConfigActivity() {
        final Intent i = new Intent();
        i.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        i.addCategory(Intent.CATEGORY_DEFAULT);
        i.setData(Uri.parse("package:" + getActivity().getPackageName()));
        i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
        i.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
        getActivity().startActivity(i);
    }

2

誰かに役立つかもしれません:-

私が気付いたことは、shouldShowRequestPermissionRationale()フラグをonRequestPermissionsResult()コールバックメソッドにチェックインすると、2つの状態しか表示されないことです。

状態1:-Return true:-ユーザーが[Deny]権限をクリックしたとき(初回を含む)。

状態2:-falseを返します:-ユーザーが「二度と尋ねない」を選択した場合。

詳細な作業例のリンク


6
初めてfalseを返します。真実ではない
JoM 2016年

はい、それは私が述べたものです、あなたがonRequestPermissionsResult()コールバックメソッドでフラグをチェックするならば、それは特にこのコールバックで2つの状態だけを持ちます。
Nicks

2
残念ながら、shouldShowRequestPermissionRationaleは常にfalseを返します。ユーザーがアクセス許可を拒否したかどうかは関係ありません。
IgorGanapolsky 2016

1

これでできるの?

@Retention(RetentionPolicy.SOURCE)
@IntDef({GRANTED, DENIED, NEVER})
public @interface PermissionStatus {
}

public static final int GRANTED = 0;
public static final int DENIED = 1;
public static final int NEVER = 2;

@PermissionStatus
public static int getPermissionStatus(Activity activity, String permission) {
    if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
        return DENIED;
    } else {
        if (ActivityCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED) {
            return GRANTED;
        } else {
            return NEVER;
        }
    }
}

残念ながら、このコードは、許可が以前に要求されなかった状況と「再要求しない」がチェックされた状況を区別しません。
ベン

これとパーミッションヘルパークラスの組み合わせを使用して、パーミッションが付与されているかどうかを確認する必要があります。
aNdRO博士、18年

0

shouldShowRequestPermissionRationale SPECIALパーミッションでは、ユーザーがチェックボックスなしで拒否した後にのみ常にTRUEを返します。

FALSE値に関心がある

したがって、偽の値で3つのケースが失われます。

1.以前はそのようなアクションはありませんでしたが、ユーザーは同意するか拒否するかを決定します。

ASKED_PERMISSION_*現在存在しておらず、である設定を定義するだけですonRequestPermissionsResult同意または拒否のいずれかの場合には、それの起動時には

したがって、この設定は存在しませんが、確認する理由はありませんshouldShowRequestPermissionRationale

2.ユーザーが同意するをクリックしました。

単に行います:

checkCallingOrSelfPermission(permission) == PackageManager.PERMISSION_GRANTED

trueを返し、確認する理由はありませんshouldShowRequestPermissionRationale

3.ユーザーがチェックボックスで[拒否]をクリックした(2回目またはそれ以上の時間)

それはだTIMEでの仕事にshouldShowRequestPermissionRationaleどの戻りますFALSE

(設定があり、許可がありません)


0

このコードは、実行時に許可を求めるようユーザーに求め、ユーザーが許可する場合は、resultメソッドを実行します。ユーザーが拒否する場合は、ユーザー拒否を使用して説明で再度尋ねます(指示で再度尋ねます)。ただし、ユーザーが再度尋ねることを選択しない場合。それは再び尋ねることは決してありません、指示付きのオープン設定オプションを表示します。

public String storagePermissions = Manifest.permission.READ_EXTERNAL_STORAGE;   
private static final int REQUEST_ACCESS =101;  

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
      if(checkSelfPermission(storagePermissions)== PackageManager.PERMISSION_GRANTED){
          result();    // result  is your block of code 
      }else {
          requestPermissions(new String[]{storagePermissions},REQUEST_ACCESS);
      }

    }
    else{
        result();    //so if user is lower than api verison M, no permission is requested
    } 

}

 private void showMessageOKCancel(String message, DialogInterface.OnClickListener okListener) {
    new AlertDialog.Builder(MainActivity.this)
            .setMessage(message)
            .setTitle("Hi User..")
            .setPositiveButton("Ok", okListener)
            .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {        //idea calling showMessage funtion again
                    Snackbar mySnackbar = Snackbar.make( findViewById(R.id.coordinatorlayout),"You Press Cancel.. ", Snackbar.LENGTH_INDEFINITE);
                    mySnackbar.setAction("Exit", new cancelButton());
                    mySnackbar.show();

                }
            })
            .create()
            .show();
}


private void result(){
          //your code
}

    @RequiresApi(api = Build.VERSION_CODES.M)
public class NeverAskAgain implements View.OnClickListener{
    @Override
    public void onClick(View view)
    {
        goToSettings();
    }
}
@RequiresApi(api = Build.VERSION_CODES.M)
private void goToSettings() {
    Intent myAppSettings = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:" + getPackageName()));
    finish();
    myAppSettings.addCategory(Intent.CATEGORY_DEFAULT);
    myAppSettings.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivityForResult(myAppSettings, REQUEST_APP_SETTINGS);
}
public class cancelButton implements View.OnClickListener{
    @Override
    public void onClick(View view){
        Toast.makeText(MainActivity.this,"To use this app , you must grant storage permission",Toast.LENGTH_SHORT);
        finish();
    }
    }


 @Override
@RequiresApi(api = Build.VERSION_CODES.M)
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode,permissions,grantResults);

    switch(requestCode) {
        case REQUEST_ACCESS:
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    // permission is granted
                    result();
                    break;
                }
                else if (!shouldShowRequestPermissionRationale(permissions[0])){
                    showMessageOKCancel("You choose Never Ask Again,option",
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        Snackbar mySnackbar = Snackbar.make(findViewById(R.id.coordinatorlayout), "Permission=>Storage=>On", Snackbar.LENGTH_INDEFINITE);
                        mySnackbar.setAction("Settings", new NeverAskAgain());
                        mySnackbar.show();
                    }
                     });
                    break;
                }
                else {
                    showMessageOKCancel("You Denid permission Request..",
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            requestPermissions(new String[]{storagePermissions}, REQUEST_ACCESS);
                        }
                    });
                    break;
                }
        }
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.