Permission request flow in Android Kotlin - Mini App: Build & Ship

Build: PermissionRequestScreen

This screen asks the user for camera permission and shows the permission status.

Target UI

-------------------------
| Permission Request    |
|-----------------------|
| Camera permission is  |
| needed to take photos.|
|                       |
| [Request Permission]  |
|                       |
| Status: Unknown       |
-------------------------

Show a button labeled 'Request Permission'.

When tapped, request CAMERA permission from the user.

Display the current permission status below the button: 'Granted', 'Denied', or 'Unknown'.

Handle the permission result properly.

Use modern Android Kotlin APIs for permission handling.

Starter Code

Android Kotlin

package com.example.permissionapp

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat
import android.widget.Button
import android.widget.TextView

class PermissionRequestScreen : AppCompatActivity() {
    private lateinit var statusTextView: TextView
    private lateinit var requestButton: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_permission_request_screen)

        statusTextView = findViewById(R.id.statusTextView)
        requestButton = findViewById(R.id.requestButton)

        // TODO: Add permission request logic here
    }
}

Task 1

Task 2

Task 3

Task 4

Solution

Android Kotlin

package com.example.permissionapp

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat
import android.widget.Button
import android.widget.TextView

class PermissionRequestScreen : AppCompatActivity() {
    private lateinit var statusTextView: TextView
    private lateinit var requestButton: Button

    private val requestPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted: Boolean ->
        if (isGranted) {
            statusTextView.text = "Status: Granted"
        } else {
            statusTextView.text = "Status: Denied"
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_permission_request_screen)

        statusTextView = findViewById(R.id.statusTextView)
        requestButton = findViewById(R.id.requestButton)

        updatePermissionStatus()

        requestButton.setOnClickListener {
            requestPermissionLauncher.launch(Manifest.permission.CAMERA)
        }
    }

    private fun updatePermissionStatus() {
        val permissionStatus = ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
        statusTextView.text = when (permissionStatus) {
            PackageManager.PERMISSION_GRANTED -> "Status: Granted"
            PackageManager.PERMISSION_DENIED -> "Status: Denied"
            else -> "Status: Unknown"
        }
    }
}

This solution uses registerForActivityResult with RequestPermission to request the camera permission in a modern, recommended way.

We check the current permission status on screen creation and update the status text accordingly.

When the user taps the button, the permission request dialog appears. The result updates the status text to show if permission was granted or denied.

This approach avoids deprecated methods and handles permission flow cleanly.

Final Result

Completed Screen

-------------------------
| Permission Request    |
|-----------------------|
| Camera permission is  |
| needed to take photos.|
|                       |
| [Request Permission]  |
|                       |
| Status: Granted       |
-------------------------

User taps 'Request Permission' button.

System shows permission dialog asking for camera access.

User grants or denies permission.

Status text updates to 'Status: Granted' or 'Status: Denied' accordingly.

Stretch Goal

Add a rationale dialog that explains why the app needs camera permission before requesting it.

💡 Hint

Use shouldShowRequestPermissionRationale to check if rationale is needed and show an AlertDialog before launching the permission request.

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