文件共享 IPC 全面笔记

文件共享 IPC（进程间通信）的原理非常简单：一个进程将数据序列化后写入文件，另一个进程从同一个文件读取并反序列化。

它不依赖 Android 框架特有的 Binder 机制，因此数据量不受 1MB 限制，非常适合传输大文件（视频、图片、大 JSON）。

fun writeDataToFile(targetDir: File, fileName: String, data: ByteArray) {
    val tempFile = File(targetDir, "$fileName.tmp")
    val targetFile = File(targetDir, fileName)
    
    // 流式写入（即使 data 不大，也习惯用流）
    FileOutputStream(tempFile).use { it.write(data) }
    
    // 原子替换，防止读到不完整文件
    tempFile.renameTo(targetFile)
}

fun readDataFromFile(targetDir: File, fileName: String): ByteArray? {
    val targetFile = File(targetDir, fileName)
    return if (targetFile.exists()) targetFile.readBytes() else null
}

对于上百 MB 甚至 GB 级别的文件，绝对不能一次性加载到内存，必须使用缓冲区流式搬运。

suspend fun copyStreamToFile(
    inputStream: InputStream,
    targetDir: File,
    fileName: String,
    bufferSize: Int = 8 * 1024
) = withContext(Dispatchers.IO) {
    val tempFile = File(targetDir, "$fileName.tmp")
    val targetFile = File(targetDir, fileName)

    try {
        FileOutputStream(tempFile).use { output ->
            inputStream.use { input ->
                val buffer = ByteArray(bufferSize)
                var bytesRead: Int
                while (input.read(buffer).also { bytesRead = it } != -1) {
                    output.write(buffer, 0, bytesRead)
                }
            }
        }
        tempFile.renameTo(targetFile)  // 原子替换
    } catch (e: Exception) {
        tempFile.delete()
        throw e
    }
}

• 写入过程中其他进程读到的永远是旧文件或不存在，不会读到半成品
• renameTo在同文件系统下是原子操作，瞬间完成替换

当需要跨进程共享一个巨大的对象列表时，绝不能把所有对象转成内存 List，再一次性序列化成巨大的 JSON 字符串，那会直接 OOM。

应该一边获取数据，一边直接写文件，内存中永远只保留一条数据的大小。

suspend fun writeBooksAsJson(
    booksFlow: Flow,  // 一条一条发射数据
    targetDir: File,
    fileName: String
) = withContext(Dispatchers.IO) {
    val tempFile = File(targetDir, "$fileName.tmp")
    val targetFile = File(targetDir, fileName)

    tempFile.bufferedWriter().use { writer ->
        val jsonWriter = JsonWriter(writer)
        jsonWriter.beginArray()
        booksFlow.collect { book ->
            // 每收到一本书，立刻写入，不堆积在内存
            gson.toJson(book, Book::class.java, jsonWriter)
        }
        jsonWriter.endArray()
    }
    tempFile.renameTo(targetFile)
}

• Flow<Book>不是列表，而是一条一条 异步发射的数据流
• emit(book)发一条 → collect收一条 → 处理一条 → 释放内存，再等下一条
• collect会自动挂起等待，直到所有数据发射完毕才继续执行后续代码

suspend fun readBooksFromJson(
    targetDir: File,
    fileName: String
): Flow<Book> = flow {
    val targetFile = File(targetDir, fileName)
    val reader = targetFile.bufferedReader()
    val jsonReader = JsonReader(reader)
    
    jsonReader.beginArray()
    while (jsonReader.hasNext()) {
        var title = ""
        var author = ""
        jsonReader.beginObject()
        while (jsonReader.hasNext()) {
            when (jsonReader.nextName()) {
                "title" -> title = jsonReader.nextString()
                "author" -> author = jsonReader.nextString()
                else -> jsonReader.skipValue()
            }
        }
        jsonReader.endObject()
        emit(Book(title, author))  // 读出一条，发射一条
    }
    jsonReader.endArray()
    jsonReader.close()
}

设计上规定只有进程 A 写入，其他进程只读。最简单安全。

val raf = RandomAccessFile(file, "rw")
val lock = raf.channel.lock()  // 阻塞，直到获取到锁
try {
    // 执行写操作
} finally {
    lock.release()
    raf.close()
}

• 阻塞的是调用线程，不会直接导致 ANR，但若持有锁时间过长（如大文件写入），会导致业务假死
• 锁绑定进程：进程退出时所有锁自动释放，因此重启 App 可以 100% 解决死锁
• 适用场景：本地小文件、快速写入、追加写（日志、埋点）

• 如果所有操作都共用同一个临时文件名 temp.tmp，多个目标文件并发写入时会互相覆盖
• 每个目标文件拥有独立的临时文件，才能保证并发安全
• 如果只写一个固定文件，可以直接写死临时文件名，省略 fileName参数

tempFile.renameTo(targetFile)在同一个文件系统下会瞬间完成：旧文件被删除（或覆盖），新文件名直接指向临时文件的数据。整个过程不可分割，读取方不会看到中间状态。

• 同一应用内多个进程→ context.getExternalFilesDir(type)，无需权限，安全便捷
• 不同应用间共享→ 使用 FileProvider或自定义 ContentProvider暴露 URI，文件仍保存在内部私有目录，安全且用户不可见

• MutableList<T>是接口，只能用来声明变量类型，不能直接实例化
• mutableListOf()是一个工厂函数，等价于 ArrayList()，是创建可变列表的最简洁方式
• 推荐使用 val list: MutableList<String> = mutableListOf()，符合"面向接口编程"原则

• 同一应用内多个进程交换大视频、大图片
• 解耦的生产者-消费者模型（如日志收集、埋点上报）
• 需要持久化且允许多进程访问的配置文件、缓存数据

• 高频、小数据量、实时性要求高的 IPC → 优先使用 Bundle/Messenger/AIDL
• 不同应用间需要精细权限控制 → 使用 ContentProvider 而非直接暴露文件