How to handle permission permanently denied in Kotlin Android

How to handle permission permanently denied in Kotlin Android.

Here's a detailed step-by-step tutorial on how to handle permission permanently denied in Kotlin Android:

Introduction

In Android, permissions are required to access sensitive user data or perform certain operations on the device. Sometimes, users may choose to deny a permission permanently, which means that the app will not be able to request the permission again and must handle this scenario gracefully. This tutorial will guide you through the process of handling permission permanently denied in Kotlin Android.

Step 1: Request the permission

The first step is to request the required permission from the user. You can use the requestPermissions() method to request one or more permissions. Here's an example of how to request the READ_CONTACTS permission:

val PERMISSIONS_REQUEST_READ_CONTACTS = 100

// Check if the permission is already granted
if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS)
    != PackageManager.PERMISSION_GRANTED
) {
    // Permission is not granted, request it
    ActivityCompat.requestPermissions(
        this,
        arrayOf(Manifest.permission.READ_CONTACTS),
        PERMISSIONS_REQUEST_READ_CONTACTS
    )
} else {
    // Permission is already granted, proceed with the operation
    // ...
}

Step 2: Handle the permission request result

After requesting the permission, the system will show a permission dialog to the user. Once the user responds to the dialog, the system will invoke the onRequestPermissionsResult() method in your activity or fragment. You need to override this method to handle the permission request result.

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    
    when (requestCode) {
        PERMISSIONS_REQUEST_READ_CONTACTS -> {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted, proceed with the operation
                // ...
            } else {
                // Permission denied, handle the denial
                if (!shouldShowRequestPermissionRationale(Manifest.permission.READ_CONTACTS)) {
                    // Permission denied permanently
                    // Show a dialog or redirect the user to settings
                    // ...
                } else {
                    // Permission denied, but can be requested again
                    // Show a message to the user or handle the denial gracefully
                    // ...
                }
            }
            return
        }
        // Handle other permissions if required
        // ...
    }
}

In the above code, we check if the permission is granted or denied. If the permission is denied, we can use the shouldShowRequestPermissionRationale() method to determine if the user has selected "Don't ask again" option. If this method returns false, it means that the permission has been permanently denied.

Step 3: Handle the permanently denied permission

If the permission has been permanently denied, you should handle this scenario based on your app's requirements. Here are a few options:

Option 1: Show a dialog

You can show a dialog to the user explaining why the permission is required and provide an option to navigate to the app settings screen. Here's an example:

val builder = AlertDialog.Builder(this)
builder.setTitle("Permission Required")
builder.setMessage("This permission is required to access your contacts.")
builder.setPositiveButton("Go to Settings") { dialog, _ ->
    dialog.dismiss()
    // Open app settings screen
    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
    val uri = Uri.fromParts("package", packageName, null)
    intent.data = uri
    startActivity(intent)
}
builder.setNegativeButton("Cancel") { dialog, _ ->
    dialog.dismiss()
    // Handle cancellation gracefully
    // ...
}
val dialog = builder.create()
dialog.show()

Option 2: Redirect to app settings

Instead of showing a dialog, you can directly redirect the user to the app settings screen using the ACTION_APPLICATION_DETAILS_SETTINGS intent:

val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
val uri = Uri.fromParts("package", packageName, null)
intent.data = uri
startActivity(intent)

Option 3: Handle denial gracefully

If you don't want to show a dialog or redirect to app settings, you can handle the denial gracefully by showing a message to the user or disabling the functionality that requires the permission.

Conclusion

In this tutorial, you have learned how to handle permission permanently denied in Kotlin Android. You should always handle this scenario gracefully to provide a good user experience. Depending on your app's requirements, you can show a dialog, redirect to app settings, or handle the denial gracefully. Remember to consider the user's privacy and only request permissions that are necessary for your app's functionality.

Introduction​

Step 1: Request the permission​

Step 2: Handle the permission request result​

Step 3: Handle the permanently denied permission​

Option 1: Show a dialog​

Option 2: Redirect to app settings​

Option 3: Handle denial gracefully​

Conclusion​