@salve-software/mako-react-native 1.0.1

package/android/src/main/java/com/margelo/nitro/mako/PerformanceMonitor.kt

@@ -0,0 +1,260 @@
+package com.margelo.nitro.mako
+
+import android.os.Handler
+import android.os.Looper
+import android.view.Choreographer
+import java.io.RandomAccessFile
+
+data class PerformanceMetricsData(
+    val uiFps: Double,
+    val jsFps: Double,
+    val memoryUsageMB: Double,
+    val cpuUsagePercent: Double
+)
+
+typealias PerformanceMetricsCallback = (PerformanceMetricsData) -> Unit
+
+class PerformanceMonitor {
+
+    // MARK: - Properties
+
+    private var choreographerCallback: Choreographer.FrameCallback? = null
+    private var handler: Handler? = null
+    private var reportRunnable: Runnable? = null
+    private var callback: PerformanceMetricsCallback? = null
+
+    // UI FPS tracking
+    private var uiFrameCount = 0
+    private var lastUiFpsUpdateTime = 0L
+    private var currentUiFps = 0.0
+
+    // JS FPS tracking
+    private var lastJsCallbackTime = 0L
+    private var jsFrameCount = 0
+    private var lastJsFpsUpdateTime = 0L
+    private var currentJsFps = 0.0
+
+    private var isMonitoring = false
+    private var intervalMs = 1000
+
+    // CPU tracking
+    private var lastCpuTime = 0L
+    private var lastAppCpuTime = 0L
+
+    // MARK: - Public Methods
+
+    fun start(callback: PerformanceMetricsCallback, intervalMs: Int = 1000): Boolean {
+        if (isMonitoring) {
+            return false // Already monitoring
+        }
+
+        this.callback = callback
+        this.intervalMs = intervalMs
+        this.isMonitoring = true
+
+        // Reset counters
+        uiFrameCount = 0
+        jsFrameCount = 0
+        val now = System.nanoTime()
+        lastUiFpsUpdateTime = now
+        lastJsFpsUpdateTime = now
+        lastJsCallbackTime = now
+        currentUiFps = 0.0
+        currentJsFps = 0.0
+
+        // Initialize CPU tracking
+        initCpuTracking()
+
+        // Set up Choreographer for UI FPS
+        setupChoreographer()
+
+        // Set up timer for reporting metrics
+        handler = Handler(Looper.getMainLooper())
+        reportRunnable = object : Runnable {
+            override fun run() {
+                if (isMonitoring) {
+                    reportMetrics()
+                    handler?.postDelayed(this, intervalMs.toLong())
+                }
+            }
+        }
+        handler?.postDelayed(reportRunnable!!, intervalMs.toLong())
+
+        return true
+    }
+
+    fun stop() {
+        if (!isMonitoring) return
+
+        isMonitoring = false
+        callback = null
+
+        // Stop choreographer
+        choreographerCallback?.let {
+            Choreographer.getInstance().removeFrameCallback(it)
+        }
+        choreographerCallback = null
+
+        // Stop report handler
+        reportRunnable?.let {
+            handler?.removeCallbacks(it)
+        }
+        reportRunnable = null
+        handler = null
+    }
+
+    fun isRunning(): Boolean {
+        return isMonitoring
+    }
+
+    fun getSnapshot(): PerformanceMetricsData {
+        return PerformanceMetricsData(
+            uiFps = currentUiFps,
+            jsFps = currentJsFps,
+            memoryUsageMB = getMemoryUsage(),
+            cpuUsagePercent = getCpuUsage()
+        )
+    }
+
+    fun recordJsFrame() {
+        if (!isMonitoring) return
+
+        val now = System.nanoTime()
+        lastJsCallbackTime = now
+        jsFrameCount++
+
+        // Calculate JS FPS every 500ms
+        val elapsed = (now - lastJsFpsUpdateTime) / 1_000_000_000.0
+        if (elapsed >= 0.5) {
+            currentJsFps = jsFrameCount / elapsed
+            jsFrameCount = 0
+            lastJsFpsUpdateTime = now
+        }
+    }
+
+    // MARK: - Private Methods
+
+    private fun setupChoreographer() {
+        choreographerCallback = object : Choreographer.FrameCallback {
+            override fun doFrame(frameTimeNanos: Long) {
+                if (!isMonitoring) return
+
+                uiFrameCount++
+
+                val now = frameTimeNanos
+                val elapsed = (now - lastUiFpsUpdateTime) / 1_000_000_000.0
+
+                // Calculate UI FPS every 500ms
+                if (elapsed >= 0.5) {
+                    currentUiFps = uiFrameCount / elapsed
+
+                    // Cap at 120 FPS (reasonable max for Android devices)
+                    if (currentUiFps > 120.0) {
+                        currentUiFps = 120.0
+                    }
+
+                    uiFrameCount = 0
+                    lastUiFpsUpdateTime = now
+                }
+
+                // Schedule next frame
+                Choreographer.getInstance().postFrameCallback(this)
+            }
+        }
+
+        Choreographer.getInstance().postFrameCallback(choreographerCallback!!)
+    }
+
+    private fun reportMetrics() {
+        val metrics = PerformanceMetricsData(
+            uiFps = currentUiFps,
+            jsFps = currentJsFps,
+            memoryUsageMB = getMemoryUsage(),
+            cpuUsagePercent = getCpuUsage()
+        )
+
+        callback?.invoke(metrics)
+    }
+
+    private fun getMemoryUsage(): Double {
+        val runtime = Runtime.getRuntime()
+        val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+        return usedMemory / 1024.0 / 1024.0 // Convert to MB
+    }
+
+    private fun initCpuTracking() {
+        try {
+            val stat = RandomAccessFile("/proc/stat", "r")
+            val cpuLine = stat.readLine()
+            stat.close()
+
+            val appStat = RandomAccessFile("/proc/self/stat", "r")
+            val appLine = appStat.readLine()
+            appStat.close()
+
+            lastCpuTime = parseCpuTime(cpuLine)
+            lastAppCpuTime = parseAppCpuTime(appLine)
+        } catch (e: Exception) {
+            // If we can't read CPU stats, just initialize to 0
+            lastCpuTime = 0
+            lastAppCpuTime = 0
+        }
+    }
+
+    private fun getCpuUsage(): Double {
+        try {
+            val stat = RandomAccessFile("/proc/stat", "r")
+            val cpuLine = stat.readLine()
+            stat.close()
+
+            val appStat = RandomAccessFile("/proc/self/stat", "r")
+            val appLine = appStat.readLine()
+            appStat.close()
+
+            val currentCpuTime = parseCpuTime(cpuLine)
+            val currentAppCpuTime = parseAppCpuTime(appLine)
+
+            val cpuDelta = currentCpuTime - lastCpuTime
+            val appCpuDelta = currentAppCpuTime - lastAppCpuTime
+
+            lastCpuTime = currentCpuTime
+            lastAppCpuTime = currentAppCpuTime
+
+            if (cpuDelta == 0L) {
+                return 0.0
+            }
+
+            val cpuUsage = (appCpuDelta.toDouble() / cpuDelta.toDouble()) * 100.0
+
+            // Cap at 100%
+            return minOf(cpuUsage, 100.0)
+        } catch (e: Exception) {
+            return 0.0
+        }
+    }
+
+    private fun parseCpuTime(line: String): Long {
+        // /proc/stat format: cpu user nice system idle iowait irq softirq
+        val parts = line.split("\\s+".toRegex())
+        if (parts.size < 5) return 0
+
+        val user = parts[1].toLongOrNull() ?: 0
+        val nice = parts[2].toLongOrNull() ?: 0
+        val system = parts[3].toLongOrNull() ?: 0
+        val idle = parts[4].toLongOrNull() ?: 0
+
+        return user + nice + system + idle
+    }
+
+    private fun parseAppCpuTime(line: String): Long {
+        // /proc/self/stat format: pid (name) state ... utime stime ...
+        // utime is field 14 (index 13), stime is field 15 (index 14)
+        val parts = line.split("\\s+".toRegex())
+        if (parts.size < 15) return 0
+
+        val utime = parts[13].toLongOrNull() ?: 0
+        val stime = parts[14].toLongOrNull() ?: 0
+
+        return utime + stime
+    }
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  nitro-trace
+//
+//  Created by Gabriel-Pereira1788 on 4/13/2026
+//
+
+#pragma once

package/ios/HybridMako.swift

@@ -0,0 +1,245 @@
+//
+//  HybridMako.swift
+//  NitroMako
+//
+//  Native log capture implementation for iOS
+//
+
+import Foundation
+import UIKit
+
+class HybridMako: HybridNitroMakoSpec {
+
+    // MARK: - Properties
+
+    private var logCallback: ((_ log: NativeLogEntry) -> Void)?
+    private var isCapturingLogs = false
+    private var stderrPipe: Pipe?
+    private var originalStderr: Int32 = -1
+    private var readSource: DispatchSourceRead?
+
+    // Storage key for device ID
+    private let deviceIdStorageKey = "mako_device_id"
+
+    // Performance monitoring
+    private let performanceMonitor = PerformanceMonitor()
+
+    // MARK: - Existing Methods
+
+    func sum(num1: Double, num2: Double) throws -> Double {
+        return num1 + num2
+    }
+
+    // MARK: - Log Capture Methods
+
+    func startLogCapture(onLog: @escaping (_ log: NativeLogEntry) -> Void) throws -> Bool {
+        guard !isCapturingLogs else {
+            return false // Already capturing
+        }
+
+        logCallback = onLog
+        isCapturingLogs = true
+
+        // Create pipe for stderr redirection
+        stderrPipe = Pipe()
+        guard let pipe = stderrPipe else {
+            isCapturingLogs = false
+            logCallback = nil
+            return false
+        }
+
+        // Save original stderr
+        originalStderr = dup(STDERR_FILENO)
+
+        // Disable buffering on stderr
+        setvbuf(stderr, nil, _IONBF, 0)
+
+        // Redirect stderr to our pipe
+        dup2(pipe.fileHandleForWriting.fileDescriptor, STDERR_FILENO)
+
+        // Set up dispatch source to read from pipe
+        let fileDescriptor = pipe.fileHandleForReading.fileDescriptor
+        readSource = DispatchSource.makeReadSource(fileDescriptor: fileDescriptor, queue: DispatchQueue.global(qos: .utility))
+
+        readSource?.setEventHandler { [weak self] in
+            guard let self = self else { return }
+
+            let data = pipe.fileHandleForReading.availableData
+            guard !data.isEmpty else { return }
+
+            // Write to original stderr so logs still appear in Xcode console
+            if self.originalStderr >= 0 {
+                _ = data.withUnsafeBytes { bytes in
+                    write(self.originalStderr, bytes.baseAddress, data.count)
+                }
+            }
+
+            // Process the log
+            if let output = String(data: data, encoding: .utf8) {
+                self.processLogOutput(output)
+            }
+        }
+
+        readSource?.setCancelHandler { [weak self] in
+            self?.stderrPipe?.fileHandleForReading.closeFile()
+        }
+
+        readSource?.resume()
+
+        return true
+    }
+
+    func stopLogCapture() throws {
+        guard isCapturingLogs else { return }
+
+        isCapturingLogs = false
+        logCallback = nil
+
+        // Cancel read source
+        readSource?.cancel()
+        readSource = nil
+
+        // Restore original stderr
+        if originalStderr >= 0 {
+            dup2(originalStderr, STDERR_FILENO)
+            close(originalStderr)
+            originalStderr = -1
+        }
+
+        // Close pipe
+        stderrPipe?.fileHandleForWriting.closeFile()
+        stderrPipe = nil
+    }
+
+    func isCapturing() throws -> Bool {
+        return isCapturingLogs
+    }
+
+    // MARK: - Device Info Methods
+
+    func getDeviceInfo() throws -> DeviceInfoResult {
+        let deviceId = UIDevice.current.identifierForVendor?.uuidString ?? generateUUID()
+        let deviceName = UIDevice.current.name
+        let appName = Bundle.main.object(forInfoDictionaryKey: "CFBundleDisplayName") as? String
+                      ?? Bundle.main.object(forInfoDictionaryKey: "CFBundleName") as? String
+                      ?? "React Native App"
+        let bundleId = Bundle.main.bundleIdentifier ?? ""
+
+        return DeviceInfoResult(deviceId: deviceId, deviceName: deviceName, appName: appName, bundleId: bundleId)
+    }
+
+    func getStoredDeviceId() throws -> String? {
+        return UserDefaults.standard.string(forKey: deviceIdStorageKey)
+    }
+
+    func storeDeviceId(deviceId: String) throws {
+        UserDefaults.standard.set(deviceId, forKey: deviceIdStorageKey)
+    }
+
+    private func generateUUID() -> String {
+        return UUID().uuidString
+    }
+
+    // MARK: - Private Helpers
+
+    private func processLogOutput(_ output: String) {
+        // Split by newlines and process each line
+        let lines = output.components(separatedBy: .newlines)
+
+        for line in lines where !line.isEmpty {
+            let level = detectLogLevel(from: line)
+            let tag = extractTag(from: line)
+
+            let entry = NativeLogEntry(
+                level: level,
+                message: line,
+                tag: tag,
+                timestamp: Date().timeIntervalSince1970 * 1000
+            )
+
+            // Invoke callback on main thread for React Native
+            DispatchQueue.main.async { [weak self] in
+                self?.logCallback?(entry)
+            }
+        }
+    }
+
+    private func detectLogLevel(from line: String) -> NativeLogLevel {
+        let lowercased = line.lowercased()
+
+        if lowercased.contains("error") || lowercased.contains("fault") || lowercased.contains("❌") {
+            return .error
+        } else if lowercased.contains("warning") || lowercased.contains("warn") || lowercased.contains("⚠️") {
+            return .warn
+        } else if lowercased.contains("debug") || lowercased.contains("🔍") {
+            return .verbose
+        }
+        return .info
+    }
+
+    private func extractTag(from line: String) -> String {
+        // Try to extract subsystem/category from NSLog format
+        // Format: "timestamp process[pid:tid] message" or similar
+
+        // Try to match patterns like "[CategoryName]" at the start
+        let bracketPattern = #"^\[([^\]]+)\]"#
+        if let regex = try? NSRegularExpression(pattern: bracketPattern),
+           let match = regex.firstMatch(in: line, range: NSRange(line.startIndex..., in: line)),
+           let range = Range(match.range(at: 1), in: line) {
+            return String(line[range])
+        }
+
+        // Try to extract from NSLog format: "AppName[pid:tid]"
+        let nslogPattern = #"^[\d\-:\.\s]+([A-Za-z0-9_]+)\["#
+        if let regex = try? NSRegularExpression(pattern: nslogPattern),
+           let match = regex.firstMatch(in: line, range: NSRange(line.startIndex..., in: line)),
+           let range = Range(match.range(at: 1), in: line) {
+            return String(line[range])
+        }
+
+        return "native"
+    }
+
+    // MARK: - Performance Monitoring Methods
+
+    func startPerformanceMonitoring(onMetrics: @escaping (_ metrics: PerformanceMetrics) -> Void, intervalMs: Double?) throws -> Bool {
+        let interval = intervalMs.map { Int($0) } ?? 1000
+
+        return performanceMonitor.start(callback: { data in
+            let metrics = PerformanceMetrics(
+                uiFps: data.uiFps,
+                jsFps: data.jsFps,
+                memoryUsageMB: data.memoryUsageMB,
+                cpuUsagePercent: data.cpuUsagePercent
+            )
+            onMetrics(metrics)
+        }, intervalMs: interval)
+    }
+
+    func stopPerformanceMonitoring() throws {
+        performanceMonitor.stop()
+    }
+
+    func isPerformanceMonitoring() throws -> Bool {
+        return performanceMonitor.isRunning()
+    }
+
+    func getPerformanceSnapshot() throws -> PerformanceMetrics {
+        let data = performanceMonitor.getSnapshot()
+        return PerformanceMetrics(
+            uiFps: data.uiFps,
+            jsFps: data.jsFps,
+            memoryUsageMB: data.memoryUsageMB,
+            cpuUsagePercent: data.cpuUsagePercent
+        )
+    }
+
+    func recordJsFrame() throws {
+        performanceMonitor.recordJsFrame()
+    }
+
+    deinit {
+        try? stopLogCapture()
+        performanceMonitor.stop()
+    }
+}