Camera Permission in Mobile Apps — What It Is, Access Types and How It Works

What is Camera Permission?

Camera Permission is a system permission that regulates app access to a mobile device camera. Mobile platforms treat the camera as a sensitive resource because it allows recording video and photographing the user’s surroundings in real time.

On Android, the CAMERA permission belongs to the dangerous permissions category and requires a mandatory runtime request. On iOS, adding the NSCameraUsageDescription key to Info.plist is a mandatory requirement for any app that accesses the camera. Without this key, the app will crash when trying to open the camera.

According to a Statista (2024) study, about 68% of mobile apps in the top 100 App Store use the camera in some form: from scanning QR codes to full photo and video capture. At the same time, 37% of users deny camera access if they do not understand why the app needs this permission.

Camera Permission on Android

Camera Permission on Android is requested through a manifest declaration followed by a runtime request. Starting from Android 6.0, the CAMERA permission cannot be obtained only at install time — the user must explicitly confirm access.

Declaration in AndroidManifest.xml

To use the camera on Android, you must add the corresponding declaration to the manifest file. Without it, the system will not allow the app to open the camera even with a runtime request.

<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" android:required="false" />

The android:required=false attribute for uses-feature allows the app to be installed on devices without a camera. This is important if the camera is not a mandatory component for the entire app operation.

Runtime Request in Kotlin

The Camera Permission request is performed through the Activity Result API. After receiving the response, the app checks the status and starts the camera or shows an explanation.

private val cameraLauncher =
    registerForActivityResult(ActivityResultContracts.TakePicture()) { success ->
    if (success) {
        // Photo saved
        showPhoto(photoUri)
    }
}

private val permissionLauncher =
    registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
    if (granted) {
        openCamera()
    } else {
        showPermissionDenied()
    }
}

fun capturePhoto() {
    if (ContextCompat.checkSelfPermission(this,
        Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
        openCamera()
    } else {
        permissionLauncher.launch(Manifest.permission.CAMERA)
    }
}

Android 11+ Features

Starting from Android 11, if the user has denied camera access twice, the system dialog will no longer be shown. The Never Ask Again flag is set automatically, and the app can only redirect the user to system settings via Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS). The developer should include a check for shouldShowRequestPermissionRationale to display a preliminary screen in a timely manner.

Camera Permission on iOS

Camera Permission on iOS is managed through the NSCameraUsageDescription key in Info.plist and a call to AVCaptureDevice.requestAccess. Apple strictly checks the justification of the request: if the app uses the camera in a way that is not obvious to the user, the App Store may reject the app.

Configuring Info.plist

A mandatory condition for camera access on iOS is adding the NSCameraUsageDescription key to the Info.plist file. The value string will be displayed in the system dialog as the reason for the request.

<key>NSCameraUsageDescription</key>
<string>The app needs camera access to create profile photos and scan QR codes.</string>

Request in Swift

In Swift, the request is performed through the static method AVCaptureDevice.requestAccess. After receiving the response, the app processes the status and starts the capture session.

import AVFoundation

func requestCameraAccess() {
    AVCaptureDevice.requestAccess(for: .video) { granted in
        DispatchQueue.main.async {
            if granted {
                self.setupCameraSession()
            } else {
                self.showSettingsAlert()
            }
        }
    }
}

private func setupCameraSession() {
    guard let device = AVCaptureDevice.default(.for: .video)
    else { return }
    do {
        let input = try AVCaptureDeviceInput(device: device)
        let session = AVCaptureSession()
        session.addInput(input)
        session.startRunning()
    } catch {
        print("Camera error: \(error)")
    }
}

Checking Current Status

Before requesting camera access, it is recommended to check the current authorization status via AVCaptureDevice.authorizationStatus(for: .video). This avoids unnecessary system dialog calls and correctly handles cases where the user has already made a decision. The status can be .notDetermined, .restricted, .denied, or .authorized.

Camera Usage Scenarios

Camera Permission is applied in various scenarios, from simple scanning to full video capture. Each scenario has its own requirements for implementation and permission handling.

QR and Barcode Scanning

On iOS, AVCaptureMetadataOutput from the AVFoundation framework is used for QR code scanning, which requires Camera Permission. On Android, it is recommended to use Google’s ML Kit Barcode Scanning. It is important to note that QR code scanning uses the camera itself, not an image analysis library — therefore, Camera Permission is mandatory.

Photo and Video Capture

Standard photo or video capture requires Camera Permission on both iOS and Android. On Android, you can use Intent(MediaStore.ACTION_IMAGE_CAPTURE), which opens the system camera app — in this case, the system app requests the permission, not yours. However, for in-app camera preview (CameraX, Camera2 API), your own permission is required.

Video Calls and AR

Video calling apps (Zoom, Google Meet) and augmented reality apps (ARCore, ARKit) request Camera Permission to capture video from the front or rear camera. In this case, the request should be explained particularly carefully, as the user may not expect a AR furniture fitting app to request the camera.

Configuring Capture Parameters

When working with the camera on iOS, you can configure capture parameters via AVCaptureDeviceInput and AVCapturePhotoOutput. On Android, CameraX simplifies configuration through ImageCapture, VideoCapture, and Preview callbacks. For each setting, you need to specify the desired resolution, zoom level, and focus mode. Choosing the correct capture configuration directly affects app performance and battery consumption.

Error Handling When Working with Camera

Various errors can occur when working with the camera. The camera may be occupied by another app, disabled in system privacy settings, or absent on the device. On Android, it is recommended to handle CameraAccessException when calling CameraManager.openCamera. On iOS, check AVCaptureDevice.authorizationStatus and handle denial correctly by offering the user to go to settings to enable access. Always check for camera availability on the device before requesting permission using PackageManager.hasSystemFeature. Such a check prevents unnecessary requests on devices without a camera and improves the user experience.

Camera Performance Optimization

Performance optimization when working with the camera is important for smooth app operation. Capturing video at high resolution consumes significant CPU and battery resources.

On iOS, use AVCaptureSessionPresetMedium instead of maximum resolution if the app does not require 4K capture. On Android, CameraX allows you to configure ImageCapture with a target resolution through ImageCaptureConfig.Builder. It is also important to release the camera when the app goes into the background and re-acquire it when returning. This is a standard practice recommended by Google and Apple to conserve battery life.

Best Practices for Requesting Camera Access

Best practices help increase the Camera Permission approval rate and avoid app rejection by the App Store or Google Play.

Use a Preview for Explanation

Before showing the system dialog, display a screen with an example of how the camera will be used: a scanning interface image, a profile photo frame, an example of a recognized QR code. Visual explanation works better than text. According to UX Movement (2024), adding a visual preview increases approval conversion to 72%.

Request Permission at the Moment of Action

Never request Camera Permission on the first app launch. A user who just opened the app is more likely to deny if they do not understand the context. Request access strictly when the user presses a button that requires the camera: “Take Profile Photo”, “Scan Code”, “Start Video Call”. A contextual trigger makes the request more meaningful.

Provide an Alternative

If the user denies Camera Permission, offer an alternative way to perform the action: selecting a photo from the gallery, manually entering QR code data, uploading an image from the device. Denial should not completely block app functionality — this is a requirement of Google Play and App Store design recommendations.