Introduction to Custom Camera Interfaces with AVFoundation

Building a custom camera interface in iOS gives developers complete control over the look, feel, and behavior of the camera experience. While Apple’s UIImagePickerController offers a ready-made solution, it lacks flexibility for advanced features like real-time filters, manual focus, custom overlays, or multi-camera setups. By leveraging AVFoundation, you can create a camera that integrates seamlessly with your app’s design and functionality. This guide walks through the entire process — from initializing a capture session to handling photo output and user interactions — providing a solid foundation for any custom camera implementation.

Whether you are building a document scanner, a barcode reader, or a social media filter app, AVFoundation equips you with the tools needed for a professional-grade camera. This article assumes familiarity with iOS development basics, including Swift, Xcode, and UIKit. For official reference, see Apple’s AVFoundation documentation.

Setting Up the AVFoundation Framework

Before writing any code, ensure your project has the necessary permissions and imports. Open Info.plist and add the Privacy – Camera Usage Description key with a concise explanation of why your app needs camera access. Without this, the system will crash when trying to capture media.

Importing the Framework

In the view controller where you plan to implement the camera, add the following import statement:

import AVFoundation
import UIKit

AVFoundation provides all the classes needed for capture, while UIKit handles the user interface. Optionally, import Photos if you intend to save images to the library.

Initializing the Capture Session

The heart of any AVFoundation-based camera is the AVCaptureSession. This object manages the flow of data from inputs (cameras, microphones) to outputs (photo files, video frames). Start by creating a session and setting its preset to define the quality and format of the captured media.

let session = AVCaptureSession()
session.sessionPreset = .photo

The .photo preset optimizes for high-resolution still images. For video recording, you might use .hd1920x1080 or .high. Always check if the device supports the desired preset using session.canSetSessionPreset().

Configuring the Camera Device

Next, select a physical camera device. iOS devices typically have multiple cameras: wide-angle, telephoto, ultra-wide, and front-facing. Use AVCaptureDevice.default(_:for:position:) to get the most suitable device for your needs.

guard let camera = AVCaptureDevice.default(.builtInWideAngleCamera,
                                           for: .video,
                                           position: .back) else {
    fatalError("No back camera available")
}

Once you have a device, create an AVCaptureDeviceInput and add it to the session. Inputs must be added before the session starts running.

do {
    let input = try AVCaptureDeviceInput(device: camera)
    if session.canAddInput(input) {
        session.addInput(input)
    }
} catch {
    print("Error creating camera input: \(error.localizedDescription)")
    return
}

If multiple cameras are needed (e.g., simultaneous front and back), add multiple inputs — but be aware of device capabilities and performance constraints.

Creating the Preview Layer

To display the live camera feed on screen, use AVCaptureVideoPreviewLayer. This layer is a subclass of CALayer that renders real-time video from the session.

let previewLayer = AVCaptureVideoPreviewLayer(session: session)
previewLayer.frame = view.bounds
previewLayer.videoGravity = .resizeAspectFill
view.layer.addSublayer(previewLayer)

The videoGravity property controls how the video fits within the layer’s bounds. .resizeAspectFill fills the layer while preserving aspect ratio, which is ideal for full-screen previews. For portrait apps, you must also account for the device’s orientation.

Handling Device Orientation and Layout

The preview layer’s connection has an orientation property that should match the interface orientation. Override viewDidLayoutSubviews() to update the layer’s frame and orientation:

override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    previewLayer.frame = view.bounds
    if let connection = previewLayer.connection, connection.isVideoOrientationSupported {
        connection.videoOrientation = .portrait
    }
}

For apps that support multiple orientations, listen to UIDevice.orientationDidChangeNotification and adjust accordingly. Ignoring orientation can result in upside-down or rotated previews.

Configuring Photo Output

To capture still images, add an AVCapturePhotoOutput to the session. This output delivers processed photo data via delegate methods. Create and add the output after the session is configured but before it starts running.

let photoOutput = AVCapturePhotoOutput()
if session.canAddOutput(photoOutput) {
    session.addOutput(photoOutput)
}

You can also configure output settings like isHighResolutionCaptureEnabled and isDepthDataDeliveryEnabled (for devices with dual cameras). These increase the quality and metadata of the captured photo.

Setting Up Photo Settings

