Permission Helper class for handling permission flow

PermissionHelper.java

import android.app.Activity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AlertDialog;

import java.util.ArrayList;

public class PermissionHelper {

    public static boolean hasPermission(Context context, String permission) {
        return Build.VERSION.SDK_INT < Build.VERSION_CODES.M
                || ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED;
    }

    public static boolean hasPermissions(Context context, String[] permissions) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            return true;
        }
        if (permissions == null) {
            return false;
        }
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    public static void requestPermissions(Activity activity, String[] permissions, int requestCode) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            return;
        }
        if (permissions == null) {
            return;
        }

        String[] permissionArray = getNonGrantedPermissions(activity, permissions);
        if (permissionArray != null) {
            ActivityCompat.requestPermissions(activity, permissionArray, requestCode);
        }
    }


    public static void requestPermissions(Fragment fragment, String[] permissions, int requestCode) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            return;
        }
        if (permissions == null) {
            return;
        }

        String[] permissionArray = getNonGrantedPermissions(fragment.getContext(), permissions);
        if (permissionArray != null) {
            fragment.requestPermissions(permissionArray, requestCode);
        }
    }

    private static String[] getNonGrantedPermissions(Context context, String[] permissions) {
        ArrayList<String> permissionList = new ArrayList<>();
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                permissionList.add(permission);
            }
        }
        if (permissionList.size() > 0) {
            String[] permissionArray = new String[permissionList.size()];
            permissionList.toArray(permissionArray);
            return permissionArray;
        }
        return null;
    }

    public static boolean shouldShowPermissionRationale(Activity activity, String[] permissions) {
        if (permissions == null) {
            return false;
        }
        for (String permission : permissions) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                return true;
            }
        }
        return false;
    }

    public static boolean shouldShowPermissionRationale(Fragment fragment, String[] permissions) {
        if (permissions == null) {
            return false;
        }
        for (String permission : permissions) {
            if (fragment.shouldShowRequestPermissionRationale(permission)) {
                return true;
            }
        }
        return false;
    }

    public static void showDialog(Context context, String title, String message, String positiveButtonText, final OnDialogCloseListener listener) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context)
                .setTitle(title)
                .setMessage(message)
                .setCancelable(false)
                .setPositiveButton(positiveButtonText, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        dialogInterface.dismiss();
                        listener.onDialogClose(dialogInterface, OnDialogCloseListener.TYPE_POSITIVE);
                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        dialogInterface.dismiss();
                        listener.onDialogClose(dialogInterface, OnDialogCloseListener.TYPE_NEGATIVE);
                    }
                });
        builder.show();
    }

    public static void openSettingScreen(Activity activity, int requestCode) {
        activity.startActivityForResult(new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                Uri.parse("package:" + BuildConfig.APPLICATION_ID)), requestCode);
    }

    public static void openSettingScreen(Fragment fragment, int requestCode) {
        fragment.startActivityForResult(new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                Uri.parse("package:" + BuildConfig.APPLICATION_ID)), requestCode);
    }

    public interface OnDialogCloseListener {
        int TYPE_POSITIVE = 1;
        int TYPE_NEGATIVE = -1;

        void onDialogClose(DialogInterface dialog, int buttonType);
    }
}

PermissionHelper.kt

import android.content.Context
import android.content.pm.PackageManager
import android.os.Build
import android.support.v4.content.ContextCompat
import android.support.v4.app.ActivityCompat.requestPermissions
import android.support.v4.app.ActivityCompat
import android.app.Activity
import android.support.v4.app.Fragment
import android.content.DialogInterface
import android.support.v7.app.AlertDialog
import android.content.Intent
import android.net.Uri


public class PermissionHelper {
    companion object {
        fun hasPermission(context: Context, permission: String): Boolean {
            return Build.VERSION.SDK_INT < Build.VERSION_CODES.M
                    || ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
        }

        fun hasPermissions(context: Context, permissions: Array<String>?): Boolean {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                return true
            }

            if (permissions == null) {
                return false
            }

            for (permission in permissions) {
                if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                    return false;
                }
            }

            return true;
        }


        fun requestPermissions(activity: Activity, permissions: Array<String>?, requestCode: Int) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                return
            }
            if (permissions == null) {
                return
            }

            val permissionArray = getNonGrantedPermissions(activity, permissions)
            if (permissionArray != null) {
                ActivityCompat.requestPermissions(activity, permissionArray, requestCode)
            }
        }


        fun requestPermissions(fragment: Fragment, permissions: Array<String>?, requestCode: Int) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                return
            }
            if (permissions == null) {
                return
            }

            val permissionArray = getNonGrantedPermissions(fragment.getContext(), permissions)
            if (permissionArray != null) {
                fragment.requestPermissions(permissionArray, requestCode)
            }
        }

        private fun getNonGrantedPermissions(context: Context, permissions: Array<String>): Array<String?>? {
            val permissionList: ArrayList<String> = ArrayList()

            for (permission in permissions) {
                if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                    permissionList.add(permission)
                }
            }
            if (permissionList.size > 0) {
                val permissionArray = arrayOfNulls<String>(permissionList.size)
                permissionList.toArray(permissionArray)
                return permissionArray
            }
            return null
        }

        fun shouldShowPermissionRationale(activity: Activity, permissions: Array<String>?): Boolean {
            if (permissions == null) {
                return false
            }
            for (permission in permissions) {
                if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                    return true
                }
            }
            return false
        }

        fun shouldShowPermissionRationale(fragment: Fragment, permissions: Array<String>?): Boolean {
            if (permissions == null) {
                return false
            }
            for (permission in permissions) {
                if (fragment.shouldShowRequestPermissionRationale(permission)) {
                    return true
                }
            }
            return false
        }

        fun showDialog(context: Context, title: String, message: String, positiveButtonText: String, listener: OnDialogCloseListener) {
            val builder = AlertDialog.Builder(context)
                    .setTitle(title)
                    .setMessage(message)
                    .setCancelable(false)
                    .setPositiveButton(positiveButtonText, DialogInterface.OnClickListener { dialogInterface, i ->
                        dialogInterface.dismiss()
                        listener.onDialogClose(dialogInterface, OnDialogCloseListener.TYPE_POSITIVE)
                    })
                    .setNegativeButton("Cancel", DialogInterface.OnClickListener { dialogInterface, i ->
                        dialogInterface.dismiss()
                        listener.onDialogClose(dialogInterface, OnDialogCloseListener.TYPE_NEGATIVE)
                    })
            builder.show()
        }

        fun openSettingScreen(activity: Activity, requestCode: Int) {
            activity.startActivityForResult(Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                    Uri.parse("package:" + activity.packageName)), requestCode)
        }

        fun openSettingScreen(fragment: Fragment, requestCode: Int) {
            fragment.startActivityForResult(Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                    Uri.parse("package:" + fragment.activity.packageName)), requestCode)
        }
    }

    interface OnDialogCloseListener {

        fun onDialogClose(dialog: DialogInterface, buttonType: Int)

        companion object {
            val TYPE_POSITIVE = 1
            val TYPE_NEGATIVE = -1
        }
    }
}

PermissionMainActivity.java

//Implement in activity
import android.Manifest;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;

public class PermissionMainActivity extends AppCompatActivity {

    private static final int REQUEST_CODE_CAMERA_PERMISSION = 123;
    private static final int REQUEST_CODE_PERMISSION_SETTING = 456;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        requestPermission();
    }

    private void requestPermission() {
        if (PermissionHelper.hasPermission(this, Manifest.permission.CAMERA)) {
            onPermissionGranted();
        } else {
            PermissionHelper.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, REQUEST_CODE_CAMERA_PERMISSION);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (PermissionHelper.hasPermissions(this, permissions)) {
            onPermissionGranted();
        } else {
            if (PermissionHelper.shouldShowPermissionRationale(this, permissions)) {
                showPermissionRationale();
            } else {
                onPermissionDenied();
            }
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CODE_PERMISSION_SETTING) {
            if (PermissionHelper.hasPermission(this, Manifest.permission.CAMERA)) {
                onPermissionGranted();
            }
        }
    }

    private void showPermissionRationale() {
        PermissionHelper.showDialog(this, "Permission", "App require camera permission for detect face.", "OK", new PermissionHelper.OnDialogCloseListener() {
            @Override
            public void onDialogClose(DialogInterface dialog, int buttonType) {
                if (buttonType == PermissionHelper.OnDialogCloseListener.TYPE_POSITIVE) {
                    PermissionHelper.requestPermissions(PermissionMainActivity.this, new String[]{Manifest.permission.CAMERA}, REQUEST_CODE_CAMERA_PERMISSION);
                }
            }
        });
    }

    private void onPermissionDenied() {
              PermissionHelper.showDialog(this, "Permission Setting", "Grant camera permission from setting screen.", "OK", new PermissionHelper.OnDialogCloseListener() {
            @Override
            public void onDialogClose(DialogInterface dialog, int buttonType) {
                if (buttonType == PermissionHelper.OnDialogCloseListener.TYPE_POSITIVE) {
                    PermissionHelper.openSettingScreen(PermissionMainActivity.this, REQUEST_CODE_PERMISSION_SETTING);
                }
            }
        });
    }

    private void onPermissionGranted() {
         // code after permission granted
    }
 
}

RuntimePermissionDialog.kt

import android.Manifest
import android.content.Intent
import android.os.Bundle
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.FragmentManager

class RuntimePermissionDialog : DialogFragment() {
    private var arrPermissions: ArrayList<String>? = null
    private var requestCode = 0
    private var permissions: Array<String?>? = null
    private var mPermissionCallback: PermissionCallback? = null
    private var message: String? = "App required permission"
    fun show(manager: FragmentManager) {
        manager.beginTransaction().add(this, tag).commitAllowingStateLoss()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (arguments != null) {
            arrPermissions = requireArguments().getStringArrayList(PERMISSIONS)
            requestCode = requireArguments().getInt(REQUEST_CODE)
            message = requireArguments().getString(MESSAGE)
        }
        if (!arrPermissions.isNullOrEmpty()) {
            permissions = arrayOfNulls(arrPermissions?.size ?: 0)
            for (pos in arrPermissions?.indices) {
                permissions!![pos] = arrPermissions!![pos]
            }
        }

        requestPermission()
    }

    fun setPermissionCallback(mPermissionCallback: PermissionCallback?): RuntimePermissionDialog {
        this.mPermissionCallback = mPermissionCallback
        return this
    }

    private fun requestPermission() {
        if (permissions == null) {
            return
        }
        if (PermissionHelper.hasPermissions(context, permissions)) {
            onPermissionGranted()
        } else {
            PermissionHelper.requestPermissions(this, permissions, requestCode)
        }
    }

    override fun onRequestPermissionsResult(
            requestCode: Int,
            permissions: Array<String>,
            grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (PermissionHelper.hasPermissions(context, permissions)) {
            onPermissionGranted()
        } else {
            if (PermissionHelper.shouldShowPermissionRationale(this, permissions)) {
                showPermissionRationale()
            } else {
                onPermissionDenied()
            }
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == this.requestCode) {
            if (PermissionHelper.hasPermissions(context, permissions)) {
                onPermissionGranted()
            }
        }
    }

    private fun showPermissionRationale() {
        PermissionHelper.showDialog(context, "Permission", message, "OK") { dialog, buttonType ->
            if (buttonType == PermissionHelper.OnDialogCloseListener.TYPE_POSITIVE) {
                PermissionHelper.requestPermissions(
                        this@RuntimePermissionDialog,
                        permissions,
                        requestCode
                )
            } else {
                mPermissionCallback?.onDeniedPermission(permissions, requestCode)
            }
            dismissAllowingStateLoss()
        }
    }

    private fun onPermissionDenied() {
        PermissionHelper.showDialog(context, "Setting", message, "OK") { dialog, buttonType ->
            if (buttonType == PermissionHelper.OnDialogCloseListener.TYPE_POSITIVE) {
                PermissionHelper.openSettingScreen(
                        this@RuntimePermissionDialog,
                        REQUEST_CODE_PERMISSION_SETTING
                )
            } else {
                mPermissionCallback?.onDeniedPermission(permissions, requestCode)
            }
            dismissAllowingStateLoss()
        }
    }

    private fun onPermissionGranted() {
        mPermissionCallback?.onGrantPermission(permissions, requestCode)
        dismissAllowingStateLoss()
    }

    companion object {
        private const val REQUEST_CODE = "REQUEST_CODE"
        private const val PERMISSIONS = "PERMISSIONS"
        private const val MESSAGE = "MESSAGE"
        private const val REQUEST_CODE_PERMISSION_SETTING = 1212
        fun newInstance(
                arrPermissions: ArrayList<String>,
                requestCode: Int,
                message: String?
        ): RuntimePermissionDialog {
            val fragment = RuntimePermissionDialog()
            val args = Bundle()
            args.putInt(REQUEST_CODE, requestCode)
            args.putStringArrayList(PERMISSIONS, arrPermissions)
            args.putString(MESSAGE, message)
            fragment.arguments = args
            return fragment
        }
    }
}