Camposer

Camposer handles still captures and video recording through the CameraController using platform-specific implementations of commands and controllers.

Still Capture (takePicture)

When CameraController.takePicture(executor, callback) is called:

• It executes a TakePictureCommand.
• Android: Uses ImageCapture.takePicture() via CameraX.
• iOS: Uses AVCapturePhotoOutput.capturePhoto().
• Results are returned via CaptureResult.Success(uri) or CaptureResult.Failure(e) to the provided callback on the caller's executor/dispatcher.

Video Recording

• Starting: CameraController.startRecording(...) triggers the platform's RecordController. On Android, this uses VideoCapture.output.prepareRecording(); on iOS, it uses an AVAssetWriter pipeline. The CameraSession updates its isRecording flag to true.
• Stopping: CameraController.stopRecording() finalizes the recording, delivers the CaptureResult, and sets isRecording to false in the CameraSession.

Camposer provides a unified Compose API for camera access in Kotlin Multiplatform (KMP) apps. The architecture separates user-facing controls from platform-specific hardware implementations (Android's CameraX and iOS's AVFoundation).

Core Components

• CameraPreview: The root @Composable function. It renders the camera feed and manages the UI lifecycle.
• CameraSession: The primary state holder, created using rememberCameraSession(). It is an expect class that provides access to the session's state, hardware info, and controller.
• CameraState: A collection of configurable camera properties exposed as MutableStateFlow (e.g., FlashMode, zoom, captureMode, format). Mutating these flows automatically triggers updates in the underlying camera engine.
• CameraController: The user-facing API for triggering captures, including takePicture, startRecording, and stopRecording.
• CameraInfo: Provides runtime information about the hardware's capabilities, such as supported features and zoom/exposure ranges.

// Conceptual usage pattern
@Composable
fun MyCameraScreen() {
    val session = rememberCameraSession()
    
    Column {
        CameraPreview(session)
        
        Button(onClick = { session.controller.takePicture(executor, callback) }) {
            Text("Take Picture")
        }
    }
}

Camposer is built using several core architectural patterns that affect how you extend or interact with the library:

• KMP expect/actual: The core camera components (CameraSession, CameraEngineImpl) and test fakes (FakeCameraEngine, FakeCameraTest, FakeCameraSession) use Kotlin Multiplatform's expect/actual mechanism. If you need to add a method to these components, you must update the common expect declaration and provide the corresponding actual implementations for all supported platforms.
• Coroutines for Async State: All asynchronous state is driven by Coroutines. CameraState properties are exposed as MutableStateFlow. Platform engines collect these flows on their respective dispatchers. Crucially, no callbacks cross the public API boundary; you should interact with the state via Flows.
• Compose Lifecycle Management: Camera startup and teardown are managed by the Compose lifecycle rather than imperative commands. The CameraPreview component uses DisposableEffect to automatically bind and unbind the camera engine to the composable's lifecycle. There is no manual start() or stop() API to call.

The captureMode parameter determines whether the camera is in photo capture or video recording mode. This mode is passed to the CameraPreview component.

Available modes:

• CaptureMode.Image (default): Enables still image capture functionality.
• CaptureMode.Video: Enables video recording functionality and makes recording-related APIs available.

You can manage the mode using a state variable (e.g., using Compose's mutableStateOf) to toggle between modes dynamically.

var captureMode by remember { mutableStateOf(CaptureMode.Image) }
val cameraSession = rememberCameraSession()

CameraPreview(
    cameraSession = cameraSession,
    captureMode = captureMode,
) {
    Button(
        onClick = {
            captureMode = when (captureMode) {
                CaptureMode.Image -> CaptureMode.Video
                CaptureMode.Video -> CaptureMode.Image
            }
        }
    ) {
        Text(
            "Switch to ${if (captureMode == CaptureMode.Image) "Video" else "Image"} Mode"
        )
    }
}