@scalebun-release/react-native 2.5.0

package/android/src/main/java/com/scalebun/profiler/collectors/IncidentDetector.kt

@@ -0,0 +1,223 @@
+package com.scalebun.profiler.collectors
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * IncidentDetector — Detects performance anomalies from collector data.
+ *
+ * All detection runs natively on the scheduler thread.
+ * Incidents are emitted as pre-formatted events to JS.
+ *
+ * Detectable incidents:
+ * - CPU spike (sustained high CPU)
+ * - Memory surge (rapid memory growth)
+ * - Jank burst (consecutive slow frames)
+ * - Frozen frame (single frame > 700ms)
+ * - Excessive thread growth
+ * - Thermal throttle
+ */
+class IncidentDetector {
+
+    // Configurable thresholds
+    var cpuSpikePercent: Double = 80.0
+    var memorySurgeBytesPerSec: Double = 10_485_760.0 // 10 MB/s
+    var jankBurstFrameCount: Int = 5
+    var frozenFrameMs: Double = 700.0
+    var excessiveThreadCount: Int = 50
+
+    // State for sustained detection
+    private var cpuSpikeConsecutive = 0
+    private val CPU_SPIKE_SUSTAINED_COUNT = 3 // 3 consecutive samples above threshold
+    private var lastIncidentTimestamp = 0L
+    private val MIN_INCIDENT_INTERVAL_MS = 5000L // Avoid flooding
+
+    private var incidentIdCounter = 0L
+
+    /**
+     * Evaluate all collectors and return any detected incidents.
+     *
+     * @param cpu Latest CPU sample (may be null on first call)
+     * @param memory Latest memory sample
+     * @param render Latest render sample
+     * @param threads Latest thread sample
+     * @param memoryGrowthRate bytes/sec growth rate (null if unavailable)
+     * @param currentScreen Current screen name for correlation
+     */
+    fun evaluate(
+        cpu: WritableMap?,
+        memory: WritableMap?,
+        render: WritableMap?,
+        threads: WritableMap?,
+        memoryGrowthRate: Double?,
+        currentScreen: String
+    ): List<WritableMap> {
+        val incidents = mutableListOf<WritableMap>()
+        val now = System.currentTimeMillis()
+
+        // Rate limit
+        if (now - lastIncidentTimestamp < MIN_INCIDENT_INTERVAL_MS) {
+            return incidents
+        }
+
+        // ─── CPU Spike ──────────────────────────────────────────
+        if (cpu != null) {
+            val appCpu = cpu.getDouble("appCpuPercent")
+            if (appCpu > cpuSpikePercent) {
+                cpuSpikeConsecutive++
+                if (cpuSpikeConsecutive >= CPU_SPIKE_SUSTAINED_COUNT) {
+                    incidents.add(buildIncident(
+                        type = "cpu_spike",
+                        title = "CPU Spike Detected",
+                        severity = if (appCpu > 95) "critical" else "warning",
+                        confidence = "high",
+                        cause = "App CPU at ${appCpu}% for $cpuSpikeConsecutive consecutive samples",
+                        description = "Sustained high CPU usage detected. This may cause thermal throttling and battery drain.",
+                        screen = currentScreen,
+                        timestamp = now
+                    ))
+                    cpuSpikeConsecutive = 0 // Reset after emitting
+                    lastIncidentTimestamp = now
+                }
+            } else {
+                cpuSpikeConsecutive = 0
+            }
+        }
+
+        // ─── Memory Surge ───────────────────────────────────────
+        if (memoryGrowthRate != null && memoryGrowthRate > memorySurgeBytesPerSec) {
+            incidents.add(buildIncident(
+                type = "memory_surge",
+                title = "Memory Surge Detected",
+                severity = if (memoryGrowthRate > memorySurgeBytesPerSec * 2) "critical" else "warning",
+                confidence = "medium",
+                cause = "Memory growing at ${formatBytes(memoryGrowthRate.toLong())}/s",
+                description = "Rapid memory growth detected. Check for large allocations, leaked bitmaps, or unbounded cache growth.",
+                screen = currentScreen,
+                timestamp = now
+            ))
+            lastIncidentTimestamp = now
+        }
+
+        // ─── Low Memory Pressure ────────────────────────────────
+        if (memory != null) {
+            try {
+                val pressureLevel = memory.getInt("pressureLevel")
+                if (pressureLevel >= 2) {
+                    incidents.add(buildIncident(
+                        type = "low_memory_pressure",
+                        title = "Low Memory Warning",
+                        severity = "critical",
+                        confidence = "high",
+                        cause = "System reports low memory state",
+                        description = "The device is very low on memory. App may be killed by the OS.",
+                        screen = currentScreen,
+                        timestamp = now
+                    ))
+                    lastIncidentTimestamp = now
+                }
+            } catch (_: Exception) {}
+        }
+
+        // ─── Frozen Frame ───────────────────────────────────────
+        if (render != null) {
+            try {
+                val maxFrameMs = render.getDouble("maxFrameTimeMs")
+                if (maxFrameMs > frozenFrameMs) {
+                    incidents.add(buildIncident(
+                        type = "frozen_frame",
+                        title = "Frozen Frame Detected",
+                        severity = if (maxFrameMs > 2000) "critical" else "warning",
+                        confidence = "high",
+                        cause = "Frame took ${maxFrameMs.toLong()}ms (threshold: ${frozenFrameMs.toLong()}ms)",
+                        description = "A single frame took an extremely long time to render, causing visible UI freeze.",
+                        screen = currentScreen,
+                        timestamp = now
+                    ))
+                    lastIncidentTimestamp = now
+                }
+
+                val slowCount = render.getInt("slowFrames")
+                if (slowCount >= jankBurstFrameCount) {
+                    incidents.add(buildIncident(
+                        type = "jank_burst",
+                        title = "Jank Burst Detected",
+                        severity = "warning",
+                        confidence = "medium",
+                        cause = "$slowCount slow frames in sampling window",
+                        description = "Multiple consecutive slow frames indicate UI jank. Check for expensive layout or draw operations.",
+                        screen = currentScreen,
+                        timestamp = now
+                    ))
+                    lastIncidentTimestamp = now
+                }
+            } catch (_: Exception) {}
+        }
+
+        // ─── Excessive Thread Growth ────────────────────────────
+        if (threads != null) {
+            try {
+                val threadCount = threads.getInt("threadCount")
+                if (threadCount > excessiveThreadCount) {
+                    incidents.add(buildIncident(
+                        type = "excessive_thread_growth",
+                        title = "Excessive Threads",
+                        severity = "warning",
+                        confidence = "medium",
+                        cause = "$threadCount threads active (threshold: $excessiveThreadCount)",
+                        description = "High thread count can cause scheduling overhead and memory waste.",
+                        screen = currentScreen,
+                        timestamp = now
+                    ))
+                    lastIncidentTimestamp = now
+                }
+            } catch (_: Exception) {}
+        }
+
+        return incidents
+    }
+
+    fun updateThresholds(thresholds: Map<String, Any?>) {
+        (thresholds["cpuSpikePercent"] as? Number)?.let { cpuSpikePercent = it.toDouble() }
+        (thresholds["memorySurgeBytesPerSec"] as? Number)?.let { memorySurgeBytesPerSec = it.toDouble() }
+        (thresholds["jankBurstFrameCount"] as? Number)?.let { jankBurstFrameCount = it.toInt() }
+        (thresholds["frozenFrameMs"] as? Number)?.let { frozenFrameMs = it.toDouble() }
+        (thresholds["excessiveThreadCount"] as? Number)?.let { excessiveThreadCount = it.toInt() }
+    }
+
+    private fun buildIncident(
+        type: String,
+        title: String,
+        severity: String,
+        confidence: String,
+        cause: String,
+        description: String,
+        screen: String,
+        timestamp: Long
+    ): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("id", "inc_${++incidentIdCounter}_${timestamp}")
+        map.putString("incidentType", type)
+        map.putString("title", title)
+        map.putString("severity", severity)
+        map.putString("confidence", confidence)
+        map.putString("likelyCause", cause)
+        map.putString("description", description)
+        map.putDouble("startTimestamp", timestamp.toDouble())
+
+        val screens = Arguments.createArray()
+        if (screen.isNotEmpty()) screens.pushString(screen)
+        map.putArray("affectedScreens", screens)
+
+        return map
+    }
+
+    private fun formatBytes(bytes: Long): String {
+        return when {
+            bytes >= 1_073_741_824 -> "${bytes / 1_073_741_824}GB"
+            bytes >= 1_048_576 -> "${bytes / 1_048_576}MB"
+            bytes >= 1024 -> "${bytes / 1024}KB"
+            else -> "${bytes}B"
+        }
+    }
+}

