Configuration

class KEditorDemoActivity : Activity(), PermissionRequest.Response {

    companion object {
        const val PESDK_RESULT = 1
        const val GALLERY_RESULT = 2
    }

    // Important permission request for Android 6.0 and above, don't forget to add this!
    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        PermissionRequest.onRequestPermissionsResult(requestCode, permissions, grantResults)
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    }

    override fun permissionGranted() {}

    override fun permissionDenied() {
        /* TODO: The Permission was rejected by the user. The Editor was not opened,
         * Show a hint to the user and try again. */
    }

    // Create a empty new SettingsList and apply the changes on this referance.
    // If you include our asset Packs and use our UI you also need to add them to the UI,
    // otherwise they are only available for the backend (like Serialisation)
    // See the specific feature sections of our guides if you want to know how to add our own Assets.
    private fun createPESDKSettingsList() =
      PhotoEditorSettingsList()
        .configure<UiConfigFilter> {
            it.setFilterList(FilterPackBasic.getFilterPack())
        }
        .configure<UiConfigText> {
            it.setFontList(FontPackBasic.getFontPack())
        }
        .configure<UiConfigFrame> {
            it.setFrameList(FramePackBasic.getFramePack())
        }
        .configure<UiConfigOverlay> {
            it.setOverlayList(OverlayPackBasic.getOverlayPack())
        }
        .configure<UiConfigSticker> {
          it.setStickerLists(
            StickerPackEmoticons.getStickerCategory(),
            StickerPackShapes.getStickerCategory()
          )
        }
        .configure<PhotoEditorSaveSettings> {
            it.setOutputToGallery(Environment.DIRECTORY_DCIM)
        }


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        openSystemGalleryToSelectAnImage()
    }

    fun openSystemGalleryToSelectAnImage() {
        val intent = Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI)
        if (intent.resolveActivity(packageManager) != null) {
            startActivityForResult(intent, GALLERY_RESULT)
        } else {
            Toast.makeText(
              this,
              "No Gallery APP installed",
              Toast.LENGTH_LONG
            ).show()
        }
    }

    fun openEditor(inputImage: Uri?) {
        val settingsList = createPESDKSettingsList()

        settingsList.configure<LoadSettings> {
            it.source = inputImage
        }

        settingsList[LoadSettings::class].source = inputImage

        PhotoEditorBuilder(this)
          .setSettingsList(settingsList)
          .startActivityForResult(this, PESDK_RESULT)
    }


    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent) {
        super.onActivityResult(requestCode, resultCode, intent)

        if (resultCode == RESULT_OK && requestCode == GALLERY_RESULT) {
            // Open Editor with some uri in this case with an image selected from the system gallery.
            openEditor(intent.data)

        } else if (resultCode == RESULT_OK && requestCode == PESDK_RESULT) {
            // Editor has saved an Image.
            val data = EditorSDKResult(intent)

            Log.i("PESDK", "Source image is located here ${data.sourceUri}")
            Log.i("PESDK", "Result image is located here ${data.resultUri}")

            // TODO: Do something with the result image

            // OPTIONAL: read the latest state to save it as a serialisation
            val lastState = data.settingsList
            try {
                IMGLYFileWriter(lastState).writeJson(File(
                  Environment.getExternalStorageDirectory(),
                  "serialisationReadyToReadWithPESDKFileReader.json"
                ))
            } catch (e: IOException) {
                e.printStackTrace()
            }

        } else if (resultCode == RESULT_CANCELED && requestCode == PESDK_RESULT) {
            // Editor was canceled
            val data = EditorSDKResult(intent)

            val sourceURI = data.sourceUri
            // TODO: Do something with the source...
        }
    }

    private lateinit var videoUri1: Uri // Example code dummy
    private lateinit var videoUri2: Uri // Example code dummy

    @RequiresApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
    private fun openVideoComposition() {
        thread {
            val settingsList = ExampleConfigUtility.createInitialVESDKSettingsList()
            settingsList.configure<VideoCompositionSettings> {
                // Add a video
                it.addCompositionPart(
                    VideoCompositionSettings.VideoPart(videoUri1)
                )
                // Add another video, which is already trimmed from 3 until 10 seconds
                it.addCompositionPart(
                    VideoCompositionSettings.VideoPart(
                        videoUri2,
                        trimStartInNanoseconds = 3.convert(TimeUnit.SECONDS, TimeUnit.NANOSECONDS),
                        trimEndInNanoseconds = 10.convert(TimeUnit.SECONDS, TimeUnit.NANOSECONDS)
                    )
                )
            }
            // ATTENTION: You need to set a loading source the size and fps is taken from!
            settingsList.configure<LoadSettings> {
                // You could use a video or a empty composition source which is recommended.
                it.source = LoadSettings.compositionSource(
                    width = 1024, height = 1920,
                    framesPerSecond = 60
                )
            }

            // OPTIONAL: Set the entry point to VideoCompositionToolPanel
            settingsList.configure<UiConfigMainMenu> {
                it.setInitialTool(VideoCompositionToolPanel.TOOL_ID)

            }
        }
    }
}

