Permission request flow in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when permission is denied permanently?

In Android, if a user denies a permission and selects "Don't ask again", what is the expected behavior when the app requests the same permission again?

A The system shows the permission dialog again to the user.

B The app crashes because permission is denied permanently.

C The app receives a callback indicating permission denied without showing the dialog.

D The app automatically gets the permission without user interaction.

💡 Hint

Think about how Android handles permissions after the user disables future prompts.

When a user denies permission and selects "Don't ask again", the system no longer shows the permission dialog. Instead, the app immediately receives a denial callback.

❓ lifecycle

intermediate

When to request permissions in Activity lifecycle?

Which lifecycle method is the best place to request runtime permissions in an Android Activity to ensure the UI is ready and the user is not interrupted during startup?

A onPause()

B onStart()

C onCreate()

D onResume()

💡 Hint

Consider when the Activity is fully visible and interactive.

Requesting permissions in onResume() ensures the UI is visible and ready, and the user can respond to the permission dialog without interruption.

📝 Syntax

advanced

What is the correct Kotlin code to request a single permission?

Given the following code snippet, which option correctly requests the CAMERA permission using Activity Result API in Kotlin?

Android Kotlin

val requestPermissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
    if (isGranted) {
        // Permission granted
    } else {
        // Permission denied
    }
}

// Request permission here

A requestPermissionLauncher.launch("android.permission.CAMERA")

B requestPermissionLauncher.launch(Manifest.permission.CAMERA)

C requestPermissionLauncher.launch(Permission.CAMERA)

D requestPermissionLauncher.launch(Manifest.permission.CAMERA.toString())

💡 Hint

Use the constant from Manifest.permission for permissions.

The correct way is to pass Manifest.permission.CAMERA directly as a string constant to launch().

🔧 Debug

advanced

Why does the permission callback not trigger?

An app uses registerForActivityResult to request location permission but the callback never executes. What is the most likely cause?

Android Kotlin

val requestPermissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
    // callback code
}

fun requestLocationPermission() {
    requestPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)
}

// Called in onCreate
requestLocationPermission()

A requestPermissionLauncher must be a class-level variable, not local.

B The callback only triggers if permission is already granted.

C registerForActivityResult must be called before onCreate.

D The permission string ACCESS_FINE_LOCATION is incorrect.

💡 Hint

Consider the lifecycle of the launcher variable.

If the launcher is declared inside a function or local scope, it may be garbage collected before the callback triggers. It must be a class-level property.

🧠 Conceptual

expert

How to handle multiple permissions with rationale?

You want to request CAMERA and LOCATION permissions together. If the user denies any permission, you want to show a rationale dialog before requesting again. Which approach correctly implements this flow?

A Request both permissions at once using ActivityResultContracts.RequestMultiplePermissions(), then check which are denied and show rationale dialog before re-requesting only denied ones.

B Request CAMERA permission first, then LOCATION separately without rationale dialogs.

C Request permissions in manifest only, no runtime requests needed.

D Request permissions one by one without checking rationale, assuming user will grant eventually.

💡 Hint

Think about user experience and Android guidelines for multiple permissions.

RequestMultiplePermissions allows requesting several permissions at once. After the result, you can detect which were denied and show rationale dialogs before re-requesting only those permissions.

Practice

1. What is the first step before requesting a dangerous permission in Android Kotlin?

easy

A. Restart the app

B. Directly call requestPermissions without checking

C. Show a Toast message to the user

D. Check if the permission is already granted

Solution

1. Step 1: Understand permission checking

   Before asking for permission, the app must check if it already has it to avoid unnecessary requests.

2. Step 2: Use ContextCompat.checkSelfPermission

   This method returns if the permission is granted or denied, guiding the next action.

3. Final Answer:

   Check if the permission is already granted -> Option D

4. Quick Check:

   Check permission first = A [OK]

Hint: Always check permission status before requesting [OK]

Common Mistakes:

• Requesting permission without checking first
• Assuming permission is granted by default
• Ignoring permission status before action

2. Which Kotlin code snippet correctly requests a permission from an Activity?

