Build an AI Document Summarizer for Android

val openDoc = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocument()) { uri ->
    uri?.let(viewModel::onDocumentPicked)
}
Button(onClick = { openDoc.launch(arrayOf("application/pdf", "text/plain")) }) {
    Text("Choose document")
}

class TextExtractor(private val context: Context, private val recognizer: TextRecognizer) {

    suspend fun extract(uri: Uri): String = withContext(Dispatchers.IO) {
        when (context.contentResolver.getType(uri)) {
            "text/plain" -> context.contentResolver.openInputStream(uri)!!.bufferedReader().use { it.readText() }
            "application/pdf" -> ocrPdf(uri)
            else -> throw UnsupportedDocumentException()
        }
    }

    private suspend fun ocrPdf(uri: Uri): String {
        val pfd = context.contentResolver.openFileDescriptor(uri, "r") ?: return ""
        return PdfRenderer(pfd).use { renderer ->
            buildString {
                for (i in 0 until minOf(renderer.pageCount, MAX_PAGES)) {
                    renderer.openPage(i).use { page ->
                        val bmp = Bitmap.createBitmap(page.width * 2, page.height * 2, Bitmap.Config.ARGB_8888)
                        bmp.eraseColor(Color.WHITE)
                        page.render(bmp, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
                        appendLine(recognizer.process(InputImage.fromBitmap(bmp, 0)).await().text)
                        bmp.recycle()
                    }
                }
            }
        }
    }
}

fun chunk(text: String, maxChars: Int = 8_000): List<String> {
    val chunks = mutableListOf<String>()
    val current = StringBuilder()
    for (para in text.split(Regex("\\n\\s*\\n"))) {
        if (current.length + para.length > maxChars && current.isNotEmpty()) {
            chunks += current.toString(); current.clear()
        }
        current.append(para.take(maxChars)).append("\n\n")
    }
    if (current.isNotBlank()) chunks += current.toString()
    return chunks
}
// Character counts approximate tokens (~4 chars/token in English); keep a safety margin.

class DocumentSummarizer(private val llm: Llm) {   // Llm: generate(prompt): String, stream(prompt): Flow<String>

    fun summarize(text: String, onProgress: (Int, Int) -> Unit): Flow<String> = flow {
        val chunks = chunk(text)
        val partials = if (chunks.size == 1) chunks else chunks.mapIndexed { i, c ->
            onProgress(i + 1, chunks.size)
            llm.generate("Summarise this section in 5 bullet points. Use only the text.\n\n$c")
        }
        emitAll(
            llm.stream(
                "Combine these section summaries into one summary: a 2-sentence overview, " +
                "then up to 8 bullet points. Don't add facts not present.\n\n" +
                partials.joinToString("\n\n")
            )
        )
    }
}

@Entity(tableName = "summaries")
data class SummaryEntity(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val summary: String,
    val sourceChars: Int,
    val modelSource: String,          // "on-device" or "cloud"
    val createdAt: Long,
)
// Store the summary, not the full document, unless users need it (privacy + storage).