Android Implementation

// LocalDreamModule.kt:45-52
internal fun isNpuSupportedInternal(): Boolean {
    val soc = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        Build.SOC_MODEL
    } else {
        ""
    }
    return soc.startsWith("SM") || soc.startsWith("QCS") || soc.startsWith("QCM")
}

// LocalDreamModule.kt:232-268
private fun prepareRuntimeDir(): File {
    val runtimeDir = File(reactApplicationContext.filesDir, RUNTIME_DIR).apply {
        if (!exists()) mkdirs()
    }

    try {
        val qnnLibs = reactApplicationContext.assets.list("qnnlibs")
        qnnLibs?.forEach { fileName ->
            val targetLib = File(runtimeDir, fileName)
            // Copy from assets if missing or size mismatch
            if (needsCopy) {
                reactApplicationContext.assets.open("qnnlibs/$fileName").use { input ->
                    targetLib.outputStream().use { output ->
                        input.copyTo(output)
                    }
                }
            }
            targetLib.setReadable(true, true)
            targetLib.setExecutable(true, true)
        }
    } catch (e: IOException) {
        Log.w(TAG, "No QNN libraries found in assets (CPU-only mode): ${e.message}")
    }

    return runtimeDir
}

// LocalDreamModule.kt:166-196
internal fun buildEnvironment(runtimeDir: File): Map<String, String> {
    val env = mutableMapOf<String, String>()

    val systemLibPaths = mutableListOf(
        runtimeDir.absolutePath,
        "/system/lib64",
        "/vendor/lib64",
        "/vendor/lib64/egl"
    )

    // Auto-detect Mali GPU paths for ARM Mali devices
    try {
        val maliSymlink = File("/system/vendor/lib64/egl/libGLES_mali.so")
        if (maliSymlink.exists()) {
            val realPath = maliSymlink.canonicalPath
            val soc = realPath.split("/").getOrNull(realPath.split("/").size - 2)
            if (soc != null) {
                listOf("/vendor/lib64/$soc", "/vendor/lib64/egl/$soc").forEach { path ->
                    if (!systemLibPaths.contains(path)) systemLibPaths.add(path)
                }
            }
        }
    } catch (e: Exception) {
        Log.w(TAG, "Failed to resolve Mali paths: ${e.message}")
    }

    env["LD_LIBRARY_PATH"] = systemLibPaths.joinToString(":")
    env["DSP_LIBRARY_PATH"] = runtimeDir.absolutePath
    env["ADSP_LIBRARY_PATH"] = runtimeDir.absolutePath

    return env
}

// LocalDreamModule.kt:138-164
internal fun saveRgbToPng(base64Rgb: String, width: Int, height: Int, outputPath: String) {
    val rgbBytes = Base64.decode(base64Rgb, Base64.DEFAULT)
    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
    val pixels = IntArray(width * height)

    for (i in 0 until width * height) {
        val idx = i * 3
        val r = rgbBytes[idx].toInt() and 0xFF
        val g = rgbBytes[idx + 1].toInt() and 0xFF
        val b = rgbBytes[idx + 2].toInt() and 0xFF
        pixels[i] = (0xFF shl 24) or (r shl 16) or (g shl 8) or b
    }

    bitmap.setPixels(pixels, 0, width, 0, 0, width, height)

    File(outputPath).parentFile?.mkdirs()
    FileOutputStream(outputPath).use { out ->
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, out)
    }
    bitmap.recycle()
}

// DownloadManagerModule.kt:515-516
if (status == "completed") {
    info.put("completedAt", System.currentTimeMillis())
    info.put("completedEventSent", true)  // Prevents duplicate events
}

@ReactMethod
fun extractText(filePath: String, maxChars: Double, promise: Promise) {
    Thread {
        try {
            val file = File(filePath)
            val limit = maxChars.toInt()
            val core = PdfiumCore(reactApplicationContext)
            val fd = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
            val doc = core.newDocument(fd)
            val pageCount = doc.getPageCount()
            val sb = StringBuilder()

            for (i in 0 until pageCount) {
                val page = doc.openPage(i)
                val textPage = page.openTextPage()
                val charCount = textPage.textPageCountChars()
                if (charCount > 0) {
                    val text = textPage.textPageGetText(0, charCount)
                    if (text != null) sb.append(text).append("\n\n")
                }
                textPage.close()
                page.close()

                if (sb.length >= limit) {
                    sb.setLength(limit)
                    sb.append("\n\n... [Extracted ${i + 1} of $pageCount pages]")
                    break
                }
            }

            doc.close()
            fd.close()
            promise.resolve(sb.toString())
        } catch (e: Exception) {
            promise.reject("PDF_ERROR", "Failed to extract text: ${e.message}", e)
        }
    }.start()
}

// android/app/build.gradle:149
implementation("io.legere:pdfiumandroid:1.0.35")

User Space (Android App)
  ↓
libQnnHtp.so (QNN Backend)
  ↓
FastRPC (IPC to DSP)
  ↓
Hexagon DSP (cDSP)
  ↓
HTP Accelerator (Tensor ops)

android {
    ndkVersion rootProject.ext.ndkVersion
    compileSdk rootProject.ext.compileSdkVersion
    
    defaultConfig {
        applicationId "ai.offgridmobile"
        minSdkVersion 26  // Android 8.0 (for Build.SOC_MODEL in API 31)
        targetSdkVersion 35
    }
    
    packaging {
        jniLibs {
            // Force compressed .so storage so Play Store extracts libs to nativeLibraryDir
            // as real filesystem files. Without this, exec() fails with EACCES (error=13)
            // because you can't fork-exec from a zip entry.
            useLegacyPackaging = true
        }
    }
}

dependencies {
    // Coroutines for async operations (LocalDreamModule)
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
    
    // PDF text extraction (PDFExtractorModule)
    implementation("io.legere:pdfiumandroid:1.0.35")
}

// TypeScript → LocalDreamModule
const params = {
  prompt: "...",
  steps: 20,
  threads: 4  // Optimal for most devices
}

.setAllowedOverMetered(true)
.setAllowedOverRoaming(true)