From Scan to PDF: A Streamlined Document Digitization Flow

Smart PDF Generator with Scan, Filter, and Custom Export Control (Kotlin)

From Friction to Focus: What the Problem Taught Us

1. Scanning & OCR Integration

• Integrate Google ML Kit for reliable text recognition from captured images.
• Handle document skew, blur, and noise to improve text extraction accuracy.

2. Image Preprocessing

• Add filter options for clarity (e.g., grayscale, contrast boost).
• Enable crop adjustment with flexible bounding boxes.
• Maintain preview consistency before saving.

3. Multi-Page Capture & PDF Assembly

• Allow continuous scanning into a session.
• Maintain a structured order of pages.
• Create a PDF with selectable DPI (70, 150, 300) for file-size/resolution control.

4. Permission & Storage Management

• Request runtime permissions for the camera and file storage.
• Handle edge cases like denied or revoked permissions gracefully.
• Ensure file storage on both internal and external directories based on OS versions.

5. Custom Naming & Downloads

• Support user-defined naming schemes or use timestamp-based fallbacks.
• Save PDFs in a dedicated folder and notify users with share options post-download.

Future-Ready Solutions: Beyond Ideas, Beyond Limits

1. Modular Image Processing Pipeline

• Built a modular architecture separating scanning, filtering, and PDF generation to maintain a clean code structure.
• Enabled independent upgrades to OCR, image enhancements, and export features without breaking the full workflow.
• Simplified testing and debugging with isolated, well-scoped modules for scanning, editing, and file management.

2. Adaptive Permission Management

• Developed a context-aware permission handler that adapts to different Android SDK versions and permission models.
• Minimized user friction by requesting permissions only when necessary, improving acceptance rates.
• Safeguarded the app flow by implementing fallback strategies when permissions are denied, keeping users engaged without crashes.

3. Dynamic DPI and Resolution Control

• Introduced a flexible resolution engine allowing users to select 70, 150, or 300 DPI dynamically before final PDF generation.
• Balanced quality and file size to suit diverse user needs, like quick sharing vs professional-grade printing.
• Optimized memory and storage usage by adjusting image compression and resolution settings in real-time.

4. Efficient Multi-Page Capture and Assembly

• Designed an optimized image caching mechanism to handle multiple high-resolution captures without memory leaks.
• Streamlined the process of stitching multiple images into a coherent, properly ordered multi-page PDF.
• Reduced processing time and ensured smooth navigation even with large multi-page documents.

5. Resilient Error Handling and Recovery

• Implemented graceful error recovery strategies during scan capture, filter application, and PDF generation stages.
• Added informative user prompts and fallback options, ensuring that minor failures do not interrupt the entire session.
• Logged critical failures internally to aid in post-release debugging and updates.

A) Manage the internet connection and custom message

fun showSnackBar(view: View?, strMessage: String?) {
        try {
            val snackbar = Snackbar.make(view!!, strMessage!!, Snackbar.LENGTH_LONG)
            val snackbarView = snackbar.view
            snackbarView.setBackgroundColor(Color.BLACK)
            val textView =
                snackbarView.findViewById<View>(com.google.android.material.R.id.snackbar_text) as TextView
            textView.setTextColor(Color.WHITE)
            textView.maxLines = 5
            snackbar.show()
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    //- Check network connectivity
    fun isInternetAvail(context: Context): Boolean {
        val connectivity = context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
        if (connectivity != null) {
            val info = connectivity.allNetworkInfo
            if (info != null) for (i in info.indices) if (info[i].state == NetworkInfo.State.CONNECTED) {
                return true
            }
        }
        return false
    }

B). Manage to store the PDF in the desired locations

. private fun savePdfToUserSelectedLocation(pdfData: ByteArray) {
        contentResolver.openOutputStream(imageUri!!)?.use { outputStream ->
            outputStream.write(pdfData)
            globalApplication.showSnackBar(
                homeScreenBinding.btnScan,
                getString(R.string.validate_pdf_download_process)
            )
        } ?: run {
            globalApplication.showSnackBar(
                homeScreenBinding.btnScan,
                getString(R.string.validate_pdf_download_process_failed)
            )
        }
    }
    private fun promptUserForPdfSaveLocation(pdfData: ByteArray?) {
        val intent = Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
            addCategory(Intent.CATEGORY_OPENABLE)
            type = “application/pdf”
            putExtra(Intent.EXTRA_TITLE, “scannedDocument.pdf”)
        }
        startActivityForResult(intent, 333)
    }

C) Custom PDF creation

private fun createPdf(
        format: PdfFormat,
        bitmaps: MutableList<Uri>,
        selectedDpi: Int
    ): ByteArray {
        val document = PdfDocument()
        val baseDpi = 72f
        val dpiFactor = selectedDpi / baseDpi
        bitmaps.forEachIndexed { index, bitmapUri ->
            val brightnessValue = 70f // Brightness adjustment
            val newBitmap = uriToBitmap(context = this, bitmapUri)
            val adjustedBitmap =
                newBitmap?.let { adjustBrightnessAndApplyGrayscale(it, brightnessValue) }
            val (pageWidth, pageHeight) = when (format) {
                PdfFormat.A4 -> Pair(595, 842)  // DIN A4 dimensions in points
                PdfFormat.A5 -> Pair(420, 595)  // DIN A5 dimensions in points
            }
           val scaledPageWidth = (pageWidth * dpiFactor).toInt()
            val scaledPageHeight = (pageHeight * dpiFactor).toInt()
            val pageInfo =
                PdfDocument.PageInfo.Builder(scaledPageWidth, scaledPageHeight, index + 1).create()
            val page = document.startPage(pageInfo)
            val canvas = page.canvas
            val paint = Paint().apply {
                color = Color.WHITE
                style = Paint.Style.FILL
            }
            canvas.drawRect(0f, 0f, scaledPageWidth.toFloat(), scaledPageHeight.toFloat(), paint)
            val resizedBitmap = adjustedBitmap?.let {
                Bitmap.createScaledBitmap(it, scaledPageWidth, scaledPageHeight, false)
            }
  if (resizedBitmap != null) {
                canvas.drawBitmap(resizedBitmap, 0f, 0f, null)
            }
            document.finishPage(page)
        }
        val outputStream = ByteArrayOutputStream()
        document.writeTo(outputStream)
        document.close()
        return outputStream.toByteArray()
    }

D) Managed to scan the desired image or documents

 private fun scanDocument() {
        scanner?.getStartScanIntent(this)?.addOnSuccessListener { intentSender ->
            scannerLauncher?.launch(IntentSenderRequest.Builder(intentSender).build())
        }?.addOnFailureListener {
            globalApplication.showSnackBar(
                homeScreenBinding.btnScan,
                getString(R.string.validate_no_scanner)
            )
        }
    }

E) Visual representation on the real Android devices

 IAP integration example

A) Managed the network states and custom messages through the application.

B) Managed to store the PDF in the desired location.

C) Managed to create the custom PDFs with multiple page support.

D) Managed to scan any documents or images to generate the PDF.

E) Visual representation of the PDF Generator for Android devices.

Performance & User Experience Optimization

Bitmap Memory Management

Implemented proactive bitmap scaling techniques to reduce image dimensions before intensive operations like PDF conversion, significantly lowering RAM usage.

Used efficient BitmapFactory.Options during image decoding to load scaled versions instead of full-resolution originals.

Ensured proper recycling of bitmap resources immediately after use to prevent memory leaks and minimize the risk of OutOfMemoryError, especially when handling multiple high-DPI scanned images.

Integrated dynamic memory monitoring to adapt bitmap size based on available system memory, ensuring smoother processing on mid- and low-end devices.

Robust Error Handling and User Recovery

Implemented comprehensive permission checks before attempting sensitive operations like camera access, file writes, and storage retrieval, reducing crash risks.

Designed fallback user prompts and clear permission rationales to improve permission acceptance rates and guide users when manual intervention was needed.

Encapsulated all file I/O and critical scan-related operations within structured try-catch blocks to gracefully manage unexpected errors, such as missing storage paths or write failures.

Delivered user-friendly error dialogs and safe exit strategies, maintaining application stability even under abnormal conditions like permission denial or corrupted files.

Hardware Adaptability

Optimized scanning, camera capture, and processing workflows to work efficiently across a wide range of hardware, from high-end flagship devices to low-memory budget phones.

Utilized Android’s hardware capability checks (CameraManager, PackageManager) to dynamically adjust scanning options, image resolutions, and DPI output based on the device’s capabilities.