Why Permission request flow in Android Kotlin? - Purpose & Use Cases

The Big Idea

What if your app could ask for permissions smoothly without confusing code or frustrated users?

The Scenario

Imagine you want your app to take photos or access contacts, but you have to ask the user for permission every time manually.

You write code to check if permission is granted, then ask for it, then handle the user's answer all over your app.

The Problem

This manual way is slow and confusing. You might forget to check permission before using a feature.

Or you might write the same code many times, making your app buggy and hard to fix.

The Solution

The permission request flow helps you handle all these steps in one clear process.

It guides your app to ask for permission, wait for the user's answer, and then continue safely.

Before vs After

✗ Before

if (checkSelfPermission() != GRANTED) {
  requestPermission()
}
// then handle result separately

✓ After

registerForActivityResult(RequestPermission()) { granted ->
  if (granted) useFeature()
}

What It Enables

This flow makes your app respectful and smooth, asking permission only when needed and reacting instantly.

Real Life Example

When you open the camera in a photo app, it asks for permission once, then lets you take pictures without interruptions.

Key Takeaways

Manual permission checks are repetitive and error-prone.

The permission request flow centralizes and simplifies permission handling.

This leads to better user experience and safer app behavior.

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