@imgly/editor-react-native 1.40.0

package/android/src/main/kotlin/ly/img/editor/reactnative/module/model/EditorPreset.kt

@@ -0,0 +1,47 @@
+package ly.img.editor.reactnative.module.model
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/** An enum containing all prebuilt editor configurations. */
+enum class EditorPreset(
+    val value: String,
+) : Parcelable {
+    /** The apparel editor. */
+    APPAREL("apparel"),
+
+    /** The postcard editor. */
+    POSTCARD("postcard"),
+
+    /** The photo editor. */
+    PHOTO("photo"),
+
+    /** The design editor. */
+    DESIGN("design"),
+
+    /** The video editor. */
+    VIDEO("video"),
+    ;
+
+    override fun toString(): String = value
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(value)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<EditorPreset> {
+        override fun createFromParcel(parcel: Parcel): EditorPreset {
+            val value = parcel.readString()
+            return entries.find { it.value == value } ?: throw IllegalArgumentException("Invalid value for EditorPreset")
+        }
+
+        override fun newArray(size: Int): Array<EditorPreset?> = arrayOfNulls(size)
+
+        fun fromValue(value: String): EditorPreset? = entries.find { it.value == value }
+    }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/model/EditorResult.kt

@@ -0,0 +1,73 @@
+package ly.img.editor.reactnative.module.model
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/**
+ * A class representing the result of an editor export.
+ * @property scene The source of the exported scene.
+ * @property artifact The source of the exported artifact, e.g. image, video.
+ * @property thumbnail The source of the exported thumbnail.
+ * @property metadata The associated metadata.
+ */
+data class EditorResult(
+    val scene: String?,
+    val artifact: String?,
+    val thumbnail: String?,
+    val metadata: Map<String, Any> = emptyMap(),
+) : Parcelable {
+    /**
+     * Creates a new instance from a given [Parcel].
+     * @param parcel The [Parcel].
+     */
+    constructor(parcel: Parcel) : this(
+        parcel.readString(),
+        parcel.readString(),
+        parcel.readString(),
+        readMap(parcel),
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(scene)
+        parcel.writeString(artifact)
+        parcel.writeString(thumbnail)
+        writeMap(parcel, metadata, flags)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<EditorResult> {
+        override fun createFromParcel(parcel: Parcel): EditorResult = EditorResult(parcel)
+
+        override fun newArray(size: Int): Array<EditorResult?> = 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
+        }
+    }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/model/EditorSettings.kt

@@ -0,0 +1,63 @@
+package ly.img.editor.reactnative.module.model
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/**
+ * A class containing all necessary information to configure an editor.
+ * @property license The license key.
+ * @property baseUri The base uri for the assets included in the scene that have a relative source.
+ * @property assetBaseUri The base uri of the default assets in the asset library.
+ * @property userId The id of the current user.
+ * @property source The source to load into the editor.
+ */
+data class EditorSettings(
+    val license: String,
+    val baseUri: String,
+    val assetBaseUri: String?,
+    val userId: String?,
+    var source: Source?,
+) : 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() ?: throw (Exception("Missing value for key 'baseUri.'")),
+        parcel.readString(),
+        parcel.readString(),
+        parcel.readParcelable(Source::class.java.classLoader),
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(license)
+        parcel.writeString(baseUri)
+        parcel.writeString(assetBaseUri)
+        parcel.writeString(userId)
+        parcel.writeParcelable(source, flags)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<EditorSettings> {
+        override fun createFromParcel(parcel: Parcel): EditorSettings = EditorSettings(parcel)
+
+        override fun newArray(size: Int): Array<EditorSettings?> = arrayOfNulls(size)
+
+        fun createFromMap(map: Map<String, Any>): EditorSettings? =
+            try {
+                val license = map["license"] as? String ?: throw (Exception("Missing value for key 'license.'"))
+                val sceneBaseUri = map["sceneBaseUri"] as? String ?: throw (Exception("Missing value for key 'sceneBaseUri.'"))
+                val assetBaseUri = map["assetBaseUri"] as? String
+                val userId = map["userId"] as? String
+                val source = (map["source"] as? Map<String, Any>)?.let { Source.createFromMap(it) }
+                EditorSettings(license, sceneBaseUri, assetBaseUri, userId, source)
+            } catch (e: Exception) {
+                null
+            }
+    }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/model/EditorSourceType.kt

@@ -0,0 +1,39 @@
+package ly.img.editor.reactnative.module.model
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/** The *EditorSourceType* defines the type of source that is loaded into the editor. */
+enum class EditorSourceType(
+    val value: String,
+) : Parcelable {
+    /** A `.scene` file. */
+    SCENE("scene"),
+
+    /** An image file, e.g. `.png`. */
+    IMAGE("image"),
+
+    /** A video file, e.g. `.mp4`. */
+    VIDEO("video"),
+    ;
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(value)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<EditorSourceType> {
+        override fun createFromParcel(parcel: Parcel): EditorSourceType {
+            val value = parcel.readString()
+            return entries.find { it.value == value } ?: throw IllegalArgumentException("Invalid value for EditorSourceType")
+        }
+
+        override fun newArray(size: Int): Array<EditorSourceType?> = arrayOfNulls(size)
+
+        fun fromValue(value: String): EditorSourceType? = entries.find { it.value == value }
+    }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/model/Source.kt

@@ -0,0 +1,44 @@
+package ly.img.editor.reactnative.module.model
+
+import android.os.Parcel
+import android.os.Parcelable
+
+data class Source(
+    var source: String,
+    val type: EditorSourceType,
+) : Parcelable {
+    constructor(parcel: Parcel) : this(
+        parcel.readString() ?: throw (Exception("Missing value for key 'source'.")),
+        parcel.readParcelable(EditorSourceType::class.java.classLoader) ?: throw (Exception("Missing value for key 'type'.")),
+    )
+
+    override fun writeToParcel(
+        parcel: Parcel,
+        flags: Int,
+    ) {
+        parcel.writeString(source)
+        parcel.writeParcelable(type, flags)
+    }
+
+    override fun describeContents(): Int = 0
+
+    companion object CREATOR : Parcelable.Creator<Source> {
+        override fun createFromParcel(parcel: Parcel): Source = Source(parcel)
+
+        override fun newArray(size: Int): Array<Source?> = arrayOfNulls(size)
+
+        fun createFromMap(map: Map<String, Any>): Source? =
+            runCatching {
+                val source = map["source"] as? String
+                val typeRaw = map["type"] as? String
+
+                source?.let { s ->
+                    typeRaw?.let { t ->
+                        EditorSourceType.fromValue(t)?.let { type ->
+                            Source(s, type)
+                        }
+                    }
+                }
+            }.getOrNull()
+    }
+}

package/android/src/newarch/IMGLYEditorModuleSpec.kt

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

package/android/src/oldarch/IMGLYEditorModuleSpec.kt

@@ -0,0 +1,18 @@
+package ly.img.editor.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 IMGLYEditorModuleSpec internal constructor(
+    context: ReactApplicationContext,
+) : ReactContextBaseJavaModule(context) {
+    abstract fun openEditor(
+        settings: ReadableMap?,
+        source: ReadableMap?,
+        preset: String?,
+        metadata: ReadableMap?,
+        promise: Promise?,
+    )
+}

package/index.d.ts

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

package/index.js

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

package/ios/Constants/IMGLYConstants.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+@interface IMGLYConstants : NSObject
+
+// Error codes
+extern NSString* const IMGLYErrorExportFailed;
+extern NSString* const IMGLYErrorParsing;
+
+// Error messages
+extern NSString* const IMGLYErrorExportFailedMessage;
+extern NSString* const IMGLYErrorParsingMessage;
+
+@end

package/ios/Constants/IMGLYConstants.m

@@ -0,0 +1,13 @@
+#import "IMGLYConstants.h"
+
+@implementation IMGLYConstants
+
+// Error codes
+NSString* const IMGLYErrorExportFailed = @"E_EXPORT_FAILED";
+NSString* const IMGLYErrorParsing = @"E_PARSING";
+
+// Error messages
+NSString* const IMGLYErrorExportFailedMessage = @"The export of the asset failed due to: ";
+NSString* const IMGLYErrorParsingMessage = @"Unable to parse the argument(s): ";
+
+@end

package/ios/Extensions/OnCreate+.swift

@@ -0,0 +1,75 @@
+import Foundation
+import IMGLYEditor
+import IMGLYEngine
+
+/// An extension that provides convenience methods for `OnCreate` calls.
+extension OnCreate {
+  /// Populates the editor based on a given `config`, `sourceType` and `defaultScene`.
+  /// - Parameters:
+  ///   - settings: The `EditorSettings` containing the relevant editor information.
+  ///   - sourceType: The `EditorSourceType` defining of which type the source is.
+  ///   - defaultSource: The `URL` of the defaultScene if no `EditorSettings.source` is specified.
+  /// - Returns: An `OnCreate.Callback`.
+  @MainActor
+  public static func load(
+    _ settings: EditorSettings?,
+    _ sourceType: EditorSourceType = .scene,
+    defaultSource: URL? = nil
+  ) -> OnCreate.Callback {
+    { engine in
+      var url: URL?
+
+      if let source = settings?.source?.source {
+        if let sourceUrl = URL(string: source), sourceUrl.scheme != nil {
+          url = sourceUrl
+        } else {
+          throw "Specified URL is not valid."
+        }
+      } else if let defaultSource {
+        url = defaultSource
+      }
+
+      if let url {
+        switch settings?.source?.type ?? sourceType {
+        case .image:
+          try await engine.scene.create(fromImage: url)
+          let pages = try engine.scene.getPages()
+          let images = try engine.block.find(byType: .graphic)
+          guard let image = images.first, let page = pages.first else { throw "Scene could not be loaded." }
+          try engine.block.setFill(page, fill: engine.block.getFill(image))
+          try engine.block.destroy(image)
+        case .video:
+          try await engine.scene.create(fromVideo: url)
+        default:
+          try await engine.scene.load(from: url)
+        }
+      } else {
+        try await OnCreate.default(engine)
+      }
+
+      var assetUrl: URL?
+      if let assetBaseUri = settings?.assetBaseUri {
+        if let temp = URL(string: assetBaseUri), temp.scheme != nil {
+          assetUrl = temp
+        }
+      }
+      try await Self.loadDefaultAssets(baseURL: assetUrl)(engine)
+    }
+  }
+
+  /// Loads the default assets for the asset library.
+  /// - Parameter baseURL: The base `URL` from your CDN where the assets are hosted.
+  /// - Returns: A `Callback`.
+  static func loadDefaultAssets(baseURL: URL?) -> Callback {
+    { engine in
+      let baseURI = baseURL ?? Engine.assetBaseURL
+      try await engine.addDefaultAssetSources(baseURL: baseURI)
+      try await engine.addDemoAssetSources(
+        exclude: [.image, .video, .audio],
+        sceneMode: engine.scene.getMode(),
+        withUploadAssetSources: true
+      )
+      try await engine.asset.addSource(TextAssetSource(engine: engine))
+    }
+  }
+}

package/ios/Extensions/OnExport+.swift

@@ -0,0 +1,64 @@
+import Foundation
+import IMGLYEditor
+import IMGLYEngine
+
+/// An extension that provides convenience methods for `OnExport` calls.
+public extension OnExport {
+  /// Exports the asset to an `EditorResult`.
+  /// - Parameters:
+  ///   - engine: The `Engine` that should be used.
+  ///   - mimeType: The `MIMEType` of the exported artifact.
+  ///   - thumbnailHeight: The height of the generated thumbnail.
+  /// - Returns: A populates `EditorResult`.
+  @MainActor
+  static func export(_ engine: Engine, _ mimeType: MIMEType,
+                     _ thumbnailHeight: CGFloat = 100) async throws -> EditorResult {
+    let helper = ExportHelper()
+    let (data, type) = try await OnExport.export(engine, mimeType: mimeType)
+    let file = try helper.saveFile(data, type)
+    let scene = try await engine.scene.saveToString()
+    let localScene = try helper.saveScene(scene)
+
+    var thumbnail: URL?
+    if let firstPage = try engine.scene.getPages().first {
+      thumbnail = try await helper.saveThumbnail(firstPage, engine, thumbnailHeight)
+    }
+    return EditorResult(
+      scene: localScene?.absoluteString,
+      artifact: file.absoluteString,
+      thumbnail: thumbnail?.absoluteString
+    )
+  }
+
+  /// Exports a video to an `EditorResult`.
+  /// - Parameters:
+  ///   - engine: The `Engine` that should be used.
+  ///   - eventHandler: The `EditorEventHandler` used for event handling.
+  ///   - mimeType: The `MIMEType` of the exported artifact.
+  ///   - thumbnailHeight: The height of the generated thumbnail.
+  /// - Returns: A populates `EditorResult`.
+  @MainActor
+  static func exportVideo(
+    _ engine: Engine,
+    _ eventHandler: EditorEventHandler,
+    _ mimeType: MIMEType,
+    _ thumbnailHeight: CGFloat = 100
+  ) async throws -> EditorResult {
+    let helper = ExportHelper()
+    let (data, type) = try await OnExport.exportVideo(engine, eventHandler, mimeType: mimeType)
+    let file = try helper.saveFile(data, type)
+    let scene = try await engine.scene.saveToString()
+    let localScene = try helper.saveScene(scene)
+
+    var thumbnail: URL?
+    if let firstPage = try engine.scene.getPages().first {
+      thumbnail = try await helper.saveThumbnail(firstPage, engine, thumbnailHeight)
+    }
+    eventHandler.send(.exportCompleted {})
+    return EditorResult(
+      scene: localScene?.absoluteString,
+      artifact: file.absoluteString,
+      thumbnail: thumbnail?.absoluteString
+    )
+  }
+}

package/ios/Extensions/String+.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+/// An extension to allow throwing strings.
+extension String: LocalizedError {
+  /// The error description.
+  public var errorDescription: String? { self }
+}

package/ios/Helper/ExportHelper.swift

@@ -0,0 +1,67 @@
+import IMGLYEngine
+import UIKit
+import UniformTypeIdentifiers
+
+/// A helper class for exporting.
+@MainActor
+class ExportHelper {
+  /// Saves given `data` to a file.
+  /// - Parameters:
+  ///   - data: The data to save.
+  ///   - contentType: The `UTType` of the file.
+  /// - Returns: The file `URL`.
+  func saveFile(_ data: Data, _ contentType: UTType) throws -> URL {
+    let fileName = "cesdk_export_artifact_" + UUID().uuidString
+    let url = FileManager.default.temporaryDirectory.appendingPathComponent(fileName, conformingTo: contentType)
+    try data.write(to: url, options: [.atomic])
+    return url
+  }
+
+  /// Saves given scene string to a file.
+  /// - Parameter scene: The scene as a `String`.
+  /// - Returns: The file `URL`.
+  func saveScene(_ scene: String) throws -> URL? {
+    let fileName = "cesdk_export_scene_" + UUID().uuidString
+    let url = FileManager.default.temporaryDirectory.appendingPathComponent(fileName, conformingTo: .plainText)
+    if let data = scene.data(using: .utf8) {
+      try data.write(to: url, options: [.atomic])
+      return url
+    }
+    return nil
+  }
+
+  // MARK: - Thumbnails
+
+  /// Generates and saves a thumbnail for a given block.
+  /// - Parameters:
+  ///   - id: The `DesignBlockID` of the block.
+  ///   - engine: The `Engine` to use.
+  ///   - height: The height of the thumbnail.
+  /// - Returns: The `URL` to the thumbnail.
+  func saveThumbnail(_ id: DesignBlockID, _ engine: Engine, _ height: CGFloat) async throws -> URL {
+    let thumbnail = try await generateThumbnail(id, engine, height)
+    let fileName = "cesdk_export_thumbnail_" + UUID().uuidString
+    let url = FileManager.default.temporaryDirectory.appendingPathComponent(fileName, conformingTo: .png)
+    try thumbnail?.pngData()?.write(to: url, options: [.atomic])
+    return url
+  }
+
+  /// Generates a thumbnail for a given block.
+  /// - Parameters:
+  ///   - id: The `DesignBlockID` of the block.
+  ///   - engine: The `Engine` to use.
+  ///   - height: The height of the thumbnail.
+  /// - Returns: The thumbnail as an `UIImage`.
+  private func generateThumbnail(_ id: DesignBlockID, _ engine: Engine, _ height: CGFloat) async throws -> UIImage? {
+    let stream = engine.block.generateVideoThumbnailSequence(
+      id,
+      thumbnailHeight: Int(height * UIScreen.main.scale),
+      timeRange: 0 ... 0.1,
+      numberOfFrames: 1
+    )
+    for try await thumbnail in stream {
+      return .init(cgImage: thumbnail.image, scale: UIScreen.main.scale, orientation: .up)
+    }
+    return nil
+  }
+}

package/ios/IMGLYEditorModule-Bridging-Header.h

@@ -0,0 +1,3 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//

package/ios/IMGLYEditorModule.h

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

package/ios/IMGLYEditorModule.mm

@@ -0,0 +1,86 @@
+#import "IMGLYEditorModule.h"
+#import "IMGLYEditorModule/IMGLYEditorModule-Swift.h"
+#import "IMGLYConstants.h"
+
+@implementation IMGLYEditorModule
+
+RCT_EXPORT_MODULE(IMGLYEditor)
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)openEditor:(JS::NativeIMGLYEditor::EditorSettings&)settings
+            source:(JS::NativeIMGLYEditor::Source&)source
+            preset:(NSString*)preset
+          metadata:(NSDictionary*)metadata
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  NSMutableDictionary* mergedSettings = [@{
+    @"license" : settings.license(),
+    @"sceneBaseUri" : settings.sceneBaseUri(),
+  } mutableCopy];
+  if (settings.assetBaseUri() != nil) {
+    mergedSettings[@"assetBaseUri"] = settings.assetBaseUri();
+  }
+  if (settings.userId() != nil) {
+    mergedSettings[@"userId"] = settings.userId();
+  }
+
+  JS::NativeIMGLYEditor::Source* sourcePtr = &source;
+  if (sourcePtr != nullptr) {
+    mergedSettings[@"source"] = @{@"source" : source.source(), @"type" : source.type()};
+  }
+
+  [self open:mergedSettings preset:preset 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::NativeIMGLYEditorSpecJSI>(params);
+}
+#else
+RCT_EXPORT_METHOD(openEditor
+                  : (nonnull NSDictionary*)settings source
+                  : (nullable NSDictionary*)source preset
+                  : (NSString*)preset metadata
+                  : (NSDictionary*)metadata resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject) {
+  NSMutableDictionary* mergedSettings = [settings mutableCopy];
+  mergedSettings[@"source"] = source;
+  [self open:mergedSettings preset:preset metadata:metadata resolve:resolve reject:reject];
+}
+
+#endif
+
+- (void)open:(nonnull NSDictionary*)settings
+      preset:(NSString*)preset
+    metadata:(NSDictionary*)metadata
+     resolve:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject {
+  EditorSettings* convertedSettings = [EditorSettings fromDictionary:settings];
+  if (convertedSettings == nil) {
+    reject(IMGLYErrorParsing, IMGLYErrorParsingMessage, nil);
+    return;
+  }
+  EditorPreset convertedPreset = [EditorPresetParser fromString:preset];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [[IMGLYEditorModuleSwiftAdapter shared] openEditor:convertedPreset
+                                              settings:convertedSettings
+                                              metadata:metadata
+                                            completion:^(EditorResult* _Nullable result, NSError* _Nullable error) {
+                                              if (result != nil) {
+                                                resolve(@ {
+                                                  @"artifact" : result.artifact,
+                                                  @"scene" : result.scene,
+                                                  @"thumbnail" : result.thumbnail,
+                                                  @"metadata" : result.metadata
+                                                });
+                                              } else if (error != nil) {
+                                                reject(IMGLYErrorExportFailed, IMGLYErrorExportFailedMessage, error);
+                                              } else {
+                                                resolve([NSNull null]);
+                                              }
+                                            }];
+  });
+}
+
+@end