Android with Kotlin

dependencies {
    implementation("com.squareup.okhttp3:okhttp:5.5.1")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.11.0")
}

Copy failed. The text is selected; copy it with your keyboard.

/** Asks the backend to create the job from the upload: "transcode" (one MP4) or "jobs" (several outputs). */
suspend fun createJob(inputUrl: String, kind: String): Job = withContext(Dispatchers.IO) {
    job(send("POST", "api/jobs", JSONObject().put("kind", kind).put("input_url", inputUrl)))
}

/** Reads the job every 2 seconds until it ends. A push from your backend (after its webhook) can replace the polling. */
suspend fun waitForJob(start: Job): Job {
    var current = start
    while (current.isActive) {
        delay(2_000)
        current = withContext(Dispatchers.IO) { job(send("GET", "api/jobs/${current.id}")) }
    }
    return current
}

Copy failed. The text is selected; copy it with your keyboard.

private fun send(method: String, path: String, body: JSONObject? = null): JSONObject {
    val requestBody = body?.toString()?.toRequestBody("application/json".toMediaType())
    val request = Request.Builder().url("$baseUrl/$path").method(method, requestBody).build()
    http.newCall(request).execute().use { response ->
        check(response)
        return JSONObject(response.body.string())
    }
}

/** An answer outside 2xx becomes its problem details, so the app can show the detail. */
private fun check(response: Response) {
    if (response.isSuccessful) return
    val problem = runCatching { JSONObject(response.body.string()) }.getOrNull()
    throw Problem(
        problem?.optString("title") ?: "The server answered with an error.",
        problem?.optString("detail") ?: "HTTP ${response.code}",
        problem?.optString("code"),
    )
}

Copy failed. The text is selected; copy it with your keyboard.

/**
 * Asks the backend for a one-time upload URL, then sends the file straight to Videxo with it.
 * The upload URL holds no API key and takes one PUT, so the PUT is never retried: when it
 * fails this throws, and the next call creates a new upload. [cacheDir] holds a copy of a file
 * whose provider does not tell its size (some cloud providers), to send its exact length.
 */
suspend fun upload(resolver: ContentResolver, file: Uri, cacheDir: File): String = withContext(Dispatchers.IO) {
    val contentType = resolver.getType(file) ?: "application/octet-stream"
    val (name, reported) = resolver.query(file, null, null, null, null)!!.use { cursor ->
        cursor.moveToFirst()
        val size = cursor.getColumnIndexOrThrow(OpenableColumns.SIZE)
        cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME)) to
            (if (cursor.isNull(size)) null else cursor.getLong(size))
    }
    // An unknown or empty size: copy the file once, up to the direct upload limit, and send the
    // copy, whose length is exact. The finally below deletes the copy, also after a failed one.
    var copy: File? = null
    try {
        if (reported == null || reported <= 0) {
            val target = File.createTempFile("upload", null, cacheDir)
            copy = target
            copyAtMost(resolver, file, target, MAX_UPLOAD_BYTES)
        }
        val size = copy?.length() ?: reported!!
        val created = send(
            "POST", "api/uploads",
            JSONObject().put("filename", plainName(name)).put("size_bytes", size).put("content_type", contentType),
        )
        val bytes = object : RequestBody() {
            override fun contentType() = contentType.toMediaType()
            override fun contentLength() = size
            // OkHttp must not send the body twice: the upload URL takes one PUT.
            override fun isOneShot() = true
            override fun writeTo(sink: BufferedSink) {
                (copy?.inputStream() ?: resolver.openInputStream(file)!!).source().use { sink.writeAll(it) }
            }
        }
        val put = Request.Builder().url(created.getString("upload_url")).put(bytes).build()
        uploads.newCall(put).execute().use { check(it) }
        created.getString("input_url")
    } finally {
        copy?.delete()
    }
}

/** Copies [file] into [target]; throws once it passes [limit] bytes, so a huge file never fills the cache. */
private fun copyAtMost(resolver: ContentResolver, file: Uri, target: File, limit: Long) {
    resolver.openInputStream(file)!!.use { input ->
        target.outputStream().use { output ->
            val buffer = ByteArray(64 * 1024)
            var total = 0L
            while (true) {
                val read = input.read(buffer)
                if (read < 0) break
                total += read
                if (total > limit) throw Problem("The file is too large.", "A direct upload is at most 100 MB.", "limit_exceeded")
                output.write(buffer, 0, read)
            }
        }
    }
}

Copy failed. The text is selected; copy it with your keyboard.

val pick = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { file: Uri? ->
    if (file == null) return@rememberLauncherForActivityResult
    busy = true
    scope.launch {
        try {
            problem = null
            job = null
            status = "Uploading"
            val inputUrl = backend.upload(context.contentResolver, file, context.cacheDir)
            val created = backend.createJob(inputUrl, kind)
            status = "Job ${created.id}: ${created.state}"
            val ended = backend.waitForJob(created)
            status = "Job ${ended.id}: ${ended.state}"
            job = ended
        } catch (error: Exception) {
            status = ""
            problem = error.message
        } finally {
            busy = false
        }
    }
}

Copy failed. The text is selected; copy it with your keyboard.

/** The backend's download route: it redirects to a fresh signed link, which the browser or DownloadManager follows. */
fun downloadUrl(job: Job, output: Output): Uri = Uri.parse("$baseUrl/api/jobs/${job.id}/outputs/${output.alias}")

Copy failed. The text is selected; copy it with your keyboard.