Kotlin Camera Permission Not Triggering Fix

If you’re building an Android app using Kotlin and experiencing issues where camera permission is not triggering, you’re not alone. Many developers encounter this frustrating behavior where requestPermissions() is called but the permission dialog does not appear or the callback is never triggered. This article explains the root causes, shares real examples, and offers working code solutions to help you fix this issue quickly.

Common Symptoms

You might be facing one of the following symptoms:

• The permission dialog never shows up
• The camera permission is denied silently
• onRequestPermissionsResult() or ActivityResultLauncher is not triggered
• Camera intent fails with a permission error

These issues typically stem from missing manifest declarations, incorrect usage of the permission APIs, or logic bugs in your flow.

Step-by-Step Fix for Kotlin Camera Permission Issues

Let’s fix it properly using Kotlin in Android Studio.

1. Declare Permissions in AndroidManifest.xml

Make sure you have declared the required permission in the manifest file:

<uses-permission android:name="android.permission.CAMERA" />

Optional: If you’re also using storage or saving pictures:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

2. Request Runtime Permissions (Android 6.0+)

Use the modern permission request approach using ActivityCompat or ActivityResultLauncher.

Method 1: Using ActivityCompat (Classic Way)

private val CAMERA_REQUEST_CODE = 100

private fun checkCameraPermission() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
        != PackageManager.PERMISSION_GRANTED) {
        
        ActivityCompat.requestPermissions(
            this,
            arrayOf(Manifest.permission.CAMERA),
            CAMERA_REQUEST_CODE
        )
    } else {
        openCamera()
    }
}

override fun onRequestPermissionsResult(
    requestCode: Int, permissions: Array<String>, grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    
    if (requestCode == CAMERA_REQUEST_CODE) {
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            openCamera()
        } else {
            Toast.makeText(this, "Camera permission denied", Toast.LENGTH_SHORT).show()
        }
    }
}

Method 2: Using ActivityResultLauncher (Modern Recommended Way)

private lateinit var requestCameraPermissionLauncher: ActivityResultLauncher<String>

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    requestCameraPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted: Boolean ->
        if (isGranted) {
            openCamera()
        } else {
            Toast.makeText(this, "Permission denied", Toast.LENGTH_SHORT).show()
        }
    }

    checkAndRequestPermission()
}

private fun checkAndRequestPermission() {
    when {
        ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) ==
                PackageManager.PERMISSION_GRANTED -> {
            openCamera()
        }

        shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) -> {
            Toast.makeText(this, "Camera access is required to take pictures", Toast.LENGTH_LONG).show()
            requestCameraPermissionLauncher.launch(Manifest.permission.CAMERA)
        }

        else -> {
            requestCameraPermissionLauncher.launch(Manifest.permission.CAMERA)
        }
    }
}

3. Open Camera Intent

If permission is granted, use this code to open the camera:

private fun openCamera() {
    val cameraIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
    if (cameraIntent.resolveActivity(packageManager) != null) {
        startActivityForResult(cameraIntent, CAMERA_REQUEST_CODE)
    } else {
        Toast.makeText(this, "No camera app found", Toast.LENGTH_SHORT).show()
    }
}

4. Troubleshooting Tips

If permission still doesn’t trigger:

• ❗ Check device settings: User may have permanently denied the permission. Go to App Settings > Permissions and manually enable.
• ❗ Avoid calling permission request before onCreate().
• ❗ Don’t forget to test on a real device, not just the emulator.

Test Case Example: Minimal Working App

Here’s a minimal app that requests camera permission and launches the camera:

class MainActivity : AppCompatActivity() {

    private val CAMERA_REQUEST_CODE = 101
    private lateinit var requestPermissionLauncher: ActivityResultLauncher<String>

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

        requestPermissionLauncher = registerForActivityResult(
            ActivityResultContracts.RequestPermission()
        ) { isGranted ->
            if (isGranted) {
                openCamera()
            } else {
                Toast.makeText(this, "Camera permission denied", Toast.LENGTH_SHORT).show()
            }
        }

        findViewById<Button>(R.id.btnCamera).setOnClickListener {
            checkCameraPermission()
        }
    }

    private fun checkCameraPermission() {
        when {
            ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) ==
                    PackageManager.PERMISSION_GRANTED -> {
                openCamera()
            }

            shouldShowRequestPermissionRationale(Manifest.permission.CAMERA) -> {
                requestPermissionLauncher.launch(Manifest.permission.CAMERA)
            }

            else -> {
                requestPermissionLauncher.launch(Manifest.permission.CAMERA)
            }
        }
    }

    private fun openCamera() {
        val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        startActivityForResult(intent, CAMERA_REQUEST_CODE)
    }
}

Conclusion

When the Kotlin camera permission is not triggering, it’s usually due to one of the following reasons: missing manifest declaration, not requesting permission properly at runtime, or logic bugs. Using modern ActivityResultLauncher is the most reliable way in 2025 Android development.

Make sure you’ve tested on various Android versions and devices, and always handle permission denial gracefully for a smooth user experience.