@imgly/editor-react-native 1.40.0

package/android/src/main/kotlin/ly/img/editor/reactnative/module/activity/EditorActivity.kt

@@ -0,0 +1,112 @@
+package ly.img.editor.reactnative.module.activity
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.os.Parcelable
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import ly.img.editor.reactnative.module.IMGLYEditorModule
+import ly.img.editor.reactnative.module.builder.Builder
+import ly.img.editor.reactnative.module.builder.CustomBuilderScope
+import ly.img.editor.reactnative.module.builder.EditorBuilder
+import ly.img.editor.reactnative.module.helper.IntentHelper
+import ly.img.editor.reactnative.module.model.EditorPreset
+import ly.img.editor.reactnative.module.model.EditorSettings
+import java.io.Serializable
+
+/** The [Activity] used to display the editor. */
+class EditorActivity : ComponentActivity() {
+    companion object {
+        /** The request code for this activity. */
+        var INTENT_REQUEST_CODE = 29055
+
+        /**
+         * The result code for this activity in
+         * case of an error.
+         */
+        var INTENT_RESULT_ERROR_CODE = 29056
+
+        /** The identifier to the config intent extra. */
+        const val INTENT_EXTRA_CONFIG = "intent_extra_config_cesdk"
+
+        /** The identifier to the preset intent extra. */
+        const val INTENT_EXTRA_PRESET = "intent_extra_preset_cesdk"
+
+        /** The identifier to the metadata intent extra. */
+        const val INTENT_EXTRA_METADATA = "intent_extra_metadata_cesdk"
+
+        /** The identifier to the result intent extra. */
+        const val INTENT_EXTRA_RESULT = "intent_extra_result_cesdk"
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val config =
+            intent.extras?.getParcelableCompat<EditorSettings>(INTENT_EXTRA_CONFIG)
+                ?: return
+        val preset = intent.extras?.getParcelableCompat<EditorPreset>(INTENT_EXTRA_PRESET) ?: EditorPreset.DESIGN
+        val metadataBundle = intent.extras?.getParcelableCompat<Bundle>(INTENT_EXTRA_METADATA)
+        val metadata = IntentHelper.bundleToMap(metadataBundle)
+        val builder: Builder = IMGLYEditorModule.builderClosure?.invoke(preset, metadata) ?: builderForPreset(preset)
+
+        setContent {
+            builder(
+                CustomBuilderScope(config, preset, metadata, { result ->
+                    val (resolvedResult, resultCode) =
+                        result.fold(
+                            onFailure = { error ->
+                                Pair(error, INTENT_RESULT_ERROR_CODE)
+                            },
+                            onSuccess = { value ->
+                                Pair(value, Activity.RESULT_OK)
+                            },
+                        )
+
+                    val resultIntent =
+                        Intent().apply {
+                            when (resultCode) {
+                                INTENT_RESULT_ERROR_CODE -> {
+                                    putExtra(INTENT_EXTRA_RESULT, resolvedResult as Serializable)
+                                }
+
+                                Activity.RESULT_OK -> {
+                                    putExtra(INTENT_EXTRA_RESULT, resolvedResult as Parcelable)
+                                }
+                            }
+                        }
+
+                    setResult(resultCode, resultIntent)
+                    finish()
+                }, {
+                    if (it != null) {
+                        val resultIntent =
+                            Intent().apply {
+                                putExtra(INTENT_EXTRA_RESULT, it)
+                            }
+                        setResult(INTENT_RESULT_ERROR_CODE, resultIntent)
+                    }
+                    finish()
+                }),
+            )
+        }
+    }
+
+    private fun builderForPreset(preset: EditorPreset): Builder =
+        when (preset) {
+            EditorPreset.APPAREL -> EditorBuilder.apparel()
+            EditorPreset.POSTCARD -> EditorBuilder.postcard()
+            EditorPreset.PHOTO -> EditorBuilder.photo()
+            EditorPreset.DESIGN -> EditorBuilder.design()
+            EditorPreset.VIDEO -> EditorBuilder.video()
+        }
+
+    private inline fun <reified T : Parcelable> Bundle.getParcelableCompat(key: String): T? =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            getParcelable(key, T::class.java)
+        } else {
+            getParcelable(key)
+        }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/builder/EditorBuilder.kt