When you initiate a capture, you specify the settings via an AVCapturePhotoSettings object. This allows you to control flash, auto exposure, and specific format options.

let settings = AVCapturePhotoSettings()
settings.flashMode = .auto
settings.isAutoStillImageStabilizationEnabled = true

For more advanced use cases (e.g., Live Photos, RAW capture), use subclasses like AVCapturePhotoBracketSettings or set isHighResolutionPhotoEnabled on the output beforehand.

Capturing Photos

With the session running and UI prepared, you can implement a capture button that triggers photo taking. The core method is capturePhoto(with:delegate:) on the photo output object.

Implementing the Capture Function

@IBAction func captureButtonTapped(_ sender: UIButton) {
    let settings = AVCapturePhotoSettings()
    photoOutput.capturePhoto(with: settings, delegate: self)
}

The delegate (typically your view controller) must conform to AVCapturePhotoCaptureDelegate. This protocol provides methods to process the captured photo and handle errors.

Implementing the Delegate

extension CameraViewController: AVCapturePhotoCaptureDelegate {

    func photoOutput(_ output: AVCapturePhotoOutput,
                     didFinishProcessingPhoto photo: AVCapturePhoto,
                     error: Error?) {
        guard error == nil else {
            print("Photo capture error: \(error!.localizedDescription)")
            return
        }
        guard let imageData = photo.fileDataRepresentation(),
              let image = UIImage(data: imageData) else {
            print("Unable to create image from photo data")
            return
        }
        // Use the image – display, save, or process.
        DispatchQueue.main.async {
            self.capturedImageView.image = image
        }
    }

    func photoOutput(_ output: AVCapturePhotoOutput,
                     willCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings) {
        // Optional: play shutter sound or animate flash.
        AudioServicesPlaySystemSound(1108)
    }
}

Note: The delegate method didFinishProcessingPhoto is called on a background queue. Always dispatch UI updates to the main thread.

Handling Live Preview Interactions

A custom camera interface often includes tap-to-focus, exposure lock, and pinch-to-zoom. These features require direct manipulation of the AVCaptureDevice.

Tap to Focus and Exposure

Add a tap gesture recognizer to the preview layer’s parent view. Convert the tap point to the camera’s coordinate system using captureDevicePointConverted(fromLayerPoint:).

@objc func handleTap(_ gesture: UITapGestureRecognizer) {
    let location = gesture.location(in: view)
    guard let device = cameraInput?.device else { return }

    // Convert to normalized coordinates (0,0 to 1,1)
    let pointOfInterest = previewLayer.captureDevicePointConverted(fromLayerPoint: location)

    do {
        try device.lockForConfiguration()
        if device.isFocusPointOfInterestSupported {
            device.focusPointOfInterest = pointOfInterest
            device.focusMode = .autoFocus
        }
        if device.isExposurePointOfInterestSupported {
            device.exposurePointOfInterest = pointOfInterest
            device.exposureMode = .autoExpose
        }
        device.unlockForConfiguration()
    } catch {
        print("Could not lock device for configuration: \(error)")
    }
}

For continuous autofocus, set focusMode to .continuousAutoFocus. Always lock the device’s configuration before changing these properties and unlock afterwards.

Pinch to Zoom

Attach a UIPinchGestureRecognizer to adjust the device’s videoZoomFactor. The device has a range from minAvailableVideoZoomFactor (usually 1.0) to maxAvailableVideoZoomFactor (depends on hardware).

@objc func handlePinch(_ gesture: UIPinchGestureRecognizer) {
    guard let device = cameraInput?.device else { return }
    let zoomFactor = max(1.0, min(device.maxAvailableVideoZoomFactor,
                                  gesture.scale * device.videoZoomFactor))
    do {
        try device.lockForConfiguration()
        device.videoZoomFactor = zoomFactor
        device.unlockForConfiguration()
    } catch {
        // Handle error
    }
    gesture.scale = 1.0 // Reset for continuous gesture
}

Post-Processing and Saving Images

After capturing a photo, you typically want to save it to the user’s photo library or display it within the app. Use the Photos framework to save images asynchronously.

Saving to Photo Library

import Photos