package/android/src/main/java/com/scalebun/profiler/collectors/MemoryCollector.kt

@@ -0,0 +1,157 @@
+package com.scalebun.profiler.collectors
+
+import android.app.ActivityManager
+import android.content.Context
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * MemoryCollector — Samples memory usage from multiple Android sources.
+ *
+ * Sources:
+ * - Runtime.getRuntime(): Java heap used/total/free
+ * - Debug.getNativeHeapSize/AllocatedSize: native heap
+ * - ActivityManager.getMemoryInfo(): system-level available/low memory/threshold
+ * - ActivityManager.getProcessMemoryInfo(): PSS (proportional set size)
+ *
+ * All public APIs. No reflection, no hidden APIs.
+ */
+class MemoryCollector(private val reactContext: ReactApplicationContext) {
+
+    private var peakMemoryBytes: Long = 0L
+    private var prevResidentBytes: Long = 0L
+    private var prevTimestampMs: Long = 0L
+
+    /**
+     * Collect a memory sample. Always returns a result (no warm-up needed).
+     */
+    fun collect(): WritableMap {
+        val map = Arguments.createMap()
+
+        try {
+            // ─── Java Heap (Runtime) ────────────────────────────
+            val runtime = Runtime.getRuntime()
+            val javaHeapTotal = runtime.totalMemory()
+            val javaHeapFree = runtime.freeMemory()
+            val javaHeapUsed = javaHeapTotal - javaHeapFree
+            val javaHeapMax = runtime.maxMemory()
+
+            map.putDouble("javaHeapUsedBytes", javaHeapUsed.toDouble())
+            map.putDouble("javaHeapTotalBytes", javaHeapTotal.toDouble())
+            map.putDouble("freeHeapBytes", javaHeapFree.toDouble())
+
+            // ─── Native Heap (Debug) ────────────────────────────
+            val nativeHeapSize = android.os.Debug.getNativeHeapSize()
+            val nativeHeapAlloc = android.os.Debug.getNativeHeapAllocatedSize()
+
+            map.putDouble("nativeHeapBytes", nativeHeapAlloc.toDouble())
+
+            // ─── Total used = java used + native allocated ──────
+            val totalUsed = javaHeapUsed + nativeHeapAlloc
+            map.putDouble("totalHeapBytes", (javaHeapTotal + nativeHeapSize).toDouble())
+            map.putDouble("usedHeapBytes", totalUsed.toDouble())
+
+            // ─── System Memory (ActivityManager) ────────────────
+            val am = reactContext.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+            if (am != null) {
+                val memInfo = ActivityManager.MemoryInfo()
+                am.getMemoryInfo(memInfo)
+
+                map.putDouble("availableMemoryBytes", memInfo.availMem.toDouble())
+                map.putBoolean("lowMemory", memInfo.lowMemory)
+
+                // Pressure level: 0 = normal, 1 = moderate (>75% used), 2 = critical (lowMemory)
+                val pressureLevel = when {
+                    memInfo.lowMemory -> 2
+                    memInfo.totalMem > 0 && (memInfo.totalMem - memInfo.availMem).toDouble() / memInfo.totalMem > 0.75 -> 1
+                    else -> 0
+                }
+                map.putInt("pressureLevel", pressureLevel)
+            } else {
+                map.putBoolean("lowMemory", false)
+                map.putInt("pressureLevel", 0)
+            }
+
+            // ─── PSS (Proportional Set Size) ────────────────────
+            // This is the best approximation of "physical memory used by this process"
+            val pss = readPssFromProcfs()
+            if (pss > 0) {
+                map.putDouble("residentBytes", pss.toDouble())
+            } else {
+                // Fallback: use java + native as an estimate
+                map.putDouble("residentBytes", totalUsed.toDouble())
+            }
+
+            val residentBytes = if (pss > 0) pss else totalUsed
+
+            // ─── Peak Memory ────────────────────────────────────
+            if (residentBytes > peakMemoryBytes) {
+                peakMemoryBytes = residentBytes
+            }
+            map.putDouble("peakMemoryBytes", peakMemoryBytes.toDouble())
+
+            map.putString("availability", "available")
+
+            // Store for surge detection
+            prevResidentBytes = residentBytes
+            prevTimestampMs = System.currentTimeMillis()
+        } catch (e: Exception) {
+            map.putBoolean("lowMemory", false)
+            map.putInt("pressureLevel", 0)
+            map.putString("availability", "degraded")
+        }
+
+        return map
+    }
+
+    /**
+     * Calculate memory growth rate in bytes/sec for incident detection.
+     * Returns null if insufficient data.
+     */
+    fun getMemoryGrowthRate(): Double? {
+        if (prevTimestampMs == 0L) return null
+        val now = System.currentTimeMillis()
+        val elapsed = now - prevTimestampMs
+        if (elapsed <= 0) return null
+
+        val currentPss = readPssFromProcfs()
+        if (currentPss <= 0 || prevResidentBytes <= 0) return null
+
+        val growth = currentPss - prevResidentBytes
+        return growth.toDouble() / (elapsed.toDouble() / 1000.0) // bytes per second
+    }
+
+    /**
+     * Read PSS from /proc/self/smaps_rollup (API 28+) or /proc/self/status.
+     * /proc/self/smaps_rollup is preferred as it's faster.
+     * Falls back to VmRSS from /proc/self/status.
+     */
+    private fun readPssFromProcfs(): Long {
+        return try {
+            // Try smaps_rollup first (API 28+ has best support, but it's a procfs file)
+            val smapsRollup = java.io.File("/proc/self/smaps_rollup")
+            if (smapsRollup.exists()) {
+                val lines = smapsRollup.readLines()
+                val pssLine = lines.firstOrNull { it.startsWith("Pss:") }
+                if (pssLine != null) {
+                    val kb = pssLine.split("\\s+".toRegex()).getOrNull(1)?.toLongOrNull() ?: 0L
+                    return kb * 1024L
+                }
+            }
+
+            // Fallback to VmRSS from /proc/self/status
+            val statusFile = java.io.File("/proc/self/status")
+            if (statusFile.exists()) {
+                val lines = statusFile.readLines()
+                val rssLine = lines.firstOrNull { it.startsWith("VmRSS:") }
+                if (rssLine != null) {
+                    val kb = rssLine.split("\\s+".toRegex()).getOrNull(1)?.toLongOrNull() ?: 0L
+                    return kb * 1024L
+                }
+            }
+
+            0L
+        } catch (_: Exception) { 0L }
+    }
+}

