@imgly/camera-react-native 1.76.0 → 1.77.0

package/android/build.gradle

@@ -141,6 +141,6 @@ repositories {
 }
 
 dependencies {
-    api "ly.img:camera:1.76.0"
+    api "ly.img:camera:1.77.0"
     implementation "com.facebook.react:react-native"
 }

package/android/src/main/kotlin/ly/img/camera/reactnative/module/IMGLYCameraModule.kt

@@ -11,14 +11,14 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import ly.img.camera.CameraActivity
-import ly.img.camera.core.CaptureVideo
-import ly.img.camera.core.CaptureVideo.Companion.INTENT_KEY_CAMERA_INPUT
+import ly.img.camera.core.CaptureMedia
+import ly.img.camera.core.CaptureMedia.Companion.INTENT_KEY_CAMERA_INPUT
 import ly.img.camera.core.EngineConfiguration
 import ly.img.camera.reactnative.module.model.CameraResult
 import ly.img.camera.reactnative.module.model.CameraSettings
 
-/** A closure to specify a [CaptureVideo.Input] the camera session based on given *metadata*. */
-typealias CameraInputClosure = (metadata: Map<String, Any?>?) -> CaptureVideo.Input
+/** A closure to specify a [CaptureMedia.Input] the camera session based on given *metadata*. */
+typealias CameraInputClosure = (metadata: Map<String, Any?>?) -> CaptureMedia.Input
 
 /** A closure to modify the [CameraResult] before being send to the JS layer. */
 typealias CameraResultClosure = (result: CameraResult?) -> CameraResult?
@@ -29,7 +29,7 @@ class IMGLYCameraModule(
 ) : IMGLYCameraModuleSpec(reactContext),
     ActivityEventListener {
     companion object {
-        /** A closure to specify a [CaptureVideo.Input] based on given *metadata*. */
+        /** A closure to specify a [CaptureMedia.Input] based on given *metadata*. */
         var configurationClosure: CameraInputClosure? = null
 
         /** A closure to modify the [CameraResult] before being send to the JS layer. */
@@ -128,9 +128,11 @@ class IMGLYCameraModule(
         this.completion = completion
 
         val engineConfiguration =
-            EngineConfiguration(license = settings.license ?: "", userId = settings.userId)
-        val input: CaptureVideo.Input =
-            configurationClosure?.invoke(metadata) ?: CaptureVideo.Input(engineConfiguration)
+            EngineConfiguration(license = settings.license ?: "", userId = settings.userId, host = "react-native")
+        val cameraConfiguration =
+            settings.configuration?.toNative() ?: ly.img.camera.core.CameraConfiguration()
+        val input: CaptureMedia.Input =
+            configurationClosure?.invoke(metadata) ?: CaptureMedia.Input(engineConfiguration, cameraConfiguration)
         val intent = Intent(activity, CameraActivity::class.java).apply {
             putExtra(INTENT_KEY_CAMERA_INPUT, input)
         }
@@ -149,9 +151,9 @@ class IMGLYCameraModule(
     ) {
         if (requestCode == this.requestCode) {
             if (resultCode == Activity.RESULT_OK) {
-                val result = intent?.getParcelableExtra<ly.img.camera.core.CameraResult>(CaptureVideo.INTENT_KEY_CAMERA_RESULT)
+                val result = intent?.getParcelableExtra<ly.img.camera.core.CameraResult>(CaptureMedia.INTENT_KEY_CAMERA_RESULT)
                 when (result) {
-                    is ly.img.camera.core.CameraResult.Record -> {
+                    is ly.img.camera.core.CameraResult.Captures -> {
                         var modifiedResult: CameraResult? = CameraResult(result)
                         val closure = resultClosure
                         if (closure != null) {

package/android/src/main/kotlin/ly/img/camera/reactnative/module/model/CameraResult.kt

@@ -1,57 +1,155 @@
 package ly.img.camera.reactnative.module.model
 
+import android.net.Uri
 import android.os.Parcel
 import android.os.Parcelable
 import ly.img.camera.reactnative.module.model.CameraResult.CREATOR.readMap
 import ly.img.camera.reactnative.module.model.CameraResult.CREATOR.writeMap
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.DurationUnit
+import ly.img.camera.core.CameraResult as CoreCameraResult
+import ly.img.camera.core.Capture as CoreCapture
 
 /**
- * The result type for a camera recording session in standard mode.
+ * A captured still photo.
  *
- * @property recordings The recordings of the camera session.
+ * @property uri The location of the photo file in temporary storage.
+ * @property duration The duration stamped on the photo.
  */
-data class CameraRecording(
-    val recordings: List<Recording>?,
+data class Photo(
+    val uri: Uri,
+    val duration: Duration,
 ) : Parcelable {
-    /**
-     * Creates a new instance from a given [Parcel].
-     * @param parcel The [Parcel].
-     */
     constructor(parcel: Parcel) : this(
-        parcel.createTypedArrayList(Recording),
+        uri = parcel.readParcelable(Uri::class.java.classLoader)!!,
+        duration = parcel.readLong().milliseconds,
     )
-    constructor(record: ly.img.camera.core.CameraResult.Record) : this(
-        record.recordings.map { Recording(it) },
+    constructor(photo: CoreCapture.Photo) : this(
+        uri = photo.uri,
+        duration = photo.clipDuration,
     )
 
     override fun writeToParcel(
         parcel: Parcel,
         flags: Int,
     ) {
-        parcel.writeTypedList(recordings)
+        parcel.writeParcelable(uri, flags)
+        parcel.writeLong(duration.inWholeMilliseconds)
     }
 
     override fun describeContents(): Int = 0
 
-    companion object CREATOR : Parcelable.Creator<CameraResult> {
-        override fun createFromParcel(parcel: Parcel): CameraResult = CameraResult(parcel)
+    companion object CREATOR : Parcelable.Creator<Photo> {
+        private const val PHOTO_FRAME_WIDTH = 1080f
+        private const val PHOTO_FRAME_HEIGHT = 1920f
 
-        override fun newArray(size: Int): Array<CameraResult?> = arrayOfNulls(size)
+        override fun createFromParcel(parcel: Parcel): Photo = Photo(parcel)
+
+        override fun newArray(size: Int): Array<Photo?> = arrayOfNulls(size)
+    }
+
+    fun toMap(): Map<String, Any?> {
+        // Android has no dual-camera mode — emit a single-element `images` list with the rect
+        // covering the full 1080×1920 preview frame so the wire format matches iOS's
+        // `Photo { images: [PhotoImage], duration }` contract.
+        val image = mapOf<String, Any?>(
+            "uri" to uri.toString(),
+            "rect" to mapOf<String, Any?>(
+                "x" to 0f,
+                "y" to 0f,
+                "width" to PHOTO_FRAME_WIDTH,
+                "height" to PHOTO_FRAME_HEIGHT,
+            ),
+        )
+        return mapOf(
+            "images" to listOf(image),
+            "duration" to duration.toDouble(DurationUnit.MILLISECONDS),
+        )
+    }
+}
+
+/**
+ * A single capture from the camera. Either a still [photo] or a video [video] recording.
+ */
+data class Capture(
+    val photo: Photo?,
+    val video: Recording?,
+) : Parcelable {
+    constructor(parcel: Parcel) : this(
+        photo = parcel.readParcelable(Photo::class.java.classLoader),
+        video = parcel.readParcelable(Recording::class.java.classLoader),
+    )
+    constructor(capture: CoreCapture) : this(
+        photo = (capture as? CoreCapture.Photo)?.let { Photo(it) },
+        video = (capture as? CoreCapture.Video)?.recording?.let { Recording(it) },
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeParcelable(photo, flags)
+        parcel.writeParcelable(video, flags)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<Capture> {
+        override fun createFromParcel(parcel: Parcel): Capture = Capture(parcel)
+
+        override fun newArray(size: Int): Array<Capture?> = arrayOfNulls(size)
+    }
+
+    fun toMap(): Map<String, Any?> = buildMap<String, Any?> {
+        photo?.let { put("photo", it.toMap()) }
+        video?.let { put("video", it.toMap()) }
+    }
+}
+
+/**
+ * The result type for a photo, video, or mixed camera capture session.
+ *
+ * @property captures The captures of the camera session.
+ */
+data class CameraCapture(
+    val captures: List<Capture>?,
+) : Parcelable {
+    constructor(parcel: Parcel) : this(
+        captures = parcel.createTypedArrayList(Capture),
+    )
+    constructor(captures: CoreCameraResult.Captures) : this(
+        captures = captures.captures.map { Capture(it) },
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeTypedList(captures)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<CameraCapture> {
+        override fun createFromParcel(parcel: Parcel): CameraCapture = CameraCapture(parcel)
+
+        override fun newArray(size: Int): Array<CameraCapture?> = arrayOfNulls(size)
     }
 
     fun toMap(): Map<String, Any?> = mapOf(
-        "recordings" to recordings?.map { it.toMap() },
+        "captures" to captures?.map { it.toMap() },
     )
 }
 
 /**
  * A class representing the result of a camera session.
  *
- * @property recording The result for the camera session in standard mode.
+ * @property capture The result for a photo, video, or mixed capture session.
  * @property metadata The associated metadata.
  */
 data class CameraResult(
-    val recording: CameraRecording?,
+    val capture: CameraCapture?,
     val metadata: Map<String, Any> = emptyMap(),
 ) : Parcelable {
     /**
@@ -59,19 +157,19 @@ data class CameraResult(
      * @param parcel The [Parcel].
      */
     constructor(parcel: Parcel) : this(
-        CameraRecording(parcel),
-        readMap(parcel),
+        capture = parcel.readParcelable(CameraCapture::class.java.classLoader),
+        metadata = readMap(parcel),
     )
-    constructor(record: ly.img.camera.core.CameraResult.Record) : this(
-        CameraRecording(record),
-        emptyMap(),
+    constructor(captures: CoreCameraResult.Captures) : this(
+        capture = CameraCapture(captures),
+        metadata = emptyMap(),
     )
 
     override fun writeToParcel(
         parcel: Parcel,
         flags: Int,
     ) {
-        recording?.writeToParcel(parcel, flags)
+        parcel.writeParcelable(capture, flags)
         writeMap(parcel, metadata, flags)
     }
 
@@ -110,7 +208,7 @@ data class CameraResult(
     }
 
     fun toMap(): Map<String, Any?> = mapOf(
-        "recording" to recording?.toMap(),
+        "capture" to capture?.toMap(),
         "metadata" to metadata,
     )
 }

package/android/src/main/kotlin/ly/img/camera/reactnative/module/model/CameraSettings.kt

@@ -2,24 +2,31 @@ package ly.img.camera.reactnative.module.model
 
 import android.os.Parcel
 import android.os.Parcelable
+import ly.img.camera.core.CaptureCount
+import ly.img.camera.core.CaptureType
+import kotlin.time.Duration.Companion.seconds
+import ly.img.camera.core.CameraConfiguration as NativeCameraConfiguration
 
 /**
  * A class containing all necessary information to configure the camera.
  *
  * @property license The license key. Pass `null` to run the SDK in evaluation mode with a watermark.
  * @property userId The id of the current user.
+ * @property configuration Optional [CameraConfiguration] controlling how the camera captures media.
  */
 data class CameraSettings(
     val license: String? = null,
     val userId: String?,
+    val configuration: CameraConfiguration? = null,
 ) : Parcelable {
     /**
      * Creates a new instance from a given [Parcel].
      * @param parcel The [Parcel].
      */
     constructor(parcel: Parcel) : this(
-        parcel.readString(),
-        parcel.readString(),
+        license = parcel.readString(),
+        userId = parcel.readString(),
+        configuration = parcel.readParcelable(CameraConfiguration::class.java.classLoader),
     )
 
     override fun writeToParcel(
@@ -28,6 +35,7 @@ data class CameraSettings(
     ) {
         parcel.writeString(license)
         parcel.writeString(userId)
+        parcel.writeParcelable(configuration, flags)
     }
 
     override fun describeContents(): Int = 0
@@ -40,7 +48,70 @@ data class CameraSettings(
         fun createFromMap(map: Map<String, Any?>): CameraSettings {
             val license = map["license"] as? String
             val userId = map["userId"] as? String
-            return CameraSettings(license, userId)
+            val configuration = (map["configuration"] as? Map<*, *>)?.let {
+                CameraConfiguration.createFromMap(it)
+            }
+            return CameraSettings(license, userId, configuration)
         }
     }
 }
+
+/**
+ * Capture configuration forwarded from the TS layer. String fields stay loose at the bridge
+ * boundary and are mapped to the native enums when building [NativeCameraConfiguration].
+ *
+ * @property captureType One of `"photo"`, `"video"`, `"mixed"` or `null` for the native default.
+ * @property captureCount One of `"single"`, `"multi"` or `null` for the native default.
+ * @property photoClipDuration Duration in seconds stamped on each photo capture.
+ */
+data class CameraConfiguration(
+    val captureType: String? = null,
+    val captureCount: String? = null,
+    val photoClipDuration: Double? = null,
+) : Parcelable {
+    constructor(parcel: Parcel) : this(
+        captureType = parcel.readString(),
+        captureCount = parcel.readString(),
+        photoClipDuration = parcel.readValue(Double::class.java.classLoader) as? Double,
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(captureType)
+        parcel.writeString(captureCount)
+        parcel.writeValue(photoClipDuration)
+    }
+
+    override fun describeContents(): Int = 0
+
+    /**
+     * Maps the wrapper configuration to a native [NativeCameraConfiguration]. Unset fields fall
+     * back to native defaults.
+     */
+    fun toNative(): NativeCameraConfiguration {
+        val defaults = NativeCameraConfiguration()
+        return NativeCameraConfiguration(
+            captureType = captureType?.let { type ->
+                CaptureType.entries.firstOrNull { it.name.equals(type, ignoreCase = true) }
+            } ?: defaults.captureType,
+            captureCount = captureCount?.let { count ->
+                CaptureCount.entries.firstOrNull { it.name.equals(count, ignoreCase = true) }
+            } ?: defaults.captureCount,
+            photoClipDuration = photoClipDuration?.seconds ?: defaults.photoClipDuration,
+        )
+    }
+
+    companion object CREATOR : Parcelable.Creator<CameraConfiguration> {
+        override fun createFromParcel(parcel: Parcel): CameraConfiguration = CameraConfiguration(parcel)
+
+        override fun newArray(size: Int): Array<CameraConfiguration?> = arrayOfNulls(size)
+
+        fun createFromMap(map: Map<*, *>) = CameraConfiguration(
+            captureType = map["captureType"] as? String,
+            captureCount = map["captureCount"] as? String,
+            photoClipDuration = (map["photoClipDuration"] as? Number)?.toDouble(),
+        )
+    }
+}

package/ios/IMGLYCameraModule.mm

@@ -6,7 +6,7 @@
 RCT_EXPORT_MODULE(IMGLYCamera)
 
 #ifdef RCT_NEW_ARCH_ENABLED
-- (void)openCamera:(JS::NativeIMGLYCamera::CameraSettings&)settings
+- (void)openCamera:(JS::NativeIMGLYCamera::SpecCameraSettings&)settings
              video:(NSString*)video
           metadata:(NSDictionary*)metadata
            resolve:(RCTPromiseResolveBlock)resolve
@@ -18,6 +18,20 @@ RCT_EXPORT_MODULE(IMGLYCamera)
   if (settings.userId() != nil) {
     convertedSettings[@"userId"] = settings.userId();
   }
+  auto configuration = settings.configuration();
+  if (configuration.has_value()) {
+    NSMutableDictionary* convertedConfiguration = [NSMutableDictionary dictionary];
+    if (configuration->captureType() != nil) {
+      convertedConfiguration[@"captureType"] = configuration->captureType();
+    }
+    if (configuration->captureCount() != nil) {
+      convertedConfiguration[@"captureCount"] = configuration->captureCount();
+    }
+    if (configuration->photoClipDuration().has_value()) {
+      convertedConfiguration[@"photoClipDuration"] = @(*configuration->photoClipDuration());
+    }
+    convertedSettings[@"configuration"] = convertedConfiguration;
+  }
   [self open:convertedSettings video:video metadata:metadata resolve:resolve reject:reject];
 }
 

package/ios/Model/CameraBuilder.swift

@@ -50,7 +50,36 @@ extension CameraBuilder {
   /// - Parameter settings: The `CameraSettings`.
   /// - Returns: The derived `EngineSettings`.
   private static func engineSettings(for settings: CameraSettings) -> EngineSettings {
-    EngineSettings(license: settings.license, userID: settings.userId)
+    // Identify this engine as React-Native-hosted so v4 licenses scoped to
+    // `host: react-native` validate. Hardcoded (not customer-configurable).
+    EngineSettings(license: settings.license, userID: settings.userId, host: "react-native")
+  }
+
+  /// Builds a native `IMGLYCamera.CameraConfiguration` from the bridged config dict.
+  /// Missing or unknown fields fall back to the native defaults.
+  private static func nativeConfiguration(
+    from configuration: CameraConfiguration?,
+  ) -> IMGLYCamera.CameraConfiguration {
+    IMGLYCamera.CameraConfiguration(
+      captureType: nativeCaptureType(configuration?.captureType),
+      captureCount: nativeCaptureCount(configuration?.captureCount),
+      photoClipDuration: configuration?.photoClipDuration ?? 5,
+    )
+  }
+
+  private static func nativeCaptureType(_ raw: String?) -> IMGLYCamera.CaptureType {
+    switch raw {
+    case "photo": .photo
+    case "mixed": .mixed
+    default: .video
+    }
+  }
+
+  private static func nativeCaptureCount(_ raw: String?) -> IMGLYCamera.CaptureCount {
+    switch raw {
+    case "single": .single
+    default: .multi
+    }
   }
 
   /// A modal camera implementation.
@@ -58,21 +87,23 @@ extension CameraBuilder {
     private let settings: CameraSettings
     private let result: CameraBuilderResult
     private let url: URL?
+    private let config: IMGLYCamera.CameraConfiguration
     private let onDismiss: (Result<IMGLYCamera.CameraResult, CameraError>) -> Void
 
     public init(settings: CameraSettings, result: @escaping CameraBuilderResult, url: URL? = nil) {
       self.settings = settings
       self.result = result
       self.url = url
+      config = CameraBuilder.nativeConfiguration(from: settings.configuration)
 
       onDismiss = { cameraResult in
         switch cameraResult {
         case let .success(.reaction(video: recording, reaction: reaction)):
           let reaction = CameraReaction(video: recording, recordings: reaction)
           result(.success(CameraResult(reaction: reaction)))
-        case let .success(.recording(recording)):
-          let recording = CameraRecording(recordings: recording)
-          result(.success(CameraResult(recording: recording)))
+        case let .success(.capture(captures)):
+          let capture = CameraCapture(captures: captures)
+          result(.success(CameraResult(capture: capture)))
         case let .failure(error):
           result(.failure(error))
         }
@@ -83,11 +114,12 @@ extension CameraBuilder {
       if let url {
         Camera(
           engineSettings(for: settings),
+          config: config,
           mode: .reaction(.horizontal, video: url, positionsSwapped: false),
           onDismiss: onDismiss,
         )
       } else {
-        Camera(engineSettings(for: settings), onDismiss: onDismiss)
+        Camera(engineSettings(for: settings), config: config, onDismiss: onDismiss)
       }
     }
   }

package/ios/Model/CameraResult.swift

@@ -1,33 +1,5 @@
 import IMGLYCamera
 
-/// The result type for a camera recording session in standard or dual camera mode.
-@objc @objcMembers public class CameraRecording: NSObject {
-  /// The recorded videos.
-  public let recordings: [Recording]
-
-  /// Creates a new `CameraResult` from the `IMGLYCamera` result types.
-  /// - Parameters:
-  ///   - recordings: The recorded `IMGLYCamera.Recording` videos.
-  public convenience init(recordings: [IMGLYCamera.Recording]) {
-    self.init(
-      recordings: recordings.compactMap { Recording(recording: $0) },
-    )
-  }
-
-  /// Creates a new `CameraResult`.
-  /// - Parameters:
-  ///   - recordings: The recorded videos.
-  public init(recordings: [Recording]) {
-    self.recordings = recordings
-  }
-
-  func toDictionary() -> [String: Any] {
-    [
-      "recordings": recordings.compactMap { $0.toDictionary() },
-    ]
-  }
-}
-
 /// The result type for a camera reaction session.
 @objc @objcMembers public class CameraReaction: NSObject {
   /// The video that was reacted to.
@@ -64,50 +36,186 @@ import IMGLYCamera
   }
 }
 
+/// The result type for a camera capture session producing photos, videos, or both.
+@objc @objcMembers public class CameraCapture: NSObject {
+  /// The individual captures from the session.
+  public let captures: [Capture]
+
+  /// Creates a new `CameraCapture` from the `IMGLYCamera` result types.
+  /// - Parameter captures: The `IMGLYCamera.Capture` items.
+  public convenience init(captures: [IMGLYCamera.Capture]) {
+    self.init(captures: captures.map { Capture(capture: $0) })
+  }
+
+  /// Creates a new `CameraCapture` instance.
+  /// - Parameter captures: The captures from the session.
+  public init(captures: [Capture]) {
+    self.captures = captures
+  }
+
+  func toDictionary() -> [String: Any] {
+    [
+      "captures": captures.map { $0.toDictionary() },
+    ]
+  }
+}
+
+/// A single capture from the camera. Either a still photo or a video recording.
+@objc @objcMembers public class Capture: NSObject {
+  /// The captured still photo, when this is a photo capture.
+  public let photo: Photo?
+
+  /// The video recording, when this is a video capture.
+  public let video: Recording?
+
+  /// Creates a new photo `Capture`.
+  public convenience init(photo: Photo) {
+    self.init(photo: photo, video: nil)
+  }
+
+  /// Creates a new video `Capture`.
+  public convenience init(video: Recording) {
+    self.init(photo: nil, video: video)
+  }
+
+  /// Creates a new `Capture` from the `IMGLYCamera.Capture` enum.
+  public convenience init(capture: IMGLYCamera.Capture) {
+    switch capture {
+    case let .photo(photo):
+      self.init(photo: Photo(photo: photo))
+    case let .video(recording):
+      self.init(video: Recording(recording: recording))
+    }
+  }
+
+  private init(photo: Photo?, video: Recording?) {
+    self.photo = photo
+    self.video = video
+  }
+
+  func toDictionary() -> [String: Any] {
+    var dictionary: [String: Any] = [:]
+    if let photo {
+      dictionary["photo"] = photo.toDictionary()
+    }
+    if let video {
+      dictionary["video"] = video.toDictionary()
+    }
+    return dictionary
+  }
+}
+
+/// A captured still photo. Contains one image in standard mode or two stacked images in dual camera mode.
+@objc @objcMembers public class Photo: NSObject {
+  /// The individual image(s) of the photo capture.
+  public let images: [PhotoImage]
+
+  /// The duration in seconds stamped on the photo.
+  public let duration: Double
+
+  /// Creates a new `Photo`.
+  /// - Parameters:
+  ///   - images: The individual image(s) of the photo capture.
+  ///   - duration: The duration in seconds stamped on the photo.
+  public init(images: [PhotoImage], duration: Double) {
+    self.images = images
+    self.duration = duration
+  }
+
+  /// Creates a new `Photo` from an `IMGLYCamera.Photo`.
+  public convenience init(photo: IMGLYCamera.Photo) {
+    self.init(
+      images: photo.images.map { PhotoImage(image: $0) },
+      duration: photo.duration.seconds,
+    )
+  }
+
+  func toDictionary() -> [String: Any] {
+    [
+      "images": images.map { $0.toDictionary() },
+      "duration": duration,
+    ]
+  }
+}
+
+/// A single image inside a photo capture.
+@objc @objcMembers public class PhotoImage: NSObject {
+  /// The `URL` to the source of the image.
+  public let url: URL
+
+  /// The position and size of the image inside the dual-camera layout.
+  public let rect: CGRect
+
+  /// Creates a new `PhotoImage`.
+  public init(url: URL, rect: CGRect) {
+    self.url = url
+    self.rect = rect
+  }
+
+  /// Creates a new `PhotoImage` from an `IMGLYCamera.Photo.Image`.
+  public convenience init(image: IMGLYCamera.Photo.Image) {
+    self.init(url: image.url, rect: image.rect)
+  }
+
+  func toDictionary() -> [String: Any] {
+    [
+      "uri": url.absoluteString,
+      "rect": [
+        "x": rect.origin.x,
+        "y": rect.origin.y,
+        "width": Double(rect.width),
+        "height": Double(rect.height),
+      ],
+    ]
+  }
+}
+
 /// The result of a camera session.
 @objc @objcMembers public class CameraResult: NSObject {
-  /// The video that was reacted to.
-  public let recording: CameraRecording?
-
-  /// The recorded videos.
+  /// The reaction session result.
   public let reaction: CameraReaction?
 
+  /// The capture result for a photo, video, or mixed session.
+  public let capture: CameraCapture?
+
   /// The associated metadata.
   public let metadata: [String: Any]
 
   /// Creates a new `CameraResult`.
   /// - Parameters:
-  ///   - video: The video that was reacted to.
-  ///   - recordings: The recorded videos.
+  ///   - reaction: The reaction session result.
   ///   - metadata: The associated metadata.
-  public convenience init(recording: CameraRecording, metadata: [String: Any] = [:]) {
-    self.init(recording: recording, reaction: nil, metadata: metadata)
+  public convenience init(reaction: CameraReaction, metadata: [String: Any] = [:]) {
+    self.init(reaction: reaction, capture: nil, metadata: metadata)
   }
 
-  /// Creates a new `CameraResult` from the `IMGLYCamera` result types.
+  /// Creates a new `CameraResult`.
   /// - Parameters:
-  ///   - video: The `IMGLYCamera.Recording` video that was reacted to.
-  ///   - recordings: The recorded `IMGLYCamera.Recording` videos.
+  ///   - capture: The capture session result.
   ///   - metadata: The associated metadata.
-  public convenience init(reaction: CameraReaction, metadata: [String: Any] = [:]) {
-    self.init(recording: nil, reaction: reaction, metadata: metadata)
+  public convenience init(capture: CameraCapture, metadata: [String: Any] = [:]) {
+    self.init(reaction: nil, capture: capture, metadata: metadata)
   }
 
-  private init(recording: CameraRecording?, reaction: CameraReaction?, metadata: [String: Any] = [:]) {
-    self.recording = recording
+  private init(
+    reaction: CameraReaction?,
+    capture: CameraCapture?,
+    metadata: [String: Any] = [:],
+  ) {
     self.reaction = reaction
+    self.capture = capture
     self.metadata = metadata
   }
 
   /// Converts the instance to a dictionary.
   public func toDictionary() -> [String: Any] {
     var dictionary: [String: Any] = ["metadata": metadata]
-    if let recording {
-      dictionary["recording"] = recording.toDictionary()
-    }
     if let reaction {
       dictionary["reaction"] = reaction.toDictionary()
     }
+    if let capture {
+      dictionary["capture"] = capture.toDictionary()
+    }
     return dictionary
   }
 }
@@ -117,13 +225,13 @@ import IMGLYCamera
   /// The individual video sections.
   public let videos: [Video]
 
-  /// The duration in milliseconds.
+  /// The duration in seconds.
   public let duration: Double
 
   /// Creates a new `Recording` instance.
   /// - Parameters:
   ///   - videos: The individual video sections.
-  ///   - duration: The duration in milliseconds.
+  ///   - duration: The duration in seconds.
   public init(videos: [Video], duration: Double) {
     self.videos = videos
     self.duration = duration

package/ios/Model/CameraSettings.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 /// A struct containing all necessary settings to setup the camera.
 @objc @objcMembers public class CameraSettings: NSObject, Codable {
   /// The license key. Pass `nil` to run the SDK in evaluation mode with a watermark.
@@ -6,6 +8,9 @@
   /// The id of the current user.
   public let userId: String?
 
+  /// Optional camera configuration. When `nil`, native defaults apply.
+  public let configuration: CameraConfiguration?
+
   /// Creates a new instance from a given dictionary.
   ///
   /// - Parameters:
@@ -22,3 +27,15 @@
     }
   }
 }
+
+/// Camera configuration options forwarded from the TypeScript layer.
+@objc @objcMembers public class CameraConfiguration: NSObject, Codable {
+  /// The kind of media the camera captures (`"photo"`, `"video"`, `"mixed"`).
+  public let captureType: String?
+
+  /// How many captures the session produces (`"single"`, `"multi"`).
+  public let captureCount: String?
+
+  /// The duration in seconds stamped on each captured photo.
+  public let photoClipDuration: Double?
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imgly/camera-react-native",
-  "version": "1.76.0",
+  "version": "1.77.0",
   "description": "Camera SDK for React Native - provide a versatile video camera to your users on iOS and Android.",
   "react-native": "index.js",
   "source": "index.js",

package/src/NativeIMGLYCamera.ts

@@ -8,7 +8,7 @@ export interface Recording {
   /** The individual videos of the recording. */
   videos: Video[];
 
-  /** The overall duration in milliseconds. */
+  /** The overall duration in seconds. */
   duration: number;
 }
 
@@ -46,10 +46,81 @@ export interface Rect {
   height: number;
 }
 
-/** The result for a default camera recording session. */
-interface CameraRecording {
-  /** The recorded videos. */
-  recordings: Recording[];
+/** A captured still photo. Contains one image in standard mode or two stacked images in dual camera mode. */
+export interface Photo {
+  /** The individual image(s) of the photo capture. */
+  images: PhotoImage[];
+
+  /**
+   * The duration stamped on the photo, in seconds.
+   * Note: the Flutter bridge passes this value in milliseconds instead.
+   */
+  duration: number;
+}
+
+/** A single image inside a photo capture. */
+export interface PhotoImage {
+  /**
+   * A url to the photo file that is stored
+   * in a temporary location.
+   */
+  uri: string;
+
+  /**
+   * A rect that contains the position of
+   * the image inside the dual-camera layout
+   * (iOS only).
+   */
+  rect: Rect;
+}
+
+/**
+ * A single capture from the camera. Either a still
+ * photo or a video recording.
+ */
+export interface Capture {
+  /** The captured still photo, when this is a photo capture. */
+  photo?: Photo;
+
+  /** The video recording, when this is a video capture. */
+  video?: Recording;
+}
+
+/** The kind of media the camera captures. */
+export type CaptureType = 'photo' | 'video' | 'mixed';
+
+/** How many captures the camera session produces. */
+export type CaptureCount = 'single' | 'multi';
+
+/**
+ * Configuration options that control how the camera captures media.
+ * All fields are optional; missing values fall back to native defaults
+ * (`video`, `multi`, `5` seconds).
+ */
+export interface CameraConfiguration {
+  /** The kind of media the camera captures. */
+  captureType?: CaptureType;
+
+  /** How many captures the camera session produces. */
+  captureCount?: CaptureCount;
+
+  /** The duration in seconds stamped on each captured photo. */
+  photoClipDuration?: number;
+}
+
+/**
+ * Spec-level shape for the configuration field.
+ *
+ * The native turbo-module codegen does not support string literal unions
+ * inside nested struct fields, so the Spec sees this looser variant with
+ * plain strings while customers still author against the strict
+ * `CameraConfiguration` above. The literal types narrow it correctly at
+ * the call site through subtype assignability.
+ */
+interface SpecCameraConfiguration {
+  captureType?: string;
+  captureCount?: string;
+  photoClipDuration?: number;
 }
 
 /** The result for a reaction camera recording session. */
@@ -61,14 +132,20 @@ interface CameraReaction {
   recordings: Recording[];
 }
 
+/** The result for a photo, video, or mixed camera capture session. */
+interface CameraCapture {
+  /** The individual captures from the session. */
+  captures: Capture[];
+}
+
 /** The result of a camera session. */
 interface CameraResult {
-  /** The video that was reacted to (iOS only). */
-  recording?: CameraRecording;
-
-  /** The recorded videos. */
+  /** The reaction result for a reaction camera session (iOS only). */
   reaction?: CameraReaction;
 
+  /** The capture result for a photo, video, or mixed camera session. */
+  capture?: CameraCapture;
+
   /** The associated metadata. */
   metadata: { [key: string]: unknown };
 }
@@ -84,6 +161,22 @@ export interface CameraSettings {
    * active users (MAU).
    */
   userId?: string;
+
+  /**
+   * Optional camera configuration. When omitted,
+   * native defaults apply.
+   */
+  configuration?: CameraConfiguration;
+}
+
+/**
+ * Spec-level shape for `CameraSettings`. See `SpecCameraConfiguration`
+ * for the reason this exists alongside the public `CameraSettings`.
+ */
+interface SpecCameraSettings {
+  license?: string;
+  userId?: string;
+  configuration?: SpecCameraConfiguration;
 }
 
 /** TurboModule Spec. */
@@ -95,7 +188,7 @@ interface Spec extends TurboModule {
    * @param metadata The metadata to pass to the native module.
    */
   openCamera(
-    settings: CameraSettings,
+    settings: SpecCameraSettings,
     video?: string,
     metadata?: { [key: string]: unknown }
   ): Promise<CameraResult | null>;
@@ -106,15 +199,6 @@ const NativeModule = TurboModuleRegistry.get<Spec>(
   'IMGLYCamera'
 ) as Spec | null;
 
-/** The result for a default camera recording session. */
-export interface CameraRecordingResult {
-  /** The recorded videos. */
-  recordings: Recording[];
-
-  /** The associated metadata. */
-  metadata: { [key: string]: unknown };
-}
-
 /** The result for a reaction camera recording session. */
 export interface CameraReactionResult {
   /** The video that was reacted to (iOS only). */
@@ -127,8 +211,37 @@ export interface CameraReactionResult {
   metadata: { [key: string]: unknown };
 }
 
+/** The result for a photo, video, or mixed camera capture session. */
+export interface CameraCaptureResult {
+  /** The individual captures from the session. */
+  captures: Capture[];
+
+  /** The associated metadata. */
+  metadata: { [key: string]: unknown };
+}
+
 /** The IMG.LY Camera. */
 class IMGLYCamera {
+  /**
+   * Opens the camera in photo or mixed capture mode.
+   *
+   * Returns a `CameraCaptureResult` with photos, videos, or both, depending
+   * on the configured `captureType`.
+   *
+   * @param settings - Configuration settings for the camera. Must include
+   *   a `configuration` with `captureType: 'photo'` or `'mixed'`.
+   * @param metadata - Optional metadata to pass to the native module.
+   * @returns A promise that resolves to the capture result, or null if cancelled.
+   */
+  static async openCamera(
+    settings: CameraSettings & {
+      configuration: CameraConfiguration & {
+        captureType: 'photo' | 'mixed';
+      };
+    },
+    metadata?: { [key: string]: unknown }
+  ): Promise<CameraCaptureResult | null>;
+
   /**
    * Opens the camera for reaction mode (iOS only).
    * @param settings - Configuration settings for the camera.
@@ -143,28 +256,28 @@ class IMGLYCamera {
   ): Promise<CameraReactionResult | null>;
 
   /**
-   * Opens the standard camera.
+   * Opens the standard video camera.
    * @param settings - Configuration settings for the camera.
    * @param metadata - Optional metadata to pass to the native module.
-   * @returns A promise that resolves to the recording result, or null if cancelled.
+   * @returns A promise that resolves to the capture result, or null if cancelled.
    */
   static async openCamera(
     settings: CameraSettings,
     metadata?: { [key: string]: unknown }
-  ): Promise<CameraRecordingResult | null>;
+  ): Promise<CameraCaptureResult | null>;
 
   /**
    * Opens the camera with the specified settings and optional video or metadata.
    * @param settings - Configuration settings for the camera.
    * @param video - Optional video input to trigger reactions (iOS only) or metadata object.
    * @param metadata - Optional metadata to pass to the native module.
-   * @returns A promise that resolves to either the recording result, reaction result, or null if unsuccessful.
+   * @returns A promise that resolves to a recording, reaction, or capture result, or null if unsuccessful.
    */
   static async openCamera(
     settings: CameraSettings,
     video?: string | { [key: string]: unknown },
     metadata: { [key: string]: unknown } = {}
-  ): Promise<CameraRecordingResult | CameraReactionResult | null> {
+  ): Promise<CameraReactionResult | CameraCaptureResult | null> {
     if (!NativeModule) return null;
     const videoInput = typeof video === 'string' ? video : undefined;
     const metadataInput =
@@ -178,9 +291,9 @@ class IMGLYCamera {
       const { video, recordings } = result.reaction;
       return { video, recordings, metadata: result.metadata };
     }
-    if (result?.recording) {
+    if (result?.capture) {
       return {
-        recordings: result.recording.recordings,
+        captures: result.capture.captures,
         metadata: result.metadata
       };
     }