easy

A. ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), 100)

B. requestPermissions(Manifest.permission.CAMERA, 100)

C. Activity.requestPermissions(this, Manifest.permission.CAMERA, 100)

D. requestPermission(Manifest.permission.CAMERA)

Solution

1. Step 1: Identify correct method signature

   ActivityCompat.requestPermissions requires context, array of permissions, and request code.

2. Step 2: Check syntax correctness

   ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), 100) matches the correct syntax with 'this' as context and arrayOf for permissions.

3. Final Answer:

   ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), 100) -> Option A

4. Quick Check:

   Correct requestPermissions syntax = D [OK]

Hint: Use ActivityCompat.requestPermissions with arrayOf permissions [OK]

Common Mistakes:

• Passing single permission string instead of array
• Using wrong method name or class
• Missing context parameter

3. Given this code snippet inside an Activity:

override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
  super.onRequestPermissionsResult(requestCode, permissions, grantResults)
  if (requestCode == 101 && grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
    println("Permission granted")
  } else {
    println("Permission denied")
  }
}

What will be printed if the user denies the permission?

medium

A. Permission denied

B. Permission granted

C. No output

D. App crashes

Solution

1. Step 1: Analyze grantResults array

   If the user denies permission, grantResults[0] will not equal PERMISSION_GRANTED.

2. Step 2: Follow conditional logic

   The else branch executes, printing "Permission denied".

3. Final Answer:

   Permission denied -> Option A

4. Quick Check:

   User denies permission = "Permission denied" [OK]

Hint: Denied permission triggers else branch in onRequestPermissionsResult [OK]

Common Mistakes:

• Assuming grantResults[0] is always granted
• Not checking if grantResults is empty
• Ignoring requestCode check

4. What is wrong with this permission request code snippet?

ActivityCompat.requestPermissions(this, Manifest.permission.ACCESS_FINE_LOCATION, 200)

medium

A. Request code 200 is invalid

B. Missing arrayOf() around permission string

C. Should use ContextCompat instead of ActivityCompat

D. No need to request ACCESS_FINE_LOCATION permission

Solution

1. Step 1: Check method parameters

   requestPermissions expects an array of permissions, not a single string.

2. Step 2: Identify correct usage

   Permission string must be wrapped in arrayOf() to form an array.

3. Final Answer:

   Missing arrayOf() around permission string -> Option B

4. Quick Check:

   Permissions must be in arrayOf() [OK]

Hint: Wrap permissions in arrayOf() when requesting [OK]

Common Mistakes:

• Passing single permission string instead of array
• Confusing ContextCompat with ActivityCompat
• Using invalid request codes

5. You want to request both CAMERA and LOCATION permissions at once. Which code correctly handles the request and checks the result in Kotlin?

hard

A. requestPermissions(arrayOf(Manifest.permission.CAMERA, Manifest.permission.ACCESS_FINE_LOCATION), 300)
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
println("Permissions handled")
}

B. ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), 300)
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
if (requestCode == 300 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
println("All permissions granted")
} else {
println("Some permissions denied")
}
}

C. ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA, Manifest.permission.ACCESS_FINE_LOCATION), 300)
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
if (requestCode == 300 && grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
println("All permissions granted")
} else {
println("Some permissions denied")
}
}

D. ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA, Manifest.permission.ACCESS_FINE_LOCATION), 300)
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
if (requestCode == 300 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
println("All permissions granted")
} else {
println("Some permissions denied")
}
}

Solution

1. Step 1: Request multiple permissions correctly

   Use arrayOf with both permissions and a unique request code.

2. Step 2: Check all permissions granted in onRequestPermissionsResult

   Use grantResults.all { it == PackageManager.PERMISSION_GRANTED } to verify all permissions.

3. Final Answer:

   Request both permissions and check all granted with grantResults.all -> Option C

4. Quick Check:

   Multiple permissions need all granted check [OK]

Hint: Check all grantResults for multiple permissions [OK]

Common Mistakes:

• Checking only first permission result
• Not using arrayOf for multiple permissions
• Ignoring requestCode in result handler