// Obtain the config
settingsList.configure<UiConfigMainMenu> {
    // Set the tools you want keep sure you licence is cover the feature and do not forget to include the correct modules in your build.gradle
    it.setToolList(
        // Composition tool (needs 'ui:video-composition')
        ToolItem(
            "imgly_tool_composition",
            R.string.vesdk_video_composition_title_name,
            ImageSource.create(R.drawable.imgly_icon_tool_video_composition)
        ),
        // Trim tool (Is redundant together with the composition tool, needs 'ui:video-trim')
        ToolItem("imgly_tool_trim", R.string.vesdk_video_trim_title_name, ImageSource.create(R.drawable.imgly_icon_tool_trim)),
        // Audio Overlay tool (needs 'ui:audio-composition')
        ToolItem(
            "imgly_tool_audio_overlay_options",
            R.string.vesdk_audio_composition_title_name,
            ImageSource.create(R.drawable.imgly_icon_tool_audio)
        ),
        // Transformation tool (needs 'ui:transform')
        ToolItem(
            "imgly_tool_transform",
            R.string.pesdk_transform_title_name,
            ImageSource.create(R.drawable.imgly_icon_tool_transform)
        ),
        // Filter tool (needs 'ui:filter')
        ToolItem("imgly_tool_filter", R.string.pesdk_filter_title_name, ImageSource.create(R.drawable.imgly_icon_tool_filters)),
        // Adjustment tool (needs 'ui:adjustment')
        ToolItem(
            "imgly_tool_adjustment",
            R.string.pesdk_adjustments_title_name,
            ImageSource.create(R.drawable.imgly_icon_tool_adjust)
        ),
        // Sticker tool (needs 'ui:sticker')
        ToolItem(
            "imgly_tool_sticker_selection",
            R.string.pesdk_sticker_title_name,
            ImageSource.create(R.drawable.imgly_icon_tool_sticker)
        ),
        // Text Design tool (needs 'ui:text-design')
        ToolItem(
            "imgly_tool_text_design",
            R.string.pesdk_textDesign_title_name,
            ImageSource.create(R.drawable.imgly_icon_tool_text_design)
        ),
        // Text tool (needs 'ui:text')
        ToolItem("imgly_tool_text", R.string.pesdk_text_title_name, ImageSource.create(R.drawable.imgly_icon_tool_text)),
        // Overlay tool (needs 'ui:overlay')
        ToolItem("imgly_tool_overlay", R.string.pesdk_overlay_title_name, ImageSource.create(R.drawable.imgly_icon_tool_overlay)),
        // Frame tool (needs 'ui:frame')
        ToolItem("imgly_tool_frame", R.string.pesdk_frame_title_name, ImageSource.create(R.drawable.imgly_icon_tool_frame)),
        // Brush tool (needs 'ui:brush')
        ToolItem("imgly_tool_brush", R.string.pesdk_brush_title_name, ImageSource.create(R.drawable.imgly_icon_tool_brush)),
        // Focus tool (needs 'ui:focus')
        ToolItem("imgly_tool_focus", R.string.pesdk_focus_title_name, ImageSource.create(R.drawable.imgly_icon_tool_focus))
    )
}