@@ -0,0 +1,478 @@
+package ly.img.editor.reactnative.module.builder
+
+import android.net.Uri
+import androidx.compose.runtime.Composable
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import ly.img.editor.ApparelEditor
+import ly.img.editor.DesignEditor
+import ly.img.editor.DismissVideoExportEvent
+import ly.img.editor.EditorDefaults
+import ly.img.editor.EngineConfiguration
+import ly.img.editor.HideLoading
+import ly.img.editor.PhotoEditor
+import ly.img.editor.PostcardEditor
+import ly.img.editor.ShowLoading
+import ly.img.editor.ShowVideoExportProgressEvent
+import ly.img.editor.VideoEditor
+import ly.img.editor.core.event.EditorEventHandler
+import ly.img.editor.core.library.data.TextAssetSource
+import ly.img.editor.core.library.data.TypefaceProvider
+import ly.img.editor.reactnative.module.model.EditorPreset
+import ly.img.editor.reactnative.module.model.EditorResult
+import ly.img.editor.reactnative.module.model.EditorSettings
+import ly.img.editor.reactnative.module.model.EditorSourceType
+import ly.img.engine.DemoAssetSource
+import ly.img.engine.DesignBlock
+import ly.img.engine.DesignBlockType
+import ly.img.engine.Engine
+import ly.img.engine.MimeType
+import ly.img.engine.addDefaultAssetSources
+import ly.img.engine.addDemoAssetSources
+import java.io.File
+import java.util.UUID
+import kotlin.coroutines.cancellation.CancellationException
+
+/** A closure used to return a [Result] with type [EditorResult] from the editor. */
+typealias EditorBuilderResult = (Result<EditorResult?>) -> Unit
+
+/** Closure allowing to return a custom UI based on various input. */
+typealias Builder = @Composable CustomBuilderScope.() -> Unit
+
+/**
+ * @property settings The [EditorSettings] to configure the editor.
+ * @property preset The [EditorPreset] to open.
+ * @property metadata The custom metadata.
+ * @property result The [EditorBuilderResult] handling the result.
+ * @property onClose The closure to handle editor closing.
+ */
+data class CustomBuilderScope(
+    val settings: EditorSettings,
+    val preset: EditorPreset,
+    val metadata: Map<String, Any>?,
+    val result: EditorBuilderResult,
+    val onClose: (Throwable?) -> Unit,
+)
+
+/** The [EditorBuilder] is used to build different editor configurations */
+class EditorBuilder {
+    companion object {
+        /** The default design editor. */
+        fun design(): Builder =
+            {
+                ModalDesignEditor(settings, result, onClose)
+            }
+
+        /** The default postcard editor. */
+        fun postcard(): Builder =
+            {
+                ModalPostcardEditor(settings, result, onClose)
+            }
+
+        /** The default apparel editor. */
+        fun apparel(): Builder =
+            {
+                ModalApparelEditor(settings, result, onClose)
+            }
+
+        /** The default photo editor. */
+        fun photo(): Builder =
+            {
+                ModalPhotoEditor(settings, result, onClose)
+            }
+
+        /** The default video editor. */
+        fun video(): Builder =
+            {
+                ModalVideoEditor(settings, result, onClose)
+            }
+
+        /**
+         * A custom editor implementation.
+         * @param contentProvider A closure to provide a custom view.
+         * @return A [Builder] providing the custom view.
+         */
+        fun custom(contentProvider: @Composable CustomBuilderScope.() -> Unit): Builder =
+            {
+                val scope = CustomBuilderScope(settings, preset, metadata, result, onClose)
+                scope.contentProvider()
+            }
+
+        @Composable
+        private fun ModalPhotoEditor(
+            settings: EditorSettings,
+            result: EditorBuilderResult,
+            onClose: (Throwable?) -> Unit,
+        ) {
+            val engineConfiguration =
+                EngineConfiguration.remember(
+                    license = settings.license,
+                    baseUri = Uri.parse(settings.baseUri),
+                    userId = settings.userId,
+                    onCreate = {
+                        EditorBuilderDefaults.onCreate(
+                            engine = editorContext.engine,
+                            eventHandler = editorContext.eventHandler,
+                            settings = settings,
+                            defaultScene = EditorBuilderDefaults.defaultPhotoUri,
+                            sourceType = EditorSourceType.IMAGE,
+                        )
+                    },
+                    onExport = {
+                        val export =
+                            EditorBuilderDefaults.onExport(
+                                engine = editorContext.engine,
+                                eventHandler = editorContext.eventHandler,
+                                mimeType = MimeType.PNG,
+                            )
+                        result(Result.success(export))
+                    },
+                )
+            PhotoEditor(engineConfiguration = engineConfiguration) {
+                onClose(it)
+            }
+        }
+
+        @Composable
+        private fun ModalApparelEditor(
+            settings: EditorSettings,
+            result: EditorBuilderResult,
+            onClose: (Throwable?) -> Unit,
+        ) {
+            val engineConfiguration =
+                EngineConfiguration.remember(
+                    license = settings.license,
+                    baseUri = Uri.parse(settings.baseUri),
+                    userId = settings.userId,
+                    onCreate = {
+                        EditorBuilderDefaults.onCreate(
+                            engine = editorContext.engine,
+                            eventHandler = editorContext.eventHandler,
+                            settings = settings,
+                            defaultScene = EngineConfiguration.defaultApparelSceneUri,
+                        )
+                    },
+                    onExport = {
+                        val export =
+                            EditorBuilderDefaults.onExport(
+                                engine = editorContext.engine,
+                                eventHandler = editorContext.eventHandler,
+                                mimeType = MimeType.PDF,
+                            )
+                        result(Result.success(export))
+                    },
+                )
+            ApparelEditor(engineConfiguration = engineConfiguration) {
+                onClose(it)
+            }
+        }
+
+        @Composable
+        private fun ModalDesignEditor(
+            settings: EditorSettings,
+            result: EditorBuilderResult,
+            onClose: (Throwable?) -> Unit,
+        ) {
+            val engineConfiguration =
+                EngineConfiguration.remember(
+                    license = settings.license,
+                    baseUri = Uri.parse(settings.baseUri),
+                    userId = settings.userId,
+                    onCreate = {
+                        EditorBuilderDefaults.onCreate(
+                            engine = editorContext.engine,
+                            eventHandler = editorContext.eventHandler,
+                            settings = settings,
+                            defaultScene = EngineConfiguration.defaultDesignSceneUri,
+                        )
+                    },
+                    onExport = {
+                        val export =
+                            EditorBuilderDefaults.onExport(
+                                engine = editorContext.engine,
+                                eventHandler = editorContext.eventHandler,
+                                mimeType = MimeType.PDF,
+                            )
+                        result(Result.success(export))
+                    },
+                )
+
+            DesignEditor(engineConfiguration = engineConfiguration) {
+                onClose(it)
+            }
+        }
+
+        @Composable
+        private fun ModalPostcardEditor(
+            settings: EditorSettings,
+            result: EditorBuilderResult,
+            onClose: (Throwable?) -> Unit,
+        ) {
+            val engineConfiguration =
+                EngineConfiguration.remember(
+                    license = settings.license,
+                    baseUri = Uri.parse(settings.baseUri),
+                    userId = settings.userId,
+                    onCreate = {
+                        EditorBuilderDefaults.onCreate(
+                            engine = editorContext.engine,
+                            eventHandler = editorContext.eventHandler,
+                            settings = settings,
+                            defaultScene = EngineConfiguration.defaultPostcardSceneUri,
+                        )
+                    },
+                    onExport = {
+                        val export =
+                            EditorBuilderDefaults.onExport(
+                                engine = editorContext.engine,
+                                eventHandler = editorContext.eventHandler,
+                                mimeType = MimeType.PDF,
+                            )
+                        result(Result.success(export))
+                    },
+                )
+
+            PostcardEditor(engineConfiguration = engineConfiguration) {
+                onClose(it)
+            }
+        }
+
+        @Composable
+        private fun ModalVideoEditor(
+            settings: EditorSettings,
+            result: EditorBuilderResult,
+            onClose: (Throwable?) -> Unit,
+        ) {
+            val engineConfiguration =
+                EngineConfiguration.remember(
+                    license = settings.license,
+                    baseUri = Uri.parse(settings.baseUri),
+                    userId = settings.userId,
+                    onCreate = {
+                        EditorBuilderDefaults.onCreate(
+                            engine = editorContext.engine,
+                            eventHandler = editorContext.eventHandler,
+                            settings = settings,
+                            defaultScene = EngineConfiguration.defaultVideoSceneUri,
+                        )
+                    },
+                    onExport = {
+                        try {
+                            val export =
+                                EditorBuilderDefaults.onExportVideo(
+                                    engine = editorContext.engine,
+                                    eventHandler = editorContext.eventHandler,
+                                    mimeType = MimeType.MP4,
+                                )
+                            result(Result.success(export))
+                        } catch (e: Exception) {
+                            if (e !is CancellationException) {
+                                result(Result.failure(e))
+                            } else {
+                                editorContext.eventHandler.send(DismissVideoExportEvent)
+                            }
+                        }
+                    },
+                )
+            VideoEditor(engineConfiguration = engineConfiguration) {
+                onClose(it)
+            }
+        }
+    }
+}
+
+/** Default implementations to ease the editor configuration process. */
+object EditorBuilderDefaults {
+    /** The default image uri for the photo editor. */
+    val defaultPhotoUri: Uri = Uri.parse("file:///android_asset/photo-ui-empty.png")
+
+    /**
+     * Default plugin implementation for the *onCreate* callback.
+     * @param engine The [Engine] that should be used.
+     * @param eventHandler The [EditorEventHandler] that should be used.
+     * @param settings The [EditorSettings] containing the relevant editor information.
+     * @param defaultScene The [Uri] of the defaultScene if no [EditorSettings.source] is specified.
+     * @param sourceType The [EditorSourceType] defining of which type the source is.
+     */
+    suspend fun onCreate(
+        engine: Engine,
+        eventHandler: EditorEventHandler,
+        settings: EditorSettings,
+        defaultScene: Uri,
+        sourceType: EditorSourceType = EditorSourceType.SCENE,
+    ) = coroutineScope {
+        fun isValidUri(uri: Uri): Boolean =
+            try {
+                uri.scheme != null && uri.path != null
+            } catch (e: Exception) {
+                false
+            }
+
+        val uri =
+            if (settings.source != null) {
+                val sourceUri = Uri.parse(settings.source?.source)
+                val isValid = isValidUri(sourceUri)
+                if (!isValid) {
+                    throw IllegalArgumentException("The specified source is not a valid Uri.")
+                }
+                sourceUri
+            } else {
+                defaultScene
+            }
+
+        when (settings.source?.type ?: sourceType) {
+            EditorSourceType.IMAGE -> {
+                engine.scene.createFromImage(uri)
+                val graphicBlocks = engine.block.findByType(DesignBlockType.Graphic)
+                require(graphicBlocks.size == 1) { "No image found." }
+                val graphicBlock = graphicBlocks[0]
+                val pages = engine.scene.getPages()
+                require(pages.size == 1) { "No image found." }
+                val page = pages[0]
+                engine.block.setFill(page, engine.block.getFill(graphicBlock))
+                engine.block.destroy(graphicBlock)
+            }
+            EditorSourceType.VIDEO -> {
+                engine.scene.createFromVideo(uri)
+            }
+
+            else -> {
+                engine.scene.load(uri)
+            }
+        }
+
+        launch {
+            val assetBaseUri = settings.assetBaseUri ?: "https://cdn.img.ly/assets/v3"
+            val isValid = isValidUri(Uri.parse(assetBaseUri))
+            val baseUri = Uri.parse(if (isValid) assetBaseUri else "https://cdn.img.ly/assets/v3")
+            engine.addDefaultAssetSources(baseUri = baseUri)
+            val excluded = setOf(DemoAssetSource.IMAGE, DemoAssetSource.VIDEO, DemoAssetSource.AUDIO)
+            engine.addDemoAssetSources(sceneMode = engine.scene.getMode(), withUploadAssetSources = true, exclude = excluded)
+            val defaultTypeface = TypefaceProvider().provideTypeface(engine, "Roboto")
+            requireNotNull(defaultTypeface)
+            engine.asset.addSource(TextAssetSource(engine, defaultTypeface))
+        }
+        coroutineContext[Job]?.invokeOnCompletion {
+            eventHandler.send(HideLoading)
+        }
+    }
+
+    /**
+     * Default plugin implementation for the *onExport* callback.
+     * @param engine The [Engine] that should be used.
+     * @param eventHandler The [EditorEventHandler] that should be used.
+     * @param mimeType The [MimeType] of the exported artifact.
+     * @param thumbnailHeight The height of the generated thumbnail.
+     */
+    suspend fun onExport(
+        engine: Engine,
+        eventHandler: EditorEventHandler,
+        mimeType: MimeType,
+        thumbnailHeight: Int = 100,
+    ): EditorResult {
+        EditorBuilderDefaults.run {
+            eventHandler.send(ShowLoading)
+            val blob =
+                engine.block.export(
+                    block = requireNotNull(engine.scene.get()),
+                    mimeType = mimeType,
+                ) {
+                    scene.getPages().forEach {
+                        block.setScopeEnabled(it, key = "layer/visibility", enabled = true)
+                        block.setVisible(it, visible = true)
+                    }
+                }
+            val tempFile = EditorDefaults.writeToTempFile(blob, mimeType)
+            val scene = engine.scene.get()
+            val sceneString =
+                scene?.let {
+                    engine.scene.saveToString(it)
+                }
+            val sceneUri = sceneString?.let { saveScene(it) }
+            val firstPage = engine.scene.getPages().first()
+            val thumbnail = saveThumbnail(firstPage, engine, thumbnailHeight)
+            eventHandler.send(HideLoading)
+            return EditorResult(
+                scene = sceneUri.toString(),
+                artifact = Uri.fromFile(tempFile).toString(),
+                thumbnail = thumbnail.toString(),
+            )
+        }
+    }
+
+    /**
+     * Default plugin implementation for the *onExport* callback for the video editor.
+     * @param engine The [Engine] that should be used.
+     * @param eventHandler The [EditorEventHandler] that should be used.
+     * @param mimeType The [MimeType] of the exported artifact.
+     * @param thumbnailHeight The height of the generated thumbnail.
+     */
+    suspend fun onExportVideo(
+        engine: Engine,
+        eventHandler: EditorEventHandler,
+        mimeType: MimeType,
+        thumbnailHeight: Int = 100,
+    ): EditorResult {
+        EditorBuilderDefaults.run {
+            eventHandler.send(ShowVideoExportProgressEvent(0f))
+
+            // First create the thumbnail and save the scene
+            // in order to finish before the video export sheet is done.
+            val page = engine.scene.getCurrentPage() ?: engine.scene.getPages().first()
+            val thumbnail = saveThumbnail(page, engine, thumbnailHeight)
+            val scene = engine.scene.get()
+            val sceneString =
+                scene?.let {
+                    engine.scene.saveToString(it)
+                }
+
+            val buffer =
+                engine.block.exportVideo(
+                    block = page,
+                    timeOffset = 0.0,
+                    duration = engine.block.getDuration(page),
+                    mimeType = mimeType,
+                    progressCallback = { progress ->
+                        eventHandler.send(
+                            ShowVideoExportProgressEvent(progress.encodedFrames.toFloat() / progress.totalFrames),
+                        )
+                    },
+                )
+
+            val tempFile = EditorDefaults.writeToTempFile(buffer, mimeType)
+            eventHandler.send(DismissVideoExportEvent)
+
+            return EditorResult(
+                scene = sceneString,
+                artifact = Uri.fromFile(tempFile).toString(),
+                thumbnail = thumbnail.toString(),
+            )
+        }
+    }
+
+    private suspend fun saveScene(scene: String): Uri =
+        withContext(Dispatchers.IO) {
+            val file =
+                File
+                    .createTempFile("cesdk_export_scene_" + UUID.randomUUID().toString(), ".scene")
+            file.writeText(scene)
+            Uri.fromFile(file)
+        }
+
+    private suspend fun saveThumbnail(
+        id: DesignBlock,
+        engine: Engine,
+        height: Int,
+    ): Uri {
+        val frames =
+            engine.block.generateVideoThumbnailSequence(id, height, timeBegin = 0.0, timeEnd = 0.1, numberOfFrames = 1).toList()
+        val firstFrame = frames.first()
+        val buffer = firstFrame.imageData
+        val tempFile = EditorDefaults.writeToTempFile(buffer, MimeType.PNG)
+        return Uri.fromFile(tempFile)
+    }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/helper/AssetHelper.kt

@@ -0,0 +1,18 @@
+package ly.img.editor.reactnative.module.helper
+
+import android.net.Uri
+
+/** Helper to use resolve assets. */
+class AssetHelper {
+    companion object {
+        /**
+         * Validates the source of a given asset and returns the Uri if succeeded.
+         * @param source The source of the asset.
+         * @return The resolved [Uri] as a [String].
+         */
+        fun validateAssetSource(source: String): String? {
+            fun uriOrNull(uri: Uri?): String? = uri.takeIf { uri?.scheme != null && uri.path != null }?.toString()
+            return uriOrNull(Uri.parse(source))
+        }
+    }
+}

package/android/src/main/kotlin/ly/img/editor/reactnative/module/helper/IntentHelper.kt

@@ -0,0 +1,61 @@
+package ly.img.editor.reactnative.module.helper
+
+import android.os.Bundle
+import android.os.Parcelable
+import java.io.Serializable
+
+/** A helper to parse Maps for intents */
+class IntentHelper {
+    companion object {
+        /**
+         * Converts a [Map] to a [Bundle].
+         * @param map The map to convert.
+         * @return The bundle.
+         */
+        fun mapToBundle(map: Map<*, *>?): Bundle {
+            val bundle = Bundle()
+            if (map != null) {
+                for ((key, value) in map) {
+                    if (key is String) {
+                        when (value) {
+                            is Int -> bundle.putInt(key, value)
+                            is Long -> bundle.putLong(key, value)
+                            is String -> bundle.putString(key, value)
+                            is Float -> bundle.putFloat(key, value)
+                            is Double -> bundle.putDouble(key, value)
+                            is Boolean -> bundle.putBoolean(key, value)
+                            is Bundle -> bundle.putBundle(key, value)
+                            is Map<*, *> -> bundle.putBundle(key, mapToBundle(value))
+                            is Parcelable -> bundle.putParcelable(key, value)
+                            is Serializable -> bundle.putSerializable(key, value)
+                            // Add other types as needed
+                            else -> throw IllegalArgumentException("Unsupported value type: ${value?.javaClass}")
+                        }
+                    } else {
+                        throw IllegalArgumentException("Unsupported key type: ${key?.javaClass}")
+                    }
+                }
+            }
+            return bundle
+        }
+
+        /**
+         * Converts a [Bundle] to a *Map<String, Any>*
+         * @param bundle The [Bundle] to convert.
+         * @return The map.
+         */
+        fun bundleToMap(bundle: Bundle?): Map<String, Any>? {
+            bundle ?: return null
+            val map = mutableMapOf<String, Any>()
+            for (key in bundle.keySet()) {
+                val value = bundle.get(key)
+                if (value is Bundle) {
+                    map[key] = bundleToMap(value)!!
+                } else if (value != null) {
+                    map[key] = value
+                }
+            }
+            return map
+        }
+    }
+}