To a Remote URL

Start Editor#

For the sake of this example, we load a video from the resources into the video editor.

By default, VideooEditor SDK exports the video as a temporary file in the application's cache directory.

Handle Result#

The result from the editor is received in the onActivityResult() method. EditorSDKResult wraps around the intent and provides a convenient API to check the result. The Uri of the exported video can be accessed via EditorSDKResult.resultUri. Here, we upload the exported video by launching a coroutine and calling the NetworkUtils.upload() suspend function. While the upload is running, we show a loader and dismiss it when the upload is finished.


class SaveVideoToRemoteURL(private val activity: AppCompatActivity) : Example(activity) {

    override fun invoke() {
        // In this example, we do not need access to the Uri(s) after the editor is closed
        // so we pass false in the constructor
        val settingsList = VideoEditorSettingsList(false)
            // Set the source as the Uri of the video to be loaded
            .configure<LoadSettings> {
                it.source = activity.resourceUri(R.raw.skater)
            }
        // Start the video editor using VideoEditorBuilder
        // The result will be obtained in onActivityResult() corresponding to EDITOR_REQUEST_CODE
        VideoEditorBuilder(activity)
            .setSettingsList(settingsList)
            .startActivityForResult(activity, EDITOR_REQUEST_CODE)
        // Release the SettingsList once done
        settingsList.release()
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
        super.onActivityResult(requestCode, resultCode, intent)
        intent ?: return
        if (requestCode == EDITOR_REQUEST_CODE) {
            val result = EditorSDKResult(intent)
            when (result.resultStatus) {
                EditorSDKResult.Status.CANCELED -> showMessage("Editor cancelled")
                EditorSDKResult.Status.EXPORT_DONE -> {
                    // Launch a Coroutine to upload the exported video
                    activity.lifecycleScope.launch {
                        showLoader(true)
                        val response = runCatching {
                            upload(result.resultUri!!, activity.contentResolver)
                        }.getOrDefault(false)
                        showLoader(false)
                        showMessage(if (response) "Uploaded successfully" else "Upload failed")
                    }
                }
                else -> {
                }
            }
        }
    }
}
/**
 * Uploads the file backed by the [uri] to a remote URL using a HTTP POST request.
 * Uses low level classes like [HttpsURLConnection], [InputStream], [OutputStream].
 * In a production app, you might want to use a library like OkHttp to handle this for you.
 *
 * @return boolean indicating whether the request returned 200 OK or not.
 */
suspend fun upload(uri: Uri, contentResolver: ContentResolver): Boolean {
    return withContext(Dispatchers.IO) {
        val url = URL("https://httpbin.org/post")

        val boundary = "Boundary-${System.currentTimeMillis()}"

        val httpsURLConnection = url.openConnection() as HttpsURLConnection
        httpsURLConnection.addRequestProperty(
            "Content-Type",
            "multipart/form-data; boundary=$boundary"
        )
        httpsURLConnection.requestMethod = "POST"
        httpsURLConnection.doInput = true
        httpsURLConnection.doOutput = true

        val outputStreamToRequestBody = httpsURLConnection.outputStream
        val httpRequestBodyWriter = BufferedWriter(OutputStreamWriter(outputStreamToRequestBody))

        httpRequestBodyWriter.write("\n--$boundary\n")
        httpRequestBodyWriter.write(
            "Content-Disposition: form-data;"
                + "name=\"media\";"
                + "filename=\"imgly_media\""
                + "\nContent-Type: ${contentResolver.getType(uri)}\n\n"
        )
        httpRequestBodyWriter.flush()

        val inputStreamToFile = contentResolver.openInputStream(uri)!!
        var bytesRead: Int
        val dataBuffer = ByteArray(1024)
        while (inputStreamToFile.read(dataBuffer).also { bytesRead = it } != -1) {
            outputStreamToRequestBody.write(dataBuffer, 0, bytesRead)
        }
        outputStreamToRequestBody.flush()

        httpRequestBodyWriter.write("\n--$boundary--\n")
        httpRequestBodyWriter.flush()

        outputStreamToRequestBody.close()
        httpRequestBodyWriter.close()

        val responseCode = httpsURLConnection.responseCode
        Log.d("IMG.LY", httpsURLConnection.inputStream.bufferedReader().use { it.readText() })
        responseCode == HttpURLConnection.HTTP_OK
    }
}