@keepsnappy/react-native 0.0.0-stage → 0.1.0-alpha.11

package/android/src/main/java/expo/modules/perflab/PerfLabSampler.kt

@@ -0,0 +1,515 @@
+package expo.modules.perflab
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.hardware.display.DisplayManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.Looper
+import android.os.PowerManager
+import android.os.Process
+import android.system.Os
+import android.system.OsConstants
+import android.view.Choreographer
+import android.view.Display
+import android.view.FrameMetrics
+import android.view.ViewTreeObserver
+import android.view.Window
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
+
+// System.nanoTime() is CLOCK_MONOTONIC, the clock of performance.now() in React Native.
+internal fun perfLabMonotonicMs(): Double = System.nanoTime() / 1_000_000.0
+
+// PowerManager.THERMAL_STATUS_* (0 none .. 6 shutdown) mapped to the iOS ProcessInfo.thermalState
+// scale (0 nominal .. 3 critical) that derive and the heat rule read (`thermal >= 2` = serious):
+// none and light -> 0, moderate -> 1, severe -> 2, critical, emergency, shutdown -> 3.
+private const val THERMAL_ANDROID_MODERATE = 2
+private const val THERMAL_ANDROID_SEVERE = 3
+private const val THERMAL_ANDROID_CRITICAL = 4
+
+internal fun perfLabThermalLevel(raw: Int): Int = when {
+  raw >= THERMAL_ANDROID_CRITICAL -> 3
+  raw >= THERMAL_ANDROID_SEVERE -> 2
+  raw >= THERMAL_ANDROID_MODERATE -> 1
+  else -> 0
+}
+
+// Fallback until the SDK configures the sampler; same value as SAMPLER_MS_DEFAULT in js/sdk/sampler.ts.
+private const val SAMPLER_MS_DEFAULT = 4000.0
+
+// Longest take() waits for the sampler thread: a sample costs ~2 ms, so this is some twenty queued samples. A reconfigure
+// that shuts the executor down discards the queued task; the wait then ends here with null instead of hanging the JS thread.
+private const val TAKE_TIMEOUT_MS = 50L
+
+private val JS_THREAD_NAMES = listOf("mqt_v_js", "mqt_js")
+
+// Counts presented and missed frames on the main thread's Choreographer. The budget follows the
+// display's current refresh rate (read off the frame path), so 90/120 Hz screens are judged right.
+// The callback allocates nothing: it reuses itself and touches only primitive fields.
+internal class PerfLabFrameCounter : Choreographer.FrameCallback {
+  private val lock = Any()
+  private val main = Handler(Looper.getMainLooper())
+  @Volatile private var running = false
+  @Volatile var budgetNs: Long = 16_666_667L
+  private var lastFrameNs = 0L
+  private var presentedTotal = 0L
+  private var missedTotal = 0L
+  private var longestGapNs = 0L
+
+  private val startOnMain = Runnable {
+    lastFrameNs = 0L
+    Choreographer.getInstance().postFrameCallback(this)
+  }
+
+  private val stopOnMain = Runnable {
+    Choreographer.getInstance().removeFrameCallback(this)
+  }
+
+  fun start() {
+    if (running) return
+    running = true
+    main.post(startOnMain)
+  }
+
+  fun stop() {
+    running = false
+    main.post(stopOnMain)
+  }
+
+  override fun doFrame(frameTimeNanos: Long) {
+    if (!running) return
+    if (lastFrameNs > 0L) {
+      val gap = frameTimeNanos - lastFrameNs
+      val budget = budgetNs
+      val missed = if (budget > 0L) maxOf(0L, Math.round(gap.toDouble() / budget) - 1L) else 0L
+      synchronized(lock) {
+        presentedTotal++
+        missedTotal += missed
+        if (gap > longestGapNs) longestGapNs = gap
+      }
+    }
+    lastFrameNs = frameTimeNanos
+    Choreographer.getInstance().postFrameCallback(this)
+  }
+
+  // Totals are cumulative; the longest gap restarts with every read.
+  fun read(): LongArray = synchronized(lock) {
+    val out = longArrayOf(presentedTotal, missedTotal, longestGapNs)
+    longestGapNs = 0L
+    out
+  }
+}
+
+// The frame budget when the display rate is unknown: 60 Hz.
+private const val BUDGET_NS_FALLBACK = 16_666_667L
+
+internal const val FRAMES_SOURCE = "framemetrics"
+internal const val JANK_BASIS_DEADLINE = "deadline"
+internal const val JANK_BASIS_DISPLAY_RATE = "display-rate"
+
+// Counts the frames the app's foreground activity window draws (Window.OnFrameMetricsAvailableListener, API 24+) and those that
+// overran their deadline (TOTAL_DURATION > DEADLINE, "overrun > 0" like JankStats; gfxinfo's JankTracker also skips
+// buffer-stuffing frames, so its count can be lower). Unlike the Choreographer counter it sees only frames that were drawn,
+// so idle time on an adaptive-refresh panel is no longer a miss. API 31+: the frame's own FrameMetrics.DEADLINE. Below 31:
+// the current display frame interval (`budgetNs`, from Display.getRefreshRate()); `jankBasis` says which.
+// The first draw after a window attach is neither jank nor the longest frame (it pays for the attach). Frames the framework
+// dropped before reporting them (dropCountSinceLastInvocation) are counted in `droppedTotal`, not as drawn.
+// Each frame is counted when it ends (INTENDED_VSYNC_TIMESTAMP + TOTAL_DURATION, the clock of System.nanoTime) at the first
+// read taken after that moment, so a frame that finished before a sample is in that sample's interval and not the next one.
+// A report that reaches the listener after the sample it ended before (a few ms of delivery delay) lands in the next
+// interval. Not seen: other windows (RN Modal dialogs, popups) and SurfaceView/TextureView content (video, Skia canvases);
+// `windowCovered` says another window held focus during the interval, so the counts of that interval are unknown.
+// Follows the foreground activity through lifecycle callbacks; the listener runs on its own thread, never the UI thread.
+internal class PerfLabFrameMetrics(private val context: () -> Context?) :
+  Window.OnFrameMetricsAvailableListener, Application.ActivityLifecycleCallbacks, ViewTreeObserver.OnWindowFocusChangeListener {
+  private class Frame(val endNs: Long, val jank: Boolean, val firstDraw: Boolean, val durationNs: Long, val dropped: Int)
+
+  private val lock = Any()
+  private val main = Handler(Looper.getMainLooper())
+  @Volatile var budgetNs: Long = BUDGET_NS_FALLBACK
+  private var thread: HandlerThread? = null
+  private var handler: Handler? = null
+  private var application: Application? = null
+  private var attached: Window? = null
+  private val pending = ArrayList<Frame>()
+  private var drawnTotal = 0L
+  private var jankTotal = 0L
+  private var droppedTotal = 0L
+  private var covered = false
+  private var coveredInInterval = false
+
+  val jankBasis: String
+    get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) JANK_BASIS_DEADLINE else JANK_BASIS_DISPLAY_RATE
+
+  fun start(current: Activity?) {
+    if (thread != null) return
+    val app = context()?.applicationContext as? Application ?: return
+    val t = HandlerThread("perflab-framemetrics").also { it.start() }
+    thread = t
+    handler = Handler(t.looper)
+    application = app
+    main.post {
+      app.registerActivityLifecycleCallbacks(this)
+      current?.let { attach(it) }
+    }
+  }
+
+  fun stop() {
+    val app = application ?: return
+    val t = thread
+    application = null
+    thread = null
+    handler = null
+    main.post {
+      app.unregisterActivityLifecycleCallbacks(this)
+      detach()
+      t?.quitSafely()
+    }
+    synchronized(lock) { pending.clear() }
+  }
+
+  // Main thread only.
+  private fun attach(activity: Activity) {
+    val h = handler ?: return
+    if (activity.isFinishing || activity.isDestroyed) return
+    val window = activity.window ?: return
+    if (window === attached) return
+    detach()
+    try {
+      window.addOnFrameMetricsAvailableListener(this, h)
+      window.decorView.viewTreeObserver.addOnWindowFocusChangeListener(this)
+      attached = window
+      synchronized(lock) { covered = false }
+    } catch (e: IllegalStateException) {
+      // Window not hardware accelerated: no frame metrics from it.
+    }
+  }
+
+  // Main thread only.
+  private fun detach() {
+    attached?.let {
+      try {
+        it.removeOnFrameMetricsAvailableListener(this)
+        it.decorView.viewTreeObserver.removeOnWindowFocusChangeListener(this)
+      } catch (e: IllegalArgumentException) {
+        // Already gone with its window.
+      }
+    }
+    attached = null
+  }
+
+  override fun onWindowFocusChanged(hasFocus: Boolean) {
+    synchronized(lock) {
+      covered = !hasFocus
+      if (!hasFocus) coveredInInterval = true
+    }
+  }
+
+  override fun onActivityResumed(activity: Activity) = attach(activity)
+
+  override fun onActivityPaused(activity: Activity) {
+    if (attached === activity.window) detach()
+  }
+
+  override fun onActivityDestroyed(activity: Activity) {
+    if (attached === activity.window) detach()
+  }
+
+  override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+  override fun onActivityStarted(activity: Activity) {}
+  override fun onActivityStopped(activity: Activity) {}
+  override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+
+  override fun onFrameMetricsAvailable(window: Window, frameMetrics: FrameMetrics, dropCountSinceLastInvocation: Int) {
+    val total = frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
+    val limit = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) frameMetrics.getMetric(FrameMetrics.DEADLINE) else budgetNs
+    val firstDraw = frameMetrics.getMetric(FrameMetrics.FIRST_DRAW_FRAME) == 1L
+    val end = frameMetrics.getMetric(FrameMetrics.INTENDED_VSYNC_TIMESTAMP) + total
+    synchronized(lock) {
+      pending.add(Frame(end, !firstDraw && limit > 0L && total > limit, firstDraw, total, dropCountSinceLastInvocation))
+    }
+  }
+
+  // Counts every frame that ended at or before untilNs. Totals are cumulative; the longest frame (-1: none was drawn) and
+  // the covered flag restart with every read.
+  fun read(untilNs: Long): LongArray = synchronized(lock) {
+    var longest = -1L
+    val it = pending.iterator()
+    while (it.hasNext()) {
+      val f = it.next()
+      if (f.endNs > untilNs) continue
+      it.remove()
+      drawnTotal++
+      droppedTotal += f.dropped
+      if (f.jank) jankTotal++
+      if (!f.firstDraw && f.durationNs > longest) longest = f.durationNs
+    }
+    val out = longArrayOf(drawnTotal, jankTotal, longest, droppedTotal, if (coveredInInterval) 1L else 0L)
+    coveredInInterval = covered
+    out
+  }
+}
+
+// Off unless configured. `auto` samples on its own thread every intervalMs and needs no JS;
+// `manual` only keeps the frame counter running and samples when asked. Every sample is logged
+// as `PERF_LAB sample {json}` and kept in a short ring for windows.
+// UNTESTED ON DEVICE: written against the iOS implementation, compiled only.
+internal class PerfLabSampler(
+  private val context: () -> Context?,
+  private val activity: () -> Activity?,
+  private val log: (String) -> Unit,
+) {
+  private val lock = Any()
+  private val frames = PerfLabFrameCounter()
+  private val frameMetrics = PerfLabFrameMetrics(context)
+  private var executor: ScheduledExecutorService? = null
+  private var mode = "off"
+  private var intervalMs = SAMPLER_MS_DEFAULT
+  private var seq = 0
+  private var previous: DoubleArray? = null
+  private val ring = ArrayDeque<Map<String, Any?>>()
+  private val ringSize = 64
+  // Records of samplerRequest, kept outside the ring until taken, so a long window still finds its open sample.
+  private val pinned = ArrayDeque<Pair<String, Map<String, Any?>>>()
+  private val pinnedMax = 32
+  private var jsTid = -1
+  private var jsThreadName: String? = null
+  private var scans = 0
+  private var maxHz = 0
+  private val tickMs = 1000.0 / Os.sysconf(OsConstants._SC_CLK_TCK).coerceAtLeast(1L)
+
+  fun configure(newMode: String, newIntervalMs: Double): Map<String, Any?> = synchronized(lock) {
+    mode = if (newMode == "auto" || newMode == "manual") newMode else "off"
+    intervalMs = maxOf(250.0, newIntervalMs)
+    executor?.shutdownNow()
+    executor = null
+    if (mode == "off") {
+      frames.stop()
+      frameMetrics.stop()
+      previous = null
+      ring.clear()
+      pinned.clear()
+      jsTid = -1
+      jsThreadName = null
+    } else {
+      updateBudget()
+      maxHz = maxRefreshHz()
+      frames.start()
+      frameMetrics.start(activity())
+      val ex = Executors.newSingleThreadScheduledExecutor { r -> Thread(r, "perflab-sampler") }
+      if (mode == "auto") {
+        val period = intervalMs.toLong()
+        ex.scheduleAtFixedRate({ synchronized(lock) { collect("auto") } }, period, period, TimeUnit.MILLISECONDS)
+      }
+      executor = ex
+    }
+    mapOf("mode" to mode, "intervalMs" to intervalMs, "nowMs" to perfLabMonotonicMs())
+  }
+
+  fun sample(reason: String): Map<String, Any?>? = synchronized(lock) {
+    if (mode == "off") null else collect(reason)
+  }
+
+  // Returns at once; the sample is taken on the sampler thread (record time is taken there) and lands in the ring.
+  fun request(reason: String) {
+    val ex = synchronized(lock) { executor } ?: return
+    try {
+      ex.execute {
+        synchronized(lock) {
+          if (mode != "off") {
+            pinned.addLast(reason to collect(reason))
+            if (pinned.size > pinnedMax) pinned.removeFirst()
+          }
+        }
+      }
+    } catch (e: java.util.concurrent.RejectedExecutionException) {
+      // Reconfigured meanwhile: the request is dropped.
+    }
+  }
+
+  // Waits behind the requests already queued on the sampler thread, so a just-made request is found.
+  fun take(reason: String): Map<String, Any?>? {
+    val ex = synchronized(lock) { executor } ?: return null
+    val task = try {
+      ex.submit<Map<String, Any?>?> {
+        synchronized(lock) {
+          val index = pinned.indexOfFirst { it.first == reason }
+          if (index < 0) null else pinned.removeAt(index).second
+        }
+      }
+    } catch (e: Exception) {
+      return null
+    }
+    return try {
+      task.get(TAKE_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+    } catch (e: Exception) {
+      task.cancel(false)
+      null
+    }
+  }
+
+  fun recent(since: Double): List<Map<String, Any?>> = synchronized(lock) {
+    ring.filter { ((it["t"] as? Double) ?: 0.0) >= since }
+  }
+
+  private fun updateBudget() {
+    val hz = display()?.refreshRate ?: 60f
+    if (hz > 1f) {
+      val ns = (1_000_000_000.0 / hz).toLong()
+      frames.budgetNs = ns
+      frameMetrics.budgetNs = ns
+    }
+  }
+
+  // Highest refresh rate the panel can run (iOS: maximumFramesPerSecond), rounded like a marketing
+  // figure: modes report 120.00001 for a 120 Hz panel.
+  private fun maxRefreshHz(): Int {
+    val modes = display()?.supportedModes ?: return 0
+    log("PERF_LAB display modes " + modes.joinToString(" ") { "${it.modeId}:${it.physicalWidth}x${it.physicalHeight}@${it.refreshRate}" })
+    return modes.maxOfOrNull { Math.round(it.refreshRate) } ?: 0
+  }
+
+  private fun display(): Display? {
+    val ctx = context() ?: return null
+    val manager = ctx.getSystemService(Context.DISPLAY_SERVICE) as? DisplayManager ?: return null
+    return manager.getDisplay(Display.DEFAULT_DISPLAY)
+  }
+
+  // utime + stime (fields 14 and 15) of a /proc stat line, after the parenthesised comm.
+  private fun statCpuMs(path: String): Double? = try {
+    val text = File(path).readText()
+    val fields = text.substring(text.lastIndexOf(')') + 2).split(' ')
+    (fields[11].toLong() + fields[12].toLong()) * tickMs
+  } catch (e: Exception) {
+    null
+  }
+
+  private fun findJsThread() {
+    val tasks = File("/proc/self/task").listFiles() ?: return
+    for (task in tasks) {
+      val name = try { File(task, "comm").readText().trim() } catch (e: Exception) { continue }
+      if (JS_THREAD_NAMES.any { name == it }) {
+        jsTid = task.name.toIntOrNull() ?: continue
+        jsThreadName = name
+        return
+      }
+    }
+  }
+
+  private fun jsCpuMs(): Double? {
+    if (jsTid > 0) {
+      statCpuMs("/proc/self/task/$jsTid/stat")?.let { return it }
+      jsTid = -1
+      jsThreadName = null
+    }
+    if (scans % 5 == 0) findJsThread()
+    scans++
+    return if (jsTid > 0) statCpuMs("/proc/self/task/$jsTid/stat") else null
+  }
+
+  // Closest analog of iOS phys_footprint: anonymous resident memory plus swapped (zram) pages.
+  private fun memoryMb(): Map<String, Any?> = try {
+    var rss = -1L
+    var anon = -1L
+    var swap = 0L
+    File("/proc/self/status").forEachLine { line ->
+      when {
+        line.startsWith("VmRSS:") -> rss = kb(line)
+        line.startsWith("RssAnon:") -> anon = kb(line)
+        line.startsWith("VmSwap:") -> swap = kb(line)
+      }
+    }
+    mapOf(
+      "footprintMb" to if (anon >= 0) (anon + swap) / 1024.0 else null,
+      "residentMb" to if (rss >= 0) rss / 1024.0 else null,
+    ).filterValues { it != null }
+  } catch (e: Exception) {
+    emptyMap()
+  }
+
+  private fun kb(line: String): Long = line.substringAfter(':').trim().substringBefore(' ').toLongOrNull() ?: -1L
+
+  private fun thermalRaw(): Int? {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return null
+    val pm = context()?.getSystemService(Context.POWER_SERVICE) as? PowerManager ?: return null
+    return pm.currentThermalStatus
+  }
+
+  private fun collect(reason: String): Map<String, Any?> {
+    val started = perfLabMonotonicMs()
+    val t = started
+    val processMs = Process.getElapsedCpuTime().toDouble()
+    val mainMs = statCpuMs("/proc/self/task/${Process.myPid()}/stat")
+    val jsMs = jsCpuMs()
+    val memory = memoryMb()
+    updateBudget()
+    val frame = frames.read()
+    val drawn = frameMetrics.read(System.nanoTime())
+    seq++
+
+    val cpu = mutableMapOf<String, Any?>("processMs" to processMs)
+    mainMs?.let { cpu["mainMs"] = it }
+    jsMs?.let { cpu["jsMs"] = it }
+    jsThreadName?.let { cpu["jsThread"] = it }
+    val framesOut = mutableMapOf<String, Any?>(
+      "presentedTotal" to frame[0].toDouble(),
+      "missedTotal" to frame[1].toDouble(),
+      "longestGapMs" to frame[2] / 1_000_000.0,
+      "budgetMs" to frames.budgetNs / 1_000_000.0,
+      "drawnTotal" to drawn[0].toDouble(),
+      "jankTotal" to drawn[1].toDouble(),
+      "droppedTotal" to drawn[3].toDouble(),
+      "windowCovered" to (drawn[4] == 1L),
+      "source" to FRAMES_SOURCE,
+      "jankBasis" to frameMetrics.jankBasis,
+    )
+    if (drawn[2] >= 0L) framesOut["longestMs"] = drawn[2] / 1_000_000.0
+    maxHz.takeIf { it > 0 }?.let { framesOut["maxHz"] = it }
+    val record = mutableMapOf<String, Any?>(
+      "v" to 1,
+      "platform" to "android",
+      "seq" to seq,
+      "reason" to reason,
+      "t" to t,
+      "wallMs" to System.currentTimeMillis().toDouble(),
+      "intervalMs" to intervalMs,
+      "mode" to mode,
+      "mem" to memory,
+    )
+    thermalRaw()?.let {
+      record["thermal"] = perfLabThermalLevel(it)
+      record["thermalRaw"] = it
+    }
+    val prev = previous
+    if (prev != null && t > prev[0]) {
+      val dt = t - prev[0]
+      record["dtMs"] = dt
+      cpu["processCores"] = (processMs - prev[1]) / dt
+      if (mainMs != null && !prev[2].isNaN()) cpu["mainCores"] = (mainMs - prev[2]) / dt
+      if (jsMs != null && !prev[3].isNaN() && jsMs >= prev[3]) cpu["jsCores"] = (jsMs - prev[3]) / dt
+      framesOut["presented"] = frame[0] - prev[4]
+      framesOut["missed"] = frame[1] - prev[5]
+      framesOut["drawn"] = drawn[0] - prev[6]
+      framesOut["jank"] = drawn[1] - prev[7]
+    }
+    previous = doubleArrayOf(
+      t, processMs, mainMs ?: Double.NaN, jsMs ?: Double.NaN, frame[0].toDouble(), frame[1].toDouble(),
+      drawn[0].toDouble(), drawn[1].toDouble(),
+    )
+    record["cpu"] = cpu
+    record["frames"] = framesOut
+    record["collectMs"] = perfLabMonotonicMs() - started
+
+    ring.addLast(record)
+    while (ring.size > ringSize) ring.removeFirst()
+    log("PERF_LAB sample ${JSONObject(record as Map<*, *>)}")
+    return record
+  }
+}

package/app.plugin.js

@@ -0,0 +1,105 @@
+// Expo config plugin for the PerfLab SDK.
+//
+// The native module (iOS pod PerfLab, Android expo.modules.perflab) is linked
+// by Expo autolinking from expo-module.config.json. With the build flag off
+// (EXPO_PUBLIC_PERF_LAB is not "1" when `expo prebuild` runs) this plugin
+// excludes the package from Expo autolinking, so a store build carries no SDK
+// native code: no pod, no Android project, no ExpoModulesProvider entry. With
+// the flag on it removes that exclusion again (prebuild without --clean edits
+// the existing files) and records the flag in the app config, so the native
+// fingerprints of flag-on and flag-off builds differ. It also records which
+// React renderer the bundle carries (PERF_LAB_REACT_PROFILING, see metro.js):
+// `always` (=1), `switch` (=switch) or `off`.
+//
+// expo-modules-autolinking reads exclusions only from the app's package.json and
+// from command arguments, so the Podfile's `use_expo_modules!` call and
+// settings.gradle's `expoAutolinking` extension are where the exclusion goes.
+
+const { withPodfile, withSettingsGradle } = require('expo/config-plugins');
+
+const PACKAGE_NAME = require('./package.json').name;
+const PACKAGE_NAMES = [...new Set([PACKAGE_NAME, '@keepsnappy/react-native', '@perf-labs/react-native'])];
+const namesFor = name => name === PACKAGE_NAME ? PACKAGE_NAMES : [name];
+// Keep this generated-line marker stable so old exclusions can be removed.
+const TAG = 'perflab: native module excluded, EXPO_PUBLIC_PERF_LAB is not 1';
+
+const isEnabled = () => (process.env.EXPO_PUBLIC_KEEPSNAPPY ?? process.env.EXPO_PUBLIC_PERF_LAB) === '1';
+
+const profilingRenderer = (value = (process.env.KEEPSNAPPY_REACT_PROFILING ?? process.env.PERF_LAB_REACT_PROFILING)) => {
+  if (value === '1') {
+    return 'always';
+  }
+  return value === 'switch' ? 'switch' : 'off';
+};
+
+const quoted = name => `'${name.replace(/'/g, "\\'")}'`;
+
+// `use_expo_modules!` with no arguments, or the form this plugin writes.
+const PODFILE_CALL = /^([ \t]*)use_expo_modules!(?:\(\{ exclude: \[[^\]]*\] \}\))?(?:[ \t]*#[^\n]*)?$/m;
+
+const editPodfile = (contents, enabled, name = PACKAGE_NAME) => {
+  const match = contents.match(PODFILE_CALL);
+  if (!match) {
+    if (enabled || contents.includes(TAG)) {
+      return contents;
+    }
+    throw new Error(
+      `${name}: cannot exclude the native module, the Podfile has no plain \`use_expo_modules!\` call. ` +
+        `Add exclude: [${quoted(name)}] to it yourself, or set EXPO_PUBLIC_KEEPSNAPPY=1.`,
+    );
+  }
+  const indent = match[1];
+  const line = enabled
+    ? `${indent}use_expo_modules!`
+    : `${indent}use_expo_modules!({ exclude: [${namesFor(name).map(quoted).join(', ')}] }) # ${TAG}`;
+  return contents.replace(PODFILE_CALL, line);
+};
+
+const gradleLine = (language, name) =>
+  language === 'kt'
+    ? `expoAutolinking.exclude = (expoAutolinking.exclude ?: emptyList()) + listOf("${namesFor(name).join('", "')}") // ${TAG}`
+    : `expoAutolinking.exclude = (expoAutolinking.exclude ?: []) + [${namesFor(name).map(quoted).join(', ')}] // ${TAG}`;
+
+const editSettingsGradle = (contents, enabled, language = 'groovy', name = PACKAGE_NAME) => {
+  const lines = contents.split('\n').filter(line => !line.includes(TAG));
+  if (enabled) {
+    return lines.join('\n');
+  }
+  const at = lines.findIndex(line => /^\s*expoAutolinking\.useExpoModules\(/.test(line));
+  if (at < 0) {
+    throw new Error(
+      `${name}: cannot exclude the native module, settings.gradle has no \`expoAutolinking.useExpoModules()\` call. ` +
+        'Set expoAutolinking.exclude yourself, or set EXPO_PUBLIC_KEEPSNAPPY=1.',
+    );
+  }
+  lines.splice(at, 0, gradleLine(language, name));
+  return lines.join('\n');
+};
+
+const withPerfLab = config => {
+  const enabled = isEnabled();
+  if (enabled) {
+    config.extra = {
+      ...config.extra,
+      perflab: { native: true, profilingRenderer: profilingRenderer() },
+    };
+  }
+  config = withPodfile(config, mod => {
+    mod.modResults.contents = editPodfile(mod.modResults.contents, enabled);
+    return mod;
+  });
+  config = withSettingsGradle(config, mod => {
+    mod.modResults.contents = editSettingsGradle(
+      mod.modResults.contents,
+      enabled,
+      mod.modResults.language,
+    );
+    return mod;
+  });
+  return config;
+};
+
+module.exports = withPerfLab;
+module.exports.editPodfile = editPodfile;
+module.exports.editSettingsGradle = editSettingsGradle;
+module.exports.profilingRenderer = profilingRenderer;

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["PerfLabModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.perflab.PerfLabModule"]
+  }
+}

package/ios/PerfLab.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'PerfLab'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = 'TapIn'
+  s.homepage       = 'https://tapin.io'
+  s.platforms      = { :ios => '16.4' }
+  s.swift_version  = '5.9'
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'hermes-engine'
+
+  s.source_files = "*.{swift,h,mm}"
+  s.public_header_files = "PerfLabHermes.h"
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
+    'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/hermes-engine/destroot/include" "$(PODS_ROOT)/Headers/Public/hermes-engine"',
+  }
+end

package/ios/PerfLabHermes.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Hermes sampling profiler (C++ API) for Swift. The runtime pointer is the
+// jsi::Runtime behind Expo's JavaScriptRuntime.withUnsafePointee.
+@interface PerfLabHermes : NSObject
+
++ (BOOL)startWithHz:(double)hz;
++ (BOOL)stop;
+// Writes the runtime's samples as a DevTools .cpuprofile (Profiler.stop
+// format). Falls back to the root API's trace-event dump when the runtime
+// does not expose IHermes. Returns {path, bytes, format} or nil.
++ (nullable NSDictionary<NSString *, id> *)dumpRuntime:(nullable void *)runtime toPath:(NSString *)path;
+
+@end
+
+NS_ASSUME_NONNULL_END