requestPermissions is called multiple times, but why does the dialog only appear once?

Question

    ActivityCompat.requestPermissions(this,
            new String[]{Manifest.permission.SEND_SMS},
            1);
    ActivityCompat.requestPermissions(this,
            new String[]{Manifest.permission.ACCESS_COARSE_LOCATION},
            2);
    ActivityCompat.requestPermissions(this,
            new String[]{Manifest.permission.CALL_PHONE},
            3);

Here, I have the three permissions I want. However, when the app pops up only one of the three permissions pops up. How do I get all three permissions to request?

Answer 1

It is an asynchronous call and there are possibly many calls. Hence, there should be a key to let you distinct between them. You will use it in

@Override
public void onRequestPermissionsResult(int requestCode,
        String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_READ_CONTACTS: {
            // Your code here
        }
    }
}

In this case MY_PERMISSIONS_REQUEST_READ_CONTACTS is an int value and you are free to define it. For instance:

int MY_PERMISSIONS_REQUEST_READ_CONTACTS = 999;

Answer 2

Try with this code:

 public void requestAppPermissions(final String[] requestedPermissions,
                                      final int requestCode, setPermissionListener listener) {
        this.permissionListener = listener;
        int permissionCheck = PackageManager.PERMISSION_GRANTED;
        for (String permission : requestedPermissions) {
            permissionCheck = permissionCheck + ContextCompat.checkSelfPermission(this, permission);
        }
        if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, requestedPermissions, requestCode);
        } else {
            if (permissionListener != null) permissionListener.onPermissionGranted(requestCode);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        for (String permission : permissions) {
            if (ActivityCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED) {
                if (permissionListener != null) permissionListener.onPermissionGranted(requestCode);
                break;
            } else if (ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) {
                if (permissionListener != null) permissionListener.onPermissionDenied(requestCode);
                break;
            } else {
                if (permissionListener != null)
                    permissionListener.onPermissionNeverAsk(requestCode);
                break;
            }
        }
    }


    public interface setPermissionListener {
        void onPermissionGranted(int requestCode);

        void onPermissionDenied(int requestCode);

        void onPermissionNeverAsk(int requestCode);
    }

invocation:

private void askPermission() {
        requestAppPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.ACCESS_FINE_LOCATION},
                Constants.PERMISSION_STORAGE,
                new setPermissionListener() {
                    @Override
                    public void onPermissionGranted(int requestCode) {
                        selectImageDialog();
                    }

                    @Override
                    public void onPermissionDenied(int requestCode) {
                        showSnackbar(mBinder.getRoot(), getString(R.string.critical_permission_denied),
                                Snackbar.LENGTH_INDEFINITE, getString(R.string.allow), new OnSnackbarActionListener() {
                                    @Override
                                    public void onAction() {
                                        askPermission();
                                    }
                                });
                    }

                    @Override
                    public void onPermissionNeverAsk(int requestCode) {
                        showPermissionSettingDialog(getString(R.string.need_permission));
                    }
                });
    }

Answer 3

You can also use Array to store permission needed and then call one request with all permissions.

fun verifyPermissions(activity: Activity?) {
    var permissions = mutableListOf<String>()
    // Check if we have SEND_SMS permission
    if (ActivityCompat.checkSelfPermission(
            activity!!,
            Manifest.permission.SEND_SMS
        ) != PackageManager.PERMISSION_GRANTED
    ) {
        permissions.add(Manifest.permission.READ_CONTACTS)
    } else {
        // permission granted
    }
    if (ActivityCompat.checkSelfPermission(
            activity,
            Manifest.permission.ACCESS_COARSE_LOCATION
        ) != PackageManager.PERMISSION_GRANTED
    ) {
        permissions.add(Manifest.permission.READ_CALL_LOG)
    } else {
        // permission granted
    }
    // continue to add other permissions
    if (!permissions.isEmpty()) {
        ActivityCompat.requestPermissions(
            activity, permissions.toTypedArray(),
            REQUEST_CODE
        )
    }
}

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    var counter: Int = 0
    when (requestCode) {
        REQUEST_CODE -> if ((grantResults.isNotEmpty())) {
            while (counter < NUM_OF_PERM) {
                if (grantResults[counter++] == PackageManager.PERMISSION_GRANTED) {
                    // permission granted
                }
            }
        }
    }
}