Devices

Once you allocate a camera manager, you can start to query and interact with the device sensors, represented by the io.deepmedia.camera.CameraDeviceCameraDevice class.

Selecting Devices

You can access a list of all devices using CameraManager.devices. If needed, you can select them by inspecting their properties:

kotlin
Copy
val manager: CameraManager = ...
val frontCamera: CameraDevice? = manager.devices.firstOrNull {
  it.direction == CameraDevice.Direction.Front
}

swift
Copy
let manager: CameraManager = ...
let frontCamera: CameraDevice? = manager.devices.first {
  $0.direction == .front
}

Some of the device properties you may consider are:

• id: String: a unique identifier for this device
• direction: CameraDevice.Direction: either front, back or external
• children: [CameraDevice]: the underlying devices for logical cameras made of multiple physical sensors under the hood
• capabilities: CameraCapabilities: a precise description of what this device can do

As you go through the guide, you'll learn about more properties that can be used for selection.

Managing Devices

Open

For a device to be used in any way it must be opened first, and that's done via the openDevice function:

kotlin
Copy
suspend fun openDevice(
  id: String? = null,
  direction: CameraDevice.Direction? = null
): CameraDevice = ...

swift
Copy
func openDevice(
  id: String? = nil,
  direction: CameraDevice.Direction? = nil
) async throws -> CameraDevice { ... }

Opening a camera means making it active and ready to be used for the use-cases you declared during initialization. For example:

• If the preview feature was selected, the camera will stream into any preview surface that you define
• If the picture feature was selected, the camera gets ready to receive the takePicture command
• If the video feature was selected, the camera gets ready to interact with the recorder
• If the barcode feature was selected, the camera will start looking for barcodes in the scene

In general, it makes the camera ready to do what you intended to do.

Close

Once you're done with a camera, you can either open another one, or close all of them.

kotlin
Copy
suspend fun closeDevices(): Unit = ...

swift
Copy
func closeDevices() async throws { ... }

Tip: use CameraManager.flipDevice() for the manager to check what camera is currently open, and open one that has the opposite direction.

Observing Devices

Current Device

Only one device can be opened at any given time. You can retrieve and observe changes with the CameraManager.currentDevice property:

kotlin
Copy
val current: CameraDevice? = manager.currentDevice.value
val flow: StateFlow<CameraDevice?> = manager.currentDevice

swift
Copy
let current: CameraDevice? = manager.currentDevice
let publisher: AnyPublisher<CameraDevice?, Never> = manager.currentDevicePublisher

Device Status

At any given time, a single device has a status represented by the CameraDevice.Status enum:

kotlin
Copy
val current: CameraDevice.Status = device.status.value
val flow: StateFlow<CameraDevice.Status> = device.status

swift
Copy
let current: CameraDevice.Status = device.status
let publisher: AnyPublisher<CameraDevice.Status, Never> = device.statusPublisher

Check the table below to understand the meaning of each status enum case: