@imgly/camera-react-native 1.40.0

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

@@ -0,0 +1,118 @@
+package ly.img.camera.reactnative.module.model
+
+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
+
+/**
+ * The result type for a camera recording session in standard mode.
+ *
+ * @property recordings The recordings of the camera session.
+ */
+data class CameraRecording(
+    val recordings: List<Recording>?,
+) : Parcelable {
+    /**
+     * Creates a new instance from a given [Parcel].
+     * @param parcel The [Parcel].
+     */
+    constructor(parcel: Parcel) : this(
+        parcel.createTypedArrayList(Recording),
+    )
+    constructor(record: ly.img.camera.core.CameraResult.Record) : this(
+        record.recordings.map { Recording(it) },
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeTypedList(recordings)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<CameraResult> {
+        override fun createFromParcel(parcel: Parcel): CameraResult = CameraResult(parcel)
+
+        override fun newArray(size: Int): Array<CameraResult?> = arrayOfNulls(size)
+    }
+
+    fun toMap(): Map<String, Any?> =
+        mapOf(
+            "recordings" to recordings?.map { it.toMap() },
+        )
+}
+
+/**
+ * A class representing the result of a camera session.
+ *
+ * @property recording The result for the camera session in standard mode.
+ * @property metadata The associated metadata.
+ */
+data class CameraResult(
+    val recording: CameraRecording?,
+    val metadata: Map<String, Any> = emptyMap(),
+) : Parcelable {
+    /**
+     * Creates a new instance from a given [Parcel].
+     * @param parcel The [Parcel].
+     */
+    constructor(parcel: Parcel) : this(
+        CameraRecording(parcel),
+        readMap(parcel),
+    )
+    constructor(record: ly.img.camera.core.CameraResult.Record) : this(
+        CameraRecording(record),
+        emptyMap(),
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        recording?.writeToParcel(parcel, flags)
+        writeMap(parcel, metadata, flags)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<CameraResult> {
+        override fun createFromParcel(parcel: Parcel): CameraResult = CameraResult(parcel)
+
+        override fun newArray(size: Int): Array<CameraResult?> = arrayOfNulls(size)
+
+        private fun writeMap(
+            parcel: Parcel,
+            map: Map<String, Any>,
+            flags: Int,
+        ) {
+            parcel.writeInt(map.size)
+            for ((key, value) in map) {
+                parcel.writeString(key)
+                parcel.writeValue(value)
+            }
+        }
+
+        private fun readMap(parcel: Parcel): Map<String, Any> {
+            val size = parcel.readInt()
+            val map = mutableMapOf<String, Any>()
+            repeat(size) {
+                val key = parcel.readString()
+                val value = parcel.readValue(this::class.java.classLoader)
+                key ?: throw (IllegalStateException("Key must not be null."))
+                value ?: throw (IllegalStateException("Value must not be null."))
+
+                map[key] = value
+            }
+            return map
+        }
+    }
+
+    fun toMap(): Map<String, Any?> =
+        mapOf(
+            "recording" to recording?.toMap(),
+            "metadata" to metadata,
+        )
+}

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

@@ -0,0 +1,46 @@
+package ly.img.camera.reactnative.module.model
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/**
+ * A class containing all necessary information to configure the camera.
+ *
+ * @property license The license key.
+ * @property userId The id of the current user.
+ */
+data class CameraSettings(
+    val license: String,
+    val userId: String?,
+) : Parcelable {
+    /**
+     * Creates a new instance from a given [Parcel].
+     * @param parcel The [Parcel].
+     */
+    constructor(parcel: Parcel) : this(
+        parcel.readString() ?: throw (Exception("Missing value for key 'license.'")),
+        parcel.readString(),
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(license)
+        parcel.writeString(userId)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<CameraSettings> {
+        override fun createFromParcel(parcel: Parcel): CameraSettings = CameraSettings(parcel)
+
+        override fun newArray(size: Int): Array<CameraSettings?> = arrayOfNulls(size)
+
+        fun createFromMap(map: Map<String, Any>): CameraSettings {
+            val license = map["license"] as? String ?: throw (Exception("Missing value for key 'license.'"))
+            val userId = map["userId"] as? String
+            return CameraSettings(license, userId)
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+package ly.img.camera.reactnative.module.model
+
+import android.net.Uri
+import android.os.Parcel
+import android.os.Parcelable
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * A camera recording.
+ *
+ * @property videos contains one or two [Video]s, for single camera output or dual camera output respectively
+ * @property duration the duration of the recording
+ */
+data class Recording(
+    val videos: List<Video>,
+    val duration: Duration,
+) : Parcelable {
+    constructor(parcel: Parcel) : this(
+        videos = parcel.createTypedArrayList(Video)!!,
+        duration = parcel.readLong().milliseconds,
+    )
+    constructor(recording: ly.img.camera.core.Recording) : this(
+        recording.videos.map { Video(it) },
+        recording.duration,
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeTypedList(videos)
+        parcel.writeLong(duration.inWholeMilliseconds)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<Recording> {
+        override fun createFromParcel(parcel: Parcel): Recording = Recording(parcel)
+
+        override fun newArray(size: Int): Array<Recording?> = arrayOfNulls(size)
+    }
+
+    fun toMap(): Map<String, Any?> =
+        mapOf(
+            "videos" to videos.map { it.toMap() },
+            "duration" to duration.inWholeMilliseconds.toDouble(),
+        )
+}
+
+/**
+ * A video in a [Recording].
+ *
+ * @param uri the uri of the video
+ */
+data class Video(
+    val uri: Uri,
+) : Parcelable {
+    constructor(parcel: Parcel) : this(uri = parcel.readParcelable(Uri::class.java.classLoader)!!)
+    constructor(video: ly.img.camera.core.Video) : this(
+        video.uri,
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeParcelable(uri, flags)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<Video> {
+        override fun createFromParcel(parcel: Parcel): Video = Video(parcel)
+
+        override fun newArray(size: Int): Array<Video?> = arrayOfNulls(size)
+    }
+
+    fun toMap(): Map<String, Any?> =
+        mapOf(
+            "uri" to uri.toString(),
+        )
+}

package/android/src/newarch/IMGLYCameraModuleSpec.kt

@@ -0,0 +1,7 @@
+package ly.img.camera.reactnative.module
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class IMGLYCameraModuleSpec internal constructor(
+    reactContext: ReactApplicationContext,
+) : NativeIMGLYCameraSpec(reactContext)

package/android/src/oldarch/IMGLYEditorModuleSpec.kt

@@ -0,0 +1,17 @@
+package ly.img.camera.reactnative.module
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
+
+abstract class IMGLYCameraModuleSpec internal constructor(
+    context: ReactApplicationContext,
+) : ReactContextBaseJavaModule(context) {
+    abstract fun openCamera(
+        settings: ReadableMap?,
+        video: String?,
+        metadata: ReadableMap?,
+        promise: Promise?,
+    )
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/NativeIMGLYCamera';
+export { default } from './src/NativeIMGLYCamera';
+

package/index.js

@@ -0,0 +1,3 @@
+export * from './src/NativeIMGLYCamera';
+export { default } from './src/NativeIMGLYCamera';
+

package/ios/IMGLYCameraModule.h

@@ -0,0 +1,11 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <IMGLYCameraModuleSpec/IMGLYCameraModuleSpec.h>
+
+@interface IMGLYCameraModule : NSObject <NativeIMGLYCameraSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface IMGLYCameraModule : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/IMGLYCameraModule.mm

@@ -0,0 +1,61 @@
+#import "IMGLYCameraModule.h"
+#import "IMGLYCameraModule/IMGLYCameraModule-Swift.h"
+
+@implementation IMGLYCameraModule
+
+RCT_EXPORT_MODULE(IMGLYCamera)
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)openCamera:(JS::NativeIMGLYCamera::CameraSettings&)settings
+             video:(NSString*)video
+          metadata:(NSDictionary*)metadata
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  NSMutableDictionary* convertedSettings = [@{
+    @"license" : settings.license(),
+  } mutableCopy];
+  if (settings.userId() != nil) {
+    convertedSettings[@"userId"] = settings.userId();
+  }
+  [self open:convertedSettings video:video metadata:metadata resolve:resolve reject:reject];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+  (const facebook::react::ObjCTurboModule::InitParams&)params {
+  return std::make_shared<facebook::react::NativeIMGLYCameraSpecJSI>(params);
+}
+
+#else
+RCT_EXPORT_METHOD(openCamera
+                  : (nonnull NSDictionary*)settings video
+                  : (nullable NSString*)video metadata
+                  : (NSDictionary*)metadata resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject) {
+  [self open:settings video:video metadata:metadata resolve:resolve reject:reject];
+}
+#endif
+
+- (void)open:(nonnull NSDictionary*)settings
+       video:(nullable NSString*)video
+    metadata:(NSDictionary*)metadata
+     resolve:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject {
+  CameraSettings* cameraSettings = [CameraSettings fromDictionary:settings];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[IMGLYCameraModuleSwiftAdapter shared]
+      openCameraWithSettings:cameraSettings
+                       video:video
+                    metadata:metadata
+                  completion:^(CameraResult* _Nullable result, NSError* _Nullable error) {
+                    if (result != nil) {
+                      resolve([result toDictionary]);
+                    } else if (error != nil) {
+                      reject(@"E_RECORDING_FAILED", @"The recording failed due to: ", error);
+                    } else {
+                      resolve([NSNull null]);
+                    }
+                  }];
+  });
+}
+@end

package/ios/IMGLYCameraModule.swift

@@ -0,0 +1,70 @@
+import IMGLYCamera
+import UIKit
+
+/// The iOS implementation for the `@imgly/camera-react-native` native React Native module.
+@objc(IMGLYCameraModuleSwiftAdapter) @objcMembers public class IMGLYCameraModuleSwiftAdapter: NSObject {
+  // MARK: - Typealias
+
+  /// A closure to specify an `CameraBuilder.Builder` based on a given `metadata`.
+  public typealias CameraBuilderClosure = (_ metadata: [String: Any]?) -> CameraBuilder.Builder
+
+  // MARK: - Properties
+
+  /// The shared instance.
+  public static var shared = IMGLYCameraModuleSwiftAdapter()
+
+  /// The `CameraBuilderClosure` to use for UI creation.
+  public var cameraBuilderClosure: CameraBuilderClosure?
+
+  /// The `UIViewController` hosting the editor.
+  private var presentationController: UIViewController?
+
+  /// Opens the camera.
+  /// - Parameters:
+  ///   - settings: The `CameraSettings` containing all relevant information for the editor.
+  ///   - video: The source of the video to react to.
+  ///   - metadata: Any custom metadata used for the `CameraBuilder.Builder`.
+  ///   - completion: The completion handler to execute once the camera failed, cancelled or exported.
+  public func openCamera(
+    settings: CameraSettings,
+    video: String?,
+    metadata: [String: Any]?,
+    completion: @escaping (_ result: CameraResult?, _ error: NSError?) -> Void
+  ) {
+    var videoURL: URL?
+    if let video {
+      if let sourceUrl = URL(string: video), sourceUrl.scheme != nil {
+        videoURL = sourceUrl
+      } else {
+        completion(nil, nil)
+      }
+    }
+
+    let builder = cameraBuilderClosure?(metadata) ?? CameraBuilder.default()
+    presentationController = builder(settings, videoURL, metadata) { [weak self] result in
+      DispatchQueue.main.async {
+        switch result {
+        case let .success(artifact):
+          completion(artifact, nil)
+        case let .failure(error):
+          switch error {
+          case CameraError.cancelled:
+            completion(nil, nil)
+          default:
+            completion(nil, error as NSError)
+          }
+        }
+        self?.presentationController?.presentingViewController?.dismiss(animated: true)
+      }
+    }
+    presentationController?.modalPresentationStyle = .fullScreen
+    if let presentationController, let windowScene = UIApplication.shared.connectedScenes
+      .filter({ $0.activationState == .foregroundActive })
+      .first as? UIWindowScene {
+      if let rootViewController = windowScene.windows
+        .filter(\.isKeyWindow).first?.rootViewController {
+        rootViewController.present(presentationController, animated: true, completion: nil)
+      }
+    }
+  }
+}

package/ios/Model/CameraBuilder.swift

@@ -0,0 +1,94 @@
+import IMGLYCamera
+import SwiftUI
+
+public enum CameraBuilder {
+  /// A closure used to return a `Result<CameraResult?, Error>` from the camera.
+  public typealias CameraBuilderResult = (Result<CameraResult?, Error>) -> Void
+
+  /// Closure allowing to return a custom UI based on various input.
+  /// - Parameters:
+  ///   - settings: The `CameraSettings`.
+  ///   - url: The `URL` of the video to react to.
+  ///   - metadata: The metadata.
+  ///   - result: The `CameraBuilderResult` used to return a result.
+  /// - Returns: A `UIViewController`.
+  public typealias Builder = (
+    _ settings: CameraSettings,
+    _ url: URL?,
+    _ metadata: [String: Any]?,
+    _ result: @escaping CameraBuilderResult
+  ) -> UIViewController
+
+  /// The default camera implementation.
+  public static func `default`() -> Builder {
+    { settings, url, _, result in
+      @ViewBuilder func camera(settings: CameraSettings, result: @escaping CameraBuilderResult) -> some View {
+        ModalCamera(settings: settings, result: result, url: url)
+      }
+      return UIHostingController(rootView: camera(settings: settings, result: result))
+    }
+  }
+
+  /// A custom camera implementation.
+  /// - Parameter contentProvider: Used to provide a custom view.
+  /// - Returns: A `Builder` providing the custom view.
+  public static func custom(_ contentProvider: @escaping (
+    _ settings: CameraSettings,
+    _ url: URL?,
+    _ metadata: [String: Any]?,
+    _ result: @escaping CameraBuilderResult
+  ) -> some View) -> Builder {
+    { settings, preset, metadata, result in
+      let hostingController = UIHostingController(rootView: contentProvider(settings, preset, metadata, result))
+      return hostingController
+    }
+  }
+}
+
+extension CameraBuilder {
+  /// Generates `EngineSettings` based on an `CameraSettings`.
+  /// - Parameter settings: The `CameraSettings`.
+  /// - Returns: The derived `EngineSettings`.
+  private static func engineSettings(for settings: CameraSettings) -> EngineSettings {
+    EngineSettings(license: settings.license, userID: settings.userId)
+  }
+
+  /// A modal camera implementation.
+  public struct ModalCamera: View {
+    private let settings: CameraSettings
+    private let result: CameraBuilderResult
+    private let url: URL?
+    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
+
+      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 .failure(error):
+          result(.failure(error))
+        }
+      }
+    }
+
+    public var body: some View {
+      if let url {
+        Camera(
+          engineSettings(for: settings),
+          mode: .reaction(.horizontal, video: url, positionsSwapped: false),
+          onDismiss: onDismiss
+        )
+      } else {
+        Camera(engineSettings(for: settings), onDismiss: onDismiss)
+      }
+    }
+  }
+}