package/android/src/main/java/com/scalebun/profiler/collectors/RenderCollector.kt

@@ -0,0 +1,194 @@
+package com.scalebun.profiler.collectors
+
+import android.view.Choreographer
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+
+/**
+ * RenderCollector — Measures frame timing and detects slow/frozen frames.
+ *
+ * Uses Choreographer.FrameCallback (API 16+, public API) to track
+ * VSYNC frame delivery. Calculates FPS, slow frames, frozen frames,
+ * dropped frames, and builds a frame time histogram.
+ *
+ * Slow frame: > 16.67ms (misses one VSYNC at 60Hz)
+ * Frozen frame: > 700ms (ANR-adjacent)
+ *
+ * Note: FrameMetrics (API 24+) provides more detail but requires
+ * Window reference. Choreographer is safer and always available.
+ */
+class RenderCollector {
+
+    // Thresholds
+    private val SLOW_FRAME_THRESHOLD_NS = 16_666_667L    // ~16.67ms
+    private val FROZEN_FRAME_THRESHOLD_NS = 700_000_000L  // 700ms
+    private val EXPECTED_FRAME_NS = 16_666_667L           // 60Hz target
+
+    // Running state
+    private val active = AtomicBoolean(false)
+
+    // Counters (thread-safe — callback runs on main thread looper)
+    private val totalFrames = AtomicInteger(0)
+    private val slowFrames = AtomicInteger(0)
+    private val frozenFrames = AtomicInteger(0)
+    private val droppedFrames = AtomicInteger(0)
+    private val maxFrameTimeNs = AtomicLong(0)
+
+    // For FPS calculation
+    private var windowStartNs = 0L
+    private var framesInWindow = 0
+
+    // Frame time histogram buckets (ms ranges)
+    private val histogram = IntArray(7) // [0-8ms, 8-16ms, 16-33ms, 33-50ms, 50-100ms, 100-700ms, 700ms+]
+
+    // Choreographer callback
+    private var lastFrameNs = 0L
+    private val frameCallback = object : Choreographer.FrameCallback {
+        override fun doFrame(frameTimeNanos: Long) {
+            if (!active.get()) return
+
+            if (lastFrameNs > 0) {
+                val durationNs = frameTimeNanos - lastFrameNs
+
+                if (durationNs > 0) {
+                    totalFrames.incrementAndGet()
+                    framesInWindow++
+
+                    // Classify frame
+                    if (durationNs > FROZEN_FRAME_THRESHOLD_NS) {
+                        frozenFrames.incrementAndGet()
+                        slowFrames.incrementAndGet()
+                    } else if (durationNs > SLOW_FRAME_THRESHOLD_NS) {
+                        slowFrames.incrementAndGet()
+                    }
+
+                    // Count dropped frames (how many VSYNCs were missed)
+                    val dropped = ((durationNs / EXPECTED_FRAME_NS) - 1).coerceAtLeast(0).toInt()
+                    if (dropped > 0) droppedFrames.addAndGet(dropped)
+
+                    // Peak frame time
+                    var prev = maxFrameTimeNs.get()
+                    while (durationNs > prev) {
+                        if (maxFrameTimeNs.compareAndSet(prev, durationNs)) break
+                        prev = maxFrameTimeNs.get()
+                    }
+
+                    // Histogram bucket
+                    val durationMs = durationNs / 1_000_000
+                    val bucket = when {
+                        durationMs < 8 -> 0
+                        durationMs < 16 -> 1
+                        durationMs < 33 -> 2
+                        durationMs < 50 -> 3
+                        durationMs < 100 -> 4
+                        durationMs < 700 -> 5
+                        else -> 6
+                    }
+                    synchronized(histogram) { histogram[bucket]++ }
+                }
+            }
+
+            lastFrameNs = frameTimeNanos
+
+            // Re-post for next frame
+            if (active.get()) {
+                Choreographer.getInstance().postFrameCallback(this)
+            }
+        }
+    }
+
+    /**
+     * Start collecting frame metrics on the main thread.
+     */
+    fun start() {
+        if (active.getAndSet(true)) return
+        lastFrameNs = 0L
+        windowStartNs = System.nanoTime()
+        framesInWindow = 0
+        Choreographer.getInstance().postFrameCallback(frameCallback)
+    }
+
+    /**
+     * Stop collecting frame metrics.
+     */
+    fun stop() {
+        active.set(false)
+    }
+
+    /**
+     * Collect current render metrics and reset window counters.
+     */
+    fun collect(): WritableMap {
+        val map = Arguments.createMap()
+
+        try {
+            val nowNs = System.nanoTime()
+            val windowDurationNs = nowNs - windowStartNs
+
+            // Calculate FPS from frames in current window
+            val fps = if (windowDurationNs > 0 && framesInWindow > 0) {
+                (framesInWindow.toDouble() / (windowDurationNs.toDouble() / 1_000_000_000.0))
+                    .coerceIn(0.0, 120.0) // Cap at 120fps
+            } else {
+                0.0
+            }
+
+            map.putDouble("fps", Math.round(fps * 10.0) / 10.0)
+            map.putInt("totalFrames", totalFrames.get())
+            map.putInt("slowFrames", slowFrames.get())
+            map.putInt("frozenFrames", frozenFrames.get())
+            map.putInt("droppedFrames", droppedFrames.get())
+            map.putDouble("maxFrameTimeMs", maxFrameTimeNs.get().toDouble() / 1_000_000.0)
+
+            // Histogram
+            val histMap = Arguments.createMap()
+            synchronized(histogram) {
+                histMap.putInt("0-8ms", histogram[0])
+                histMap.putInt("8-16ms", histogram[1])
+                histMap.putInt("16-33ms", histogram[2])
+                histMap.putInt("33-50ms", histogram[3])
+                histMap.putInt("50-100ms", histogram[4])
+                histMap.putInt("100-700ms", histogram[5])
+                histMap.putInt("700ms+", histogram[6])
+            }
+            map.putMap("histogram", histMap)
+            map.putString("availability", if (active.get()) "available" else "unavailable")
+
+            // Reset window for next collection
+            windowStartNs = nowNs
+            framesInWindow = 0
+        } catch (e: Exception) {
+            map.putDouble("fps", 0.0)
+            map.putString("availability", "degraded")
+        }
+
+        return map
+    }
+
+    /**
+     * Reset all counters.
+     */
+    fun reset() {
+        totalFrames.set(0)
+        slowFrames.set(0)
+        frozenFrames.set(0)
+        droppedFrames.set(0)
+        maxFrameTimeNs.set(0)
+        synchronized(histogram) {
+            for (i in histogram.indices) histogram[i] = 0
+        }
+        windowStartNs = System.nanoTime()
+        framesInWindow = 0
+    }
+
+    /**
+     * Get count of consecutive slow frames (for jank burst detection).
+     */
+    fun getConsecutiveSlowFrames(): Int {
+        // Simplified: return current slow frame count in this window
+        return slowFrames.get()
+    }
+}