@arms/rum-reactnative 0.1.2 → 0.1.3-beta.0

package/android/src/main/java/com/rumsdkreactnative/RumSdkReactnativeModule.kt

@@ -0,0 +1,512 @@
+package com.rumsdkreactnative
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.content.res.Configuration
+import android.os.Build
+import android.provider.Settings
+import android.util.DisplayMetrics
+import android.view.WindowManager
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.rumsdkreactnative.crash.CrashContextManager
+import com.rumsdkreactnative.crash.CrashHandler
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+@ReactModule(name = RumSdkReactnativeModule.NAME)
+class RumSdkReactnativeModule(reactContext: ReactApplicationContext) :
+  NativeRumSdkReactnativeSpec(reactContext) {
+
+  private val prefs: SharedPreferences =
+    migratePrefs(reactContext).also {
+      // 使用迁移后的 prefs
+    }
+
+  private val crashDir: File =
+    File(reactContext.applicationContext.filesDir, CRASH_DIR_NAME)
+
+  private val crashContextManager: CrashContextManager =
+    CrashContextManager(reactContext.applicationContext)
+
+  override fun getName(): String = NAME
+
+  // region Storage
+
+  override fun getItem(key: String, promise: Promise) {
+    try {
+      promise.resolve(prefs.getString(key, null))
+    } catch (e: Throwable) {
+      promise.reject(ERR_STORAGE, e)
+    }
+  }
+
+  override fun setItem(key: String, value: String, promise: Promise) {
+    try {
+      prefs.edit().putString(key, value).apply()
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject(ERR_STORAGE, e)
+    }
+  }
+
+  override fun removeItem(key: String, promise: Promise) {
+    try {
+      prefs.edit().remove(key).apply()
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject(ERR_STORAGE, e)
+    }
+  }
+
+  override fun clear(promise: Promise) {
+    try {
+      prefs.edit().clear().apply()
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject(ERR_STORAGE, e)
+    }
+  }
+
+  override fun getAllKeys(promise: Promise) {
+    try {
+      val array = Arguments.createArray()
+      for (key in prefs.all.keys) {
+        array.pushString(key)
+      }
+      promise.resolve(array)
+    } catch (e: Throwable) {
+      promise.reject(ERR_STORAGE, e)
+    }
+  }
+
+  // endregion
+
+  // region Device Info
+
+  override fun getDeviceInfo(promise: Promise) {
+    try {
+      val ctx = reactApplicationContext
+      val map = Arguments.createMap()
+
+      // device.id - 使用 ANDROID_ID，设备级唯一标识（恢复出厂设置后重置）
+      try {
+        val androidId = Settings.Secure.getString(
+          ctx.contentResolver,
+          Settings.Secure.ANDROID_ID
+        )
+        if (!androidId.isNullOrBlank()) {
+          map.putString("device_id", androidId)
+        }
+      } catch (_: Throwable) {
+        // 部分厂商可能限制访问，忽略
+      }
+
+      // device.brand - 设备品牌，优先 MANUFACTURER（如 "Xiaomi"），BRAND 作为兜底
+      val brand = Build.MANUFACTURER?.takeIf { it.isNotBlank() } ?: Build.BRAND ?: ""
+      map.putString("device_brand", brand)
+
+      // device.model - 设备型号
+      map.putString("device_model", Build.MODEL ?: "")
+
+      // device.name - 设备名称（工业名称，如 "goldfish"）
+      map.putString("device_name", Build.DEVICE ?: "")
+
+      // device.type - 根据屏幕尺寸类别判断 mobile / tablet
+      val screenLayout = ctx.resources.configuration.screenLayout
+      val screenSize = screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK
+      val deviceType = when {
+        screenSize >= Configuration.SCREENLAYOUT_SIZE_LARGE -> "tablet"
+        else -> "mobile"
+      }
+      map.putString("device_type", deviceType)
+
+      // os.type - 操作系统
+      map.putString("os_type", "Android")
+
+      // os.version - 操作系统版本
+      map.putString("os_version", Build.VERSION.RELEASE ?: "")
+
+      // app.package - 应用包名
+      map.putString("app_package", ctx.packageName ?: "")
+
+      // app.version - 应用版本（versionName）
+      try {
+        val packageInfo = ctx.packageManager.getPackageInfo(ctx.packageName, 0)
+        map.putString("app_version", packageInfo.versionName ?: "")
+      } catch (_: Throwable) {
+        // 忽略
+      }
+
+      // viewport - 当前屏幕像素（物理像素）
+      try {
+        val wm = ctx.getSystemService(Context.WINDOW_SERVICE) as? WindowManager
+        val metrics = DisplayMetrics()
+        @Suppress("DEPRECATION")
+        wm?.defaultDisplay?.getRealMetrics(metrics)
+        if (metrics.widthPixels > 0) {
+          map.putInt("viewport_width", metrics.widthPixels)
+          map.putInt("viewport_height", metrics.heightPixels)
+        }
+      } catch (_: Throwable) {
+        // 忽略
+      }
+
+      promise.resolve(map)
+    } catch (e: Throwable) {
+      promise.reject(ERR_DEVICE_INFO, e)
+    }
+  }
+
+  // endregion
+
+  // region Crash
+
+  /**
+   * 读取 crashDir 下所有崩溃报告文件，组装为 JSONArray 字符串返回。
+   * 崩溃文件命名：crash_{timestamp}_{id}.json（Java）或 crash_native_{timestamp}_{pid}.json（NDK）
+   * 注意：排除 context 文件（.rum_crash_context）和临时文件
+   */
+  override fun getPendingCrashes(promise: Promise) {
+    try {
+      val arr = JSONArray()
+      if (crashDir.exists() && crashDir.isDirectory) {
+        // NDK 崩溃的信号处理器只写 crash-specific 数据（signal/frames/arch 等），
+        // 不包含 context/device/app 字段。Java 崩溃在 captureAndPersist 中已写入这些字段。
+        // 在此处统一读取 context 文件和构建设备/应用信息，为缺少这些字段的 NDK 崩溃补入。
+        val crashContext = try {
+          crashContextManager.readContext() ?: JSONObject()
+        } catch (_: Throwable) {
+          JSONObject()
+        }
+        val deviceInfo = try {
+          CrashHandler.buildDevice()
+        } catch (_: Throwable) {
+          JSONObject()
+        }
+        val appInfo = try {
+          CrashHandler.buildApp(reactApplicationContext.applicationContext)
+        } catch (_: Throwable) {
+          JSONObject()
+        }
+
+        val files = crashDir.listFiles { f ->
+          isCrashReportFile(f.name)
+        }
+        files?.sortedBy { it.lastModified() }?.forEach { file ->
+          try {
+            val text = file.readText(Charsets.UTF_8)
+            if (text.isNotEmpty()) {
+              // 解析为 JSONObject 后放入数组，确保 JS 层 JSON.parse 后获得对象数组。
+              // NDK 崩溃写入器在 binary_images 循环中发生二次崩溃时，核心崩溃数据
+              // （crash_id/timestamp/signal/frames）虽已落盘但 JSON 不完整（缺少
+              // 闭合 ]}），JSONObject(text) 会抛异常导致核心数据完全丢失。
+              // 尝试修复截断的 JSON 以恢复核心数据。
+              val json = try {
+                JSONObject(text)
+              } catch (_: Throwable) {
+                val repaired = repairTruncatedJson(text)
+                if (repaired != null) {
+                  try { JSONObject(repaired) } catch (_: Throwable) { null }
+                } else null
+              }
+              if (json != null) {
+                // 补全 NDK 崩溃缺失的 context/device/app 字段。
+                // 仅在字段不存在时补入，避免覆盖 Java 崩溃已有的数据。
+                if (!json.has("context")) {
+                  json.put("context", crashContext)
+                }
+                if (!json.has("device")) {
+                  json.put("device", deviceInfo)
+                }
+                if (!json.has("app")) {
+                  json.put("app", appInfo)
+                }
+                // 为 NDK 崩溃补全 platform/exception/crashed_thread/mechanism 等结构化字段
+                CrashHandler.enrichNdkCrash(json)
+                arr.put(json)
+              }
+            }
+          } catch (_: Throwable) {
+            // ignore single file
+          }
+        }
+      }
+      promise.resolve(arr.toString())
+    } catch (e: Throwable) {
+      promise.reject(ERR_CRASH, e)
+    }
+  }
+
+  /**
+   * 解析 crashIds JSON array，按 crash_id 删除对应文件。
+   */
+  override fun clearCrashReports(crashIds: String, promise: Promise) {
+    try {
+      val ids = HashSet<String>()
+      if (crashIds.isNotEmpty()) {
+        try {
+          val parsed = JSONArray(crashIds)
+          for (i in 0 until parsed.length()) {
+            val id = parsed.optString(i, null) ?: continue
+            if (id.isNotEmpty()) ids.add(id)
+          }
+        } catch (_: Throwable) {
+          // ignore parse error
+        }
+      }
+      if (ids.isNotEmpty() && crashDir.exists() && crashDir.isDirectory) {
+        val files = crashDir.listFiles { f ->
+          isCrashReportFile(f.name)
+        }
+        files?.forEach { file ->
+          try {
+            // 策略 1：通过文件名匹配（Java 崩溃 + 修复后的 NDK 崩溃）
+            // crash_id 现在为 crash_native_{ts}_{pid}，与文件名 nameWithoutExt 完全一致
+            var matched = false
+            for (id in ids) {
+              val nameWithoutExt = file.nameWithoutExtension
+              if (nameWithoutExt.endsWith("_$id") || nameWithoutExt == id) {
+                file.delete()
+                matched = true
+                break
+              }
+            }
+            if (matched) return@forEach
+
+            // 策略 2：通过文件内容中的 crash_id 字段匹配（历史遗留 NDK 崩溃）
+            // 旧版 NDK 崩溃文件名为 crash_native_{ts}_{pid}，但 crash_id 为 ndk_{ts}_{pid}，
+            // 文件名匹配失败。读取文件 JSON 中的 crash_id 进行精确匹配。
+            val text = file.readText(Charsets.UTF_8)
+            if (text.isNotEmpty()) {
+              val json = try { JSONObject(text) } catch (_: Throwable) {
+                val repaired = repairTruncatedJson(text)
+                if (repaired != null) {
+                  try { JSONObject(repaired) } catch (_: Throwable) { null }
+                } else null
+              }
+              if (json != null) {
+                val crashId = json.optString("crash_id", "")
+                if (crashId.isNotEmpty() && ids.contains(crashId)) {
+                  file.delete()
+                }
+              }
+            }
+          } catch (_: Throwable) {
+            // ignore
+          }
+        }
+      }
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject(ERR_CRASH, e)
+    }
+  }
+
+  /** 上次运行是否发生过崩溃：crashDir 中存在崩溃报告文件即认为发生过 */
+  override fun crashedLastRun(promise: Promise) {
+    try {
+      val crashed = crashDir.exists() &&
+        (crashDir.listFiles()?.any { it.isFile && isCrashReportFile(it.name) } ?: false)
+      promise.resolve(crashed)
+    } catch (e: Throwable) {
+      promise.reject(ERR_CRASH, e)
+    }
+  }
+
+  /** 更新崩溃上下文快照（session/view 变更时调用） */
+  override fun updateCrashContext(context: String) {
+    try {
+      crashContextManager.updateContext(context)
+    } catch (_: Throwable) {
+      // ignore
+    }
+  }
+
+  /** 清除所有崩溃报告文件（用于清理无 crash_id 的旧版 NDK 文件） */
+  override fun clearAllCrashReports(promise: Promise) {
+    try {
+      if (crashDir.exists() && crashDir.isDirectory) {
+        val files = crashDir.listFiles { f -> isCrashReportFile(f.name) }
+        files?.forEach { file ->
+          try {
+            file.delete()
+          } catch (_: Throwable) {
+            // ignore
+          }
+        }
+      }
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject(ERR_CRASH, e)
+    }
+  }
+
+  /** 清理过期和超限的崩溃文件 */
+  override fun cleanupOldCrashes(maxFiles: Double, maxAgeMs: Double, promise: Promise) {
+    try {
+      if (!crashDir.exists() || !crashDir.isDirectory) {
+        promise.resolve(null)
+        return
+      }
+
+      val maxFileCount = maxFiles.toInt().coerceAtLeast(1)
+      val maxAge = maxAgeMs.toLong()
+      val now = System.currentTimeMillis()
+
+      val files = crashDir.listFiles { f -> isCrashReportFile(f.name) }
+        ?.sortedByDescending { it.lastModified() }
+        ?: emptyList()
+
+      // 1. 删除过期文件
+      val remaining = files.filter { file ->
+        val expired = now - file.lastModified() > maxAge
+        if (expired) {
+          try { file.delete() } catch (_: Throwable) {}
+        }
+        !expired
+      }
+
+      // 2. 超过上限时删除最旧的
+      if (remaining.size > maxFileCount) {
+        remaining.drop(maxFileCount).forEach { file ->
+          try { file.delete() } catch (_: Throwable) {}
+        }
+      }
+
+      promise.resolve(null)
+    } catch (e: Throwable) {
+      promise.reject(ERR_CRASH, e)
+    }
+  }
+
+  /**
+   * 尝试修复截断的 JSON 文本。
+   * NDK 崩溃写入器在写入过程中发生二次崩溃时，落盘的 JSON 可能缺少闭合括号。
+   * 本方法去除末尾多余逗号，统计未闭合的 { 和 [（正确处理字符串内的引号转义），
+   * 追加对应数量的 ] 和 } 闭合字符。
+   *
+   * @return 修复后的 JSON 字符串；如果 JSON 已完整或无法修复则返回 null
+   */
+  private fun repairTruncatedJson(text: String): String? {
+    var s = text.trimEnd()
+    // 去除末尾逗号
+    while (s.endsWith(",")) s = s.dropLast(1)
+    // 统计未闭合的括号
+    var braces = 0
+    var brackets = 0
+    var inStr = false
+    var esc = false
+    for (c in s) {
+      if (esc) { esc = false; continue }
+      if (c == '\\') { esc = true; continue }
+      if (c == '"') { inStr = !inStr; continue }
+      if (inStr) continue
+      when (c) {
+        '{' -> braces++
+        '}' -> braces--
+        '[' -> brackets++
+        ']' -> brackets--
+      }
+    }
+    if (brackets < 0 || braces < 0) return null
+    if (brackets == 0 && braces == 0) return null // JSON 已经完整，不需要修复
+    // 若截断发生在字符串值内部（inStr == true），需先补上闭合引号，
+    // 否则追加 ]} 后仍是非法 JSON，JSONObject(repaired) 会抛异常导致核心崩溃数据丢失。
+    val prefix = if (inStr) "\"" else ""
+    return prefix + s + "]".repeat(brackets) + "}".repeat(braces)
+  }
+
+  // endregion
+
+  // region Test Crash
+
+  private external fun nativeTriggerCrash(type: Int)
+
+  override fun triggerTestCrash(crashType: String) {
+    when (crashType) {
+      // TurboModule 架构下，@ReactMethod void 方法中抛出的 Java 异常会被 C++ 层
+      // 拦截并转换为 JS 异常，不会到达 Thread.getDefaultUncaughtExceptionHandler()。
+      // 在新线程中抛出异常，可正确触发 CrashHandler 捕获并写入崩溃文件。
+      "java_exception" -> {
+        Thread {
+          throw RuntimeException("RUM SDK Test: Uncaught Java Exception")
+        }.apply { name = "rum-test-crash" }.start()
+        // 给新线程足够时间触发 UncaughtExceptionHandler，确保崩溃先于
+        // 方法返回触发，E2E 测试才能正确捕获 reject。
+        Thread.sleep(100)
+      }
+      "sigsegv" -> nativeTriggerCrash(0)
+      "sigabrt" -> nativeTriggerCrash(1)
+      "sigfpe" -> nativeTriggerCrash(2)
+      "cpp_exception" -> nativeTriggerCrash(3)
+      "stack_overflow" -> nativeTriggerCrash(4)
+    }
+  }
+
+  // endregion
+
+  companion object {
+    const val NAME = "RumSdkReactnative"
+    private const val PREFS_NAME = "com.aliyun.rum.reactnative"
+    private const val LEGACY_PREFS_NAME = "com.aliyun.arms.rum.reactnative"
+    private const val CRASH_DIR_NAME = "rum_crashes"
+    private const val ERR_STORAGE = "RUM_STORAGE_ERROR"
+    private const val ERR_DEVICE_INFO = "RUM_DEVICE_INFO_ERROR"
+    private const val ERR_CRASH = "RUM_CRASH_ERROR"
+
+    init {
+      try {
+        System.loadLibrary("rum_crash")
+      } catch (_: UnsatisfiedLinkError) {
+        // Library may already be loaded by NdkCrashHandler
+      }
+    }
+
+    /**
+     * 迁移旧版 SharedPreferences（com.aliyun.arms.rum.reactnative → com.aliyun.rum.reactnative）
+     */
+    private fun migratePrefs(context: android.content.Context): SharedPreferences {
+      val newPrefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      val legacyPrefs = context.getSharedPreferences(LEGACY_PREFS_NAME, Context.MODE_PRIVATE)
+      val legacyData = legacyPrefs.all
+      if (legacyData.isNotEmpty()) {
+        val editor = newPrefs.edit()
+        for ((key, value) in legacyData) {
+          if (!newPrefs.contains(key)) {
+            when (value) {
+              is String -> editor.putString(key, value)
+              is Int -> editor.putInt(key, value)
+              is Long -> editor.putLong(key, value)
+              is Boolean -> editor.putBoolean(key, value)
+              is Float -> editor.putFloat(key, value)
+              is Set<*> -> {
+                @Suppress("UNCHECKED_CAST")
+                editor.putStringSet(key, value as Set<String>)
+              }
+            }
+          }
+        }
+        editor.apply()
+        legacyPrefs.edit().clear().apply()
+      }
+      return newPrefs
+    }
+
+    /**
+     * 判断文件名是否为崩溃报告文件（排除 context 文件和临时文件）。
+     * 崩溃文件：crash_*.json（Java）或 crash_native_*.json（NDK）
+     * 非崩溃：.rum_crash_context、crash_context.json（旧版）、.arms_crash_context（旧版）、*.tmp
+     */
+    private fun isCrashReportFile(name: String): Boolean {
+      if (!name.endsWith(".json")) return false
+      if (!name.startsWith("crash_")) return false
+      // 排除旧版 context 文件（升级后可能残留）
+      if (name == "crash_context.json") return false
+      return true
+    }
+  }
+}