func saveImageToLibrary(_ image: UIImage) {
    PHPhotoLibrary.requestAuthorization { status in
        guard status == .authorized else {
            print("Photo library access denied")
            return
        }
        PHPhotoLibrary.shared().performChanges {
            PHAssetChangeRequest.creationRequestForAsset(from: image)
        } completionHandler: { success, error in
            if success {
                print("Image saved successfully")
            } else {
                print("Error saving image: \(error?.localizedDescription ?? "unknown")")
            }
        }
    }
}

Always request authorization before performing changes. For iOS 14+, consider using limited library access and the PHPickerViewController for user selection.

Displaying Captured Image

To show the captured image temporarily, assign it to an image view. For a full preview, present a modal view controller with the captured photo and options to retake or use the photo.

Advanced Features

To make your camera interface stand out, consider implementing the following capabilities.

Switching Between Front and Back Cameras

Toggle cameras by removing the existing input and adding a new one from the opposite position. Store the current input and session to reconfigure:

func switchCamera() {
    guard let currentInput = cameraInput else { return }
    session.beginConfiguration()
    session.removeInput(currentInput)

    let newPosition: AVCaptureDevice.Position = currentInput.device.position == .back ? .front : .back
    guard let newCamera = AVCaptureDevice.default(.builtInWideAngleCamera,
                                                  for: .video,
                                                  position: newPosition),
          let newInput = try? AVCaptureDeviceInput(device: newCamera),
          session.canAddInput(newInput) else {
        // Re-add original input if new one fails
        session.addInput(currentInput)
        session.commitConfiguration()
        return
    }
    session.addInput(newInput)
    cameraInput = newInput
    session.commitConfiguration()
}

Use beginConfiguration() and commitConfiguration() to batch changes without interrupting the session.

Flash Control

The flash mode is set on each capture’s settings, but you can also control the torch (continuous light) via the device:

func toggleTorch() {
    guard let device = cameraInput?.device, device.hasTorch else { return }
    do {
        try device.lockForConfiguration()
        device.torchMode = device.torchMode == .on ? .off : .on
        device.unlockForConfiguration()
    } catch {
        print("Torch error: \(error)")
    }
}

For photo capture, use flashMode in AVCapturePhotoSettings.

Enabling RAW Capture

On devices with a camera that supports RAW (e.g., iPhone 12 Pro series), you can capture DNG files. First, check if the photo output supports RAW:

if photoOutput.isRAWCaptureSupported {
    let rawFormat = photoOutput.availableRawPhotoFileTypes.first ?? .dng
    let settings = AVCapturePhotoSettings(rawPixelFormatType: rawFormat.rawValue)
    // Set processed format as well if needed
    photoOutput.capturePhoto(with: settings, delegate: self)
}

RAW files provide greater editing flexibility but require more storage and processing.

Error Handling and Permissions

Robust error handling ensures your app behaves gracefully under unexpected conditions.

Camera Permission

Before starting the session, verify authorization status:

func requestCameraPermission() {
    switch AVCaptureDevice.authorizationStatus(for: .video) {
    case .authorized:
        self.setupCamera()
    case .notDetermined:
        AVCaptureDevice.requestAccess(for: .video) { granted in
            DispatchQueue.main.async {
                if granted { self.setupCamera() }
                else { self.showPermissionAlert() }
            }
        }
    default:
        showPermissionAlert()
    }
}

If the user denies permission, present an alert directing them to Settings.

Session Runtime Errors

Subscribe to AVCaptureSessionRuntimeErrorNotification to handle issues like a disconnected camera (e.g., during a phone call).

NotificationCenter.default.addObserver(self,
                                       selector: #selector(handleSessionError),
                                       name: .AVCaptureSessionRuntimeError,
                                       object: session)

@objc func handleSessionError(_ notification: Notification) {
    guard let error = notification.userInfo?[AVCaptureSessionErrorKey] as? AVError else { return }
    print("Session runtime error: \(error.localizedDescription)")
    // Attempt to restart the session after a delay
    DispatchQueue.main.async {
        self.session.startRunning()
    }
}

Conclusion

Implementing a custom camera interface with AVFoundation provides unmatched flexibility and control over the camera experience. By following the steps outlined in this guide — from session setup and preview layer creation to photo capture and user interaction — you can build a camera that integrates seamlessly into your iOS app. Remember to handle permissions, device orientation, and runtime errors gracefully. For further exploration, refer to AVCapturePhotoOutput and AVCaptureDevice documentation. With these fundamentals, you are ready to create a polished, production-ready custom camera interface.