EasyPermissions-ktx

The @AfterPermissionGranted annotation allows you to specify a method that should automatically execute once all permissions associated with a specific requestCode are granted.

Requirements:

• The annotated method must be void (or return Unit in Kotlin).
• The annotated method must have no input parameters.
• The requestCode used in the annotation must match the requestCode used in the requestPermissions call.

@AfterPermissionGranted(REQUEST_CODE_LOCATION_AND_CONTACTS_PERMISSION)
private fun methodRequiresTwoPermission() {
    // This runs automatically after permissions are granted
}

If a user selects 'Never Ask Again', you can use EasyPermissions.somePermissionPermanentlyDenied(...) to detect this state. This method should be called within the onPermissionsDenied callback. If it returns true, you can then direct the user to the system settings using a SettingsDialog.

override fun onPermissionsDenied(requestCode: Int, perms: List<String>) {
    // Check if the user denied permissions and checked "NEVER ASK AGAIN."
    if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
        // Display a dialog directing them to enable the permission in app settings
        SettingsDialog.Builder(this).build().show()
    }
}

To allow the library to handle permission results, you must override onRequestPermissionsResult in your Activity or Fragment and delegate the call to EasyPermissions.onRequestPermissionsResult.

class MainActivity : AppCompatActivity() {

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)

        // EasyPermissions handles the request result.
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this)
    }
}

Add the following dependency to your build.gradle file to include the library in your Android project.

dependencies {
    implementation 'com.vmadalin:easypermissions-ktx:1.0.0'
}

Use EasyPermissions.hasPermissions(...) to check if permissions are already granted. If not, use EasyPermissions.requestPermissions(...) to trigger the system request and show a rationale if necessary.

// Check if permissions are already granted
if (EasyPermissions.hasPermissions(this, Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.READ_CONTACTS)) {
    // Already have permission, do the thing
} else {
    // Request them now
    EasyPermissions.requestPermissions(
        host = this,
        rationale = getString(R.string.permission_location_and_contacts_rationale_message),
        requestCode = REQUEST_CODE_LOCATION_AND_CONTACTS_PERMISSION,
        perms = Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.READ_CONTACTS
    )
}

Implement EasyPermissions.RationaleCallbacks to respond specifically to whether a user accepted or denied the rationale dialog itself. Note that these callbacks indicate the user's response to the explanation, not necessarily the final permission state.

// Implement RationaleCallbacks to handle user interaction with the rationale dialog
override fun onRationaleAccepted(requestCode: Int) {
    // Rationale accepted to request some permissions
}

override fun onRationaleDenied(requestCode: Int) {
    // Rationale denied to request some permissions
}

Implement the EasyPermissions.PermissionCallbacks interface in your Activity or Fragment to receive explicit callbacks when permissions are granted or denied.

class MainActivity : AppCompatActivity(), EasyPermissions.PermissionCallbacks {

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this)
    }

    override fun onPermissionsGranted(requestCode: Int, perms: List<String>) {
        // Some permissions have been granted
    }

    override fun onPermissionsDenied(requestCode: Int, perms: List<String>) {
        // Some permissions have been denied
    }
}

For fine-grained control over the rationale dialog (such as custom themes or button text), use the PermissionRequest.Builder instead of passing simple parameters to requestPermissions.

val request = PermissionRequest.Builder(this)
    .code(REQUEST_CODE)
    .perms(Manifest.permission.CAMERA, Manifest.permission.ACCESS_FINE_LOCATION)
    .theme(R.style.my_fancy_style)
    .rationale(R.string.camera_and_location_rationale)
    .positiveButtonText(R.string.rationale_ask_ok)
    .negativeButtonText(R.string.rationale_ask_cancel)
    .build()

EasyPermissions.requestPermissions(this, request)

The RationaleDialog provides two methods to display the dialog, depending on your project's dependency requirements:

1. showCompatDialog(): Uses androidx.appcompat.app.AlertDialog. This is the recommended method for modern Android development to ensure backward compatibility and consistent styling.
2. showDialog(): Uses the standard android.app.AlertDialog. Use this if you are not using AndroidX components.

The RationaleDialog is used to prompt users to enable permissions in the app's settings screen when a permission request has been denied.

When the user clicks the positive button (e.g., 'OK'), the dialog triggers onRationaleAccepted and automatically attempts to request the permissions again via directRequestPermissions.

When the user clicks the negative button (e.g., 'Cancel'), it triggers onRationaleDenied and onPermissionsDenied.

val rationaleDialog = RationaleDialog(context, permissionRequestModel)
rationaleDialog.showCompatDialog()

Use SettingsDialog to prompt users to enable permissions by directing them to the system's application settings screen. When the user clicks the positive button, they are sent to the settings screen via an Intent. The result is returned to the calling Activity or Fragment via onActivityResult using the provided requestCode.

To create and display the dialog, use the SettingsDialog.Builder pattern.

SettingsDialog.Builder(context)
    .title("Permission Required")
    .rationale("Please enable this permission in settings to continue.")
    .requestCode(123)
    .build()
    .show()