package/android/src/main/java/com/rumsdkreactnative/RumSdkReactnativePackage.kt

@@ -0,0 +1,33 @@
+package com.rumsdkreactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class RumSdkReactnativePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == RumSdkReactnativeModule.NAME) {
+      RumSdkReactnativeModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[RumSdkReactnativeModule.NAME] = ReactModuleInfo(
+        RumSdkReactnativeModule.NAME,
+        RumSdkReactnativeModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/android/src/main/java/com/rumsdkreactnative/crash/CrashContextManager.kt

@@ -0,0 +1,157 @@
+package com.rumsdkreactnative.crash
+
+import android.content.Context
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStreamReader
+
+/**
+ * 崩溃上下文管理器：
+ * - context 文件：单条 JSON，包含 session_id / view_id / view_name 等。原子写入（写临时文件 → rename）
+ *
+ * 注意：所有写入都基于普通文件 IO（非 SharedPreferences），保证 native crash 时也能被 fork 子进程读取。
+ */
+class CrashContextManager(context: Context) {
+
+  private val baseDir: File = File(context.filesDir, CRASH_DIR_NAME).apply {
+    // 迁移旧版目录 arms_crashes → rum_crashes
+    val legacyDir = File(context.filesDir, LEGACY_CRASH_DIR_NAME)
+    if (legacyDir.exists() && legacyDir.isDirectory) {
+      try {
+        if (!exists()) {
+          legacyDir.renameTo(this)
+        } else {
+          legacyDir.listFiles()?.forEach { file ->
+            val target = File(this, file.name)
+            if (!target.exists()) file.renameTo(target)
+          }
+          legacyDir.delete()
+        }
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+    if (!exists()) {
+      try {
+        mkdirs()
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+  }
+
+  private val contextFile: File = File(baseDir, CONTEXT_FILE)
+  private val contextTmpFile: File = File(baseDir, "$CONTEXT_FILE.tmp")
+
+  init {
+    // 迁移清理：删除旧版 crash_context.json，迁移 .arms_crash_context → .rum_crash_context
+    migrateLegacyContextFile()
+  }
+
+  private fun migrateLegacyContextFile() {
+    try {
+      // 删除最早版本的 context 文件（json 后缀，会被崩溃过滤器误匹配）
+      val legacyJson = File(baseDir, LEGACY_CONTEXT_FILE)
+      if (legacyJson.exists()) {
+        legacyJson.delete()
+      }
+      // 迁移 .arms_crash_context → .rum_crash_context
+      val legacyArms = File(baseDir, LEGACY_ARMS_CONTEXT_FILE)
+      if (legacyArms.exists()) {
+        if (!contextFile.exists()) {
+          legacyArms.renameTo(contextFile)
+        } else {
+          legacyArms.delete()
+        }
+      }
+    } catch (_: Throwable) {
+      // ignore
+    }
+  }
+
+  // ===== Context =====
+
+  /** 原子写入上下文（写临时文件 → rename） */
+  @Synchronized
+  fun updateContext(jsonString: String) {
+    if (jsonString.isEmpty()) return
+    ensureDir()
+    var fos: FileOutputStream? = null
+    try {
+      fos = FileOutputStream(contextTmpFile)
+      fos.write(jsonString.toByteArray(Charsets.UTF_8))
+      fos.flush()
+      try {
+        fos.fd.sync()
+      } catch (_: Throwable) {
+        // ignore
+      }
+      try {
+        fos.close()
+      } catch (_: Throwable) {
+        // ignore
+      }
+      fos = null
+      // POSIX rename 保证原子替换目标文件，无需先 delete
+      try {
+        contextTmpFile.renameTo(contextFile)
+      } catch (_: Throwable) {
+        // ignore
+      }
+    } catch (_: Throwable) {
+      // ignore
+    } finally {
+      try {
+        fos?.close()
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+  }
+
+  fun readContext(): JSONObject? {
+    if (!contextFile.exists()) return null
+    return try {
+      val text = readAllText(contextFile)
+      if (text.isEmpty()) null else JSONObject(text)
+    } catch (_: Throwable) {
+      null
+    }
+  }
+
+  // ===== Helpers =====
+
+  private fun ensureDir() {
+    if (!baseDir.exists()) {
+      try {
+        baseDir.mkdirs()
+      } catch (_: Throwable) {
+        // ignore
+      }
+    }
+  }
+
+  private fun readAllText(file: File): String {
+    return try {
+      file.inputStream().use { input ->
+        BufferedReader(InputStreamReader(input, Charsets.UTF_8)).use { reader ->
+          reader.readText()
+        }
+      }
+    } catch (_: Throwable) {
+      ""
+    }
+  }
+
+  companion object {
+    private const val CRASH_DIR_NAME = "rum_crashes"
+    private const val LEGACY_CRASH_DIR_NAME = "arms_crashes"
+    // 使用 .rum_ 前缀 + 非 .json 后缀，避免被崩溃文件过滤器误匹配
+    private const val CONTEXT_FILE = ".rum_crash_context"
+    // 旧版文件名（用于升级时迁移清理）
+    private const val LEGACY_CONTEXT_FILE = "crash_context.json"
+    private const val LEGACY_ARMS_CONTEXT_FILE = ".arms_crash_context"
+  }
+}