@onekeyfe/react-native-perf-stats 3.0.25

package/ios/ReactNativePerfStats.swift

@@ -0,0 +1,391 @@
+import NitroModules
+import ReactNativeNativeLogger
+import Darwin
+import UIKit
+
+private let kTag = "PerfStats"
+private let kMinIntervalMs: Double = 200
+
+// Anomaly logging thresholds. We only emit a warn after the metric has
+// stayed over the threshold for kAnomalySustainSamples in a row, to
+// skip transient spikes (e.g. JS startup, GC). After firing we throttle
+// for kAnomalyCooldownSec to avoid flooding native-logger.
+private let kCpuAnomalyPct: Double = 150.0
+private let kRssAnomalyBytes: Double = 800.0 * 1024.0 * 1024.0
+private let kAnomalySustainSamples: Int = 5
+private let kAnomalyCooldownSec: Double = 30.0
+
+class ReactNativePerfStats: HybridReactNativePerfStatsSpec {
+
+    func start(intervalMs: Double) throws {
+        Sampler.shared.start(intervalMs: max(intervalMs, kMinIntervalMs))
+    }
+
+    func stop() throws {
+        Sampler.shared.stop()
+    }
+
+    func showOverlay() throws {
+        Overlay.shared.show()
+    }
+
+    func hideOverlay() throws {
+        Overlay.shared.hide()
+    }
+
+    func sample() throws -> Promise<PerfSample> {
+        return Promise.async {
+            return Sampler.shared.takeSample()
+        }
+    }
+}
+
+// MARK: - Sampler
+//
+// Singleton; one timer fires on a private background queue regardless of
+// how many HybridObject instances exist or which thread calls start(). This
+// keeps overlay updates flowing even when the JS thread is blocked.
+
+private final class Sampler {
+    static let shared = Sampler()
+
+    private let queue = DispatchQueue(label: "io.onekey.perfstats.sampler", qos: .utility)
+    private let lock = NSLock()
+    private var timer: DispatchSourceTimer?
+    private var running = false
+    private var intervalMs: Double = 1000
+    private var lastCpuSec: Double = -1
+    private var lastMonoSec: Double = -1
+
+    // Anomaly state lives on the sampler's serial dispatch queue, so no
+    // synchronization is needed. lastLogSec intentionally persists across
+    // stop()/start() cycles to keep the cooldown honest if the caller
+    // toggles the sampler rapidly.
+    private var cpuOverCount: Int = 0
+    private var rssOverCount: Int = 0
+    private var lastCpuLogSec: Double = 0
+    private var lastRssLogSec: Double = 0
+
+    func start(intervalMs ms: Double) {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            let prev = self.intervalMs
+            self.intervalMs = ms
+            if self.running, let t = self.timer {
+                // Skip reschedule when interval is unchanged — calling
+                // `schedule` on a running source resets the next deadline,
+                // which would briefly extend the gap unnecessarily.
+                if prev != ms {
+                    t.schedule(
+                        deadline: .now() + .milliseconds(Int(ms)),
+                        repeating: .milliseconds(Int(ms))
+                    )
+                }
+                return
+            }
+            self.running = true
+            let t = DispatchSource.makeTimerSource(queue: self.queue)
+            t.schedule(
+                deadline: .now() + .milliseconds(Int(ms)),
+                repeating: .milliseconds(Int(ms))
+            )
+            t.setEventHandler { [weak self] in
+                guard let self = self, self.running else { return }
+                let s = self.takeSample()
+                Overlay.shared.update(sample: s)
+                self.checkAnomalyAndLog(sample: s)
+            }
+            self.timer = t
+            t.resume()
+        }
+    }
+
+    func stop() {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            self.running = false
+            self.timer?.cancel()
+            self.timer = nil
+        }
+        Overlay.shared.hide()
+    }
+
+    func takeSample() -> PerfSample {
+        let nowMono = monotonicSec()
+        let nowCpu = processCpuSec()
+        let rssBytes = residentBytes()
+        let nowWallMs = Date().timeIntervalSince1970 * 1000.0
+
+        var cpuPct: Double = 0
+        lock.lock()
+        if nowCpu >= 0 && lastCpuSec >= 0 && lastMonoSec > 0 {
+            let dCpu = nowCpu - lastCpuSec
+            let dWall = nowMono - lastMonoSec
+            if dWall > 0 && dCpu >= 0 {
+                cpuPct = (dCpu / dWall) * 100.0
+            }
+        }
+        if nowCpu >= 0 {
+            lastCpuSec = nowCpu
+            lastMonoSec = nowMono
+        }
+        lock.unlock()
+
+        return PerfSample(
+            cpu: cpuPct,
+            rss: Double(rssBytes),
+            timestamp: nowWallMs
+        )
+    }
+
+    /// Emits a warn to native-logger when CPU or RSS has stayed over its
+    /// threshold for `kAnomalySustainSamples` consecutive samples. Only
+    /// called from the periodic timer; one-off `sample()` calls do not
+    /// trip this path. Each metric tracks its own counter and cooldown.
+    private func checkAnomalyAndLog(sample s: PerfSample) {
+        let nowSec = monotonicSec()
+
+        if s.cpu >= kCpuAnomalyPct {
+            cpuOverCount += 1
+            if cpuOverCount >= kAnomalySustainSamples,
+               nowSec - lastCpuLogSec >= kAnomalyCooldownSec {
+                OneKeyLog.warn(
+                    kTag,
+                    String(
+                        format: "Sustained high CPU: %.1f%% over %d samples",
+                        s.cpu, cpuOverCount
+                    )
+                )
+                lastCpuLogSec = nowSec
+                cpuOverCount = 0
+            }
+        } else {
+            cpuOverCount = 0
+        }
+
+        if s.rss >= kRssAnomalyBytes {
+            rssOverCount += 1
+            if rssOverCount >= kAnomalySustainSamples,
+               nowSec - lastRssLogSec >= kAnomalyCooldownSec {
+                let mb = s.rss / 1024.0 / 1024.0
+                OneKeyLog.warn(
+                    kTag,
+                    String(
+                        format: "Sustained high RSS: %.1f MB over %d samples",
+                        mb, rssOverCount
+                    )
+                )
+                lastRssLogSec = nowSec
+                rssOverCount = 0
+            }
+        } else {
+            rssOverCount = 0
+        }
+    }
+
+    private func monotonicSec() -> Double {
+        var ts = timespec()
+        if clock_gettime(CLOCK_MONOTONIC, &ts) != 0 {
+            return Date().timeIntervalSince1970
+        }
+        return Double(ts.tv_sec) + Double(ts.tv_nsec) / 1_000_000_000.0
+    }
+
+    /// Aggregate CPU time consumed by all threads (live + terminated) of the
+    /// current process, in seconds. Returns -1 on failure.
+    private func processCpuSec() -> Double {
+        var ts = timespec()
+        if clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) != 0 {
+            OneKeyLog.warn(kTag, "clock_gettime(CLOCK_PROCESS_CPUTIME_ID) failed: errno=\(errno)")
+            return -1
+        }
+        return Double(ts.tv_sec) + Double(ts.tv_nsec) / 1_000_000_000.0
+    }
+
+    private func residentBytes() -> UInt64 {
+        var vmInfo = task_vm_info_data_t()
+        var count = mach_msg_type_number_t(
+            MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size
+        )
+        let kr = withUnsafeMutablePointer(to: &vmInfo) { ptr in
+            ptr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { intPtr in
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), intPtr, &count)
+            }
+        }
+        if kr == KERN_SUCCESS {
+            return UInt64(vmInfo.phys_footprint)
+        }
+
+        var basicInfo = mach_task_basic_info_data_t()
+        var basicCount = mach_msg_type_number_t(
+            MemoryLayout<mach_task_basic_info_data_t>.size / MemoryLayout<natural_t>.size
+        )
+        let basicKr = withUnsafeMutablePointer(to: &basicInfo) { ptr in
+            ptr.withMemoryRebound(to: integer_t.self, capacity: Int(basicCount)) { intPtr in
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), intPtr, &basicCount)
+            }
+        }
+        if basicKr == KERN_SUCCESS {
+            return UInt64(basicInfo.resident_size)
+        }
+
+        OneKeyLog.warn(kTag, "Failed to read resident memory; vmKr=\(kr) basicKr=\(basicKr)")
+        return 0
+    }
+}
+
+// MARK: - Overlay
+//
+// Singleton UILabel attached to the current key UIWindow. Updates always
+// dispatch to main. No floating-window permission needed; overlay only
+// shows while the app is in the foreground.
+//
+// Inherits NSObject so UIPanGestureRecognizer's target/action selector
+// dispatch resolves cleanly via Obj-C runtime.
+
+private final class Overlay: NSObject {
+    static let shared = Overlay()
+
+    private override init() { super.init() }
+
+    private var label: UILabel?
+    private var visible = false
+
+    // `_lastSample` is written by the Sampler timer thread and read by the
+    // main thread in attach() and inside the coalesced update closure.
+    // Optional<struct> is not atomic in Swift, so guard with a lock to avoid
+    // torn reads / undefined behaviour. `_updatePending` is part of the same
+    // protected state to coalesce overlay refreshes.
+    private let sampleLock = NSLock()
+    private var _lastSample: PerfSample?
+    private var _updatePending = false
+
+    private var lastSample: PerfSample? {
+        get {
+            sampleLock.lock(); defer { sampleLock.unlock() }
+            return _lastSample
+        }
+        set {
+            sampleLock.lock(); defer { sampleLock.unlock() }
+            _lastSample = newValue
+        }
+    }
+
+    func show() {
+        visible = true
+        DispatchQueue.main.async { [weak self] in self?.attach() }
+    }
+
+    func hide() {
+        visible = false
+        DispatchQueue.main.async { [weak self] in self?.detach() }
+    }
+
+    /// Coalesce updates: if the main thread is blocked, we don't want N
+    /// label.text writes piling up only to all fire when it unblocks. The
+    /// `_updatePending` flag (held under sampleLock) ensures at most one
+    /// pending dispatch at a time, and the closure always reads the
+    /// latest sample on main.
+    func update(sample: PerfSample) {
+        sampleLock.lock()
+        _lastSample = sample
+        let shouldPost = !_updatePending
+        if shouldPost { _updatePending = true }
+        sampleLock.unlock()
+
+        if !shouldPost { return }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.sampleLock.lock()
+            self._updatePending = false
+            let snapshot = self._lastSample
+            self.sampleLock.unlock()
+            guard self.visible, let snapshot = snapshot else { return }
+            self.label?.text = self.renderText(snapshot)
+        }
+    }
+
+    private func attach() {
+        if label != nil { return }
+        guard let window = currentKeyWindow() else {
+            OneKeyLog.warn(kTag, "No key UIWindow available; overlay deferred")
+            return
+        }
+
+        let lbl = UILabel(frame: CGRect(x: 30, y: 100, width: 160, height: 60))
+        lbl.backgroundColor = UIColor.black.withAlphaComponent(0.7)
+        lbl.layer.cornerRadius = 8
+        lbl.layer.masksToBounds = true
+        lbl.textColor = .white
+        lbl.font = .systemFont(ofSize: 13, weight: .bold)
+        lbl.textAlignment = .center
+        lbl.numberOfLines = 2
+        lbl.text = "CPU: --\nRAM: --"
+        lbl.isUserInteractionEnabled = true
+
+        let pan = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
+        lbl.addGestureRecognizer(pan)
+
+        window.addSubview(lbl)
+        label = lbl
+
+        if let s = lastSample {
+            lbl.text = renderText(s)
+        }
+    }
+
+    private func detach() {
+        label?.removeFromSuperview()
+        label = nil
+    }
+
+    @objc private func handlePan(_ gesture: UIPanGestureRecognizer) {
+        guard let view = gesture.view, let parent = view.superview else { return }
+        let translation = gesture.translation(in: parent)
+        let newCenter = CGPoint(
+            x: view.center.x + translation.x,
+            y: view.center.y + translation.y
+        )
+        let halfW = view.bounds.size.width / 2
+        let halfH = view.bounds.size.height / 2
+        view.center = CGPoint(
+            x: max(halfW, min(parent.bounds.size.width - halfW, newCenter.x)),
+            y: max(halfH, min(parent.bounds.size.height - halfH, newCenter.y))
+        )
+        gesture.setTranslation(.zero, in: parent)
+    }
+
+    private func renderText(_ s: PerfSample) -> String {
+        let cpuStr = s.cpu > 0 ? String(format: "%.1f%%", s.cpu) : "--"
+        let mb = s.rss / 1024.0 / 1024.0
+        let memStr = mb > 0 ? String(format: "%.1f MB", mb) : "--"
+        return "CPU: \(cpuStr)\nRAM: \(memStr)"
+    }
+
+    private func currentKeyWindow() -> UIWindow? {
+        // iOS 15+ preferred path
+        if #available(iOS 15.0, *) {
+            for scene in UIApplication.shared.connectedScenes {
+                guard
+                    let windowScene = scene as? UIWindowScene,
+                    windowScene.activationState == .foregroundActive
+                else { continue }
+                if let kw = windowScene.keyWindow {
+                    return kw
+                }
+            }
+        }
+        // Fallback: scan all connected scenes
+        for scene in UIApplication.shared.connectedScenes {
+            guard let windowScene = scene as? UIWindowScene else { continue }
+            if let kw = windowScene.windows.first(where: { $0.isKeyWindow }) {
+                return kw
+            }
+            if let any = windowScene.windows.first {
+                return any
+            }
+        }
+        return nil
+    }
+}

package/lib/module/ReactNativePerfStats.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativePerfStats.nitro.js.map

package/lib/module/ReactNativePerfStats.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["ReactNativePerfStats.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const ReactNativePerfStatsHybridObject = NitroModules.createHybridObject('ReactNativePerfStats');
+export const ReactNativePerfStats = ReactNativePerfStatsHybridObject;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","ReactNativePerfStatsHybridObject","createHybridObject","ReactNativePerfStats"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,gCAAgC,GACpCD,YAAY,CAACE,kBAAkB,CAA2B,sBAAsB,CAAC;AAEnF,OAAO,MAAMC,oBAAoB,GAAGF,gCAAgC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/ReactNativePerfStats.nitro.d.ts

@@ -0,0 +1,51 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface PerfSample {
+    /**
+     * Process CPU usage as a percentage of one core, computed as
+     * `(deltaCpuTime / deltaWallTime) * 100` against the previous sample.
+     * Multi-core saturation can exceed 100. The first sample after process
+     * launch returns `0` because no baseline exists yet.
+     */
+    cpu: number;
+    /** Resident set size in bytes. iOS: phys_footprint; Android: VmRSS. */
+    rss: number;
+    /** Wall-clock timestamp (ms since unix epoch) when the sample was taken. */
+    timestamp: number;
+}
+export interface ReactNativePerfStats extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Start the singleton native sampler.
+     *
+     * - Runs on a dedicated background thread (Android: HandlerThread;
+     *   iOS: dispatch source on a global queue), so it survives JS-thread
+     *   blockages — the overlay keeps updating even when JS is frozen.
+     * - Idempotent: calling `start` again only updates the interval; it does
+     *   not spawn additional timers.
+     */
+    start(intervalMs: number): void;
+    /** Stop the sampler. Also hides the overlay if shown. No-op if not running. */
+    stop(): void;
+    /**
+     * Show the floating overlay (CPU + RAM) drawn natively.
+     *
+     * - Android: TextView attached to the current Activity via
+     *   `addContentView` — no floating-window permission required.
+     * - iOS: UILabel added to the key UIWindow.
+     * - Draggable on both platforms.
+     * - Idempotent. If the sampler is not running, the overlay shows "--"
+     *   until `start` is called.
+     */
+    showOverlay(): void;
+    /** Hide the floating overlay. The sampler keeps running. No-op if not shown. */
+    hideOverlay(): void;
+    /**
+     * Take one CPU+RAM sample without affecting the overlay timer.
+     * Cheap (~1ms) and runs off the JS thread via Promise.async.
+     * Shares the same delta baseline as the overlay sampler.
+     */
+    sample(): Promise<PerfSample>;
+}
+//# sourceMappingURL=ReactNativePerfStats.nitro.d.ts.map

package/lib/typescript/src/ReactNativePerfStats.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativePerfStats.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativePerfStats.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhC,+EAA+E;IAC/E,IAAI,IAAI,IAAI,CAAC;IAEb;;;;;;;;;OASG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB,gFAAgF;IAChF,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;CAC/B"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNativePerfStats as ReactNativePerfStatsType } from './ReactNativePerfStats.nitro';
+export declare const ReactNativePerfStats: ReactNativePerfStatsType;
+export type * from './ReactNativePerfStats.nitro';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,IAAI,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAKrG,eAAO,MAAM,oBAAoB,0BAAmC,CAAC;AACrE,mBAAmB,8BAA8B,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["reactnativeperfstats"],
+  "ios": {
+    "iosModuleName": "ReactNativePerfStats"
+  },
+  "android": {
+    "androidNamespace": ["reactnativeperfstats"],
+    "androidCxxLibName": "reactnativeperfstats"
+  },
+  "autolinking": {
+    "ReactNativePerfStats": {
+      "swift": "ReactNativePerfStats",
+      "kotlin": "ReactNativePerfStats"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JHybridReactNativePerfStatsSpec.cpp

@@ -0,0 +1,83 @@
+///
+/// JHybridReactNativePerfStatsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridReactNativePerfStatsSpec.hpp"
+
+// Forward declaration of `PerfSample` to properly resolve imports.
+namespace margelo::nitro::reactnativeperfstats { struct PerfSample; }
+
+#include "PerfSample.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JPerfSample.hpp"
+
+namespace margelo::nitro::reactnativeperfstats {
+
+  jni::local_ref<JHybridReactNativePerfStatsSpec::jhybriddata> JHybridReactNativePerfStatsSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridReactNativePerfStatsSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridReactNativePerfStatsSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridReactNativePerfStatsSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridReactNativePerfStatsSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridReactNativePerfStatsSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridReactNativePerfStatsSpec::start(double intervalMs) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* intervalMs */)>("start");
+    method(_javaPart, intervalMs);
+  }
+  void JHybridReactNativePerfStatsSpec::stop() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stop");
+    method(_javaPart);
+  }
+  void JHybridReactNativePerfStatsSpec::showOverlay() {
+    static const auto method = javaClassStatic()->getMethod<void()>("showOverlay");
+    method(_javaPart);
+  }
+  void JHybridReactNativePerfStatsSpec::hideOverlay() {
+    static const auto method = javaClassStatic()->getMethod<void()>("hideOverlay");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<PerfSample>> JHybridReactNativePerfStatsSpec::sample() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("sample");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<PerfSample>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPerfSample>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::reactnativeperfstats

package/nitrogen/generated/android/c++/JHybridReactNativePerfStatsSpec.hpp

@@ -0,0 +1,69 @@
+///
+/// HybridReactNativePerfStatsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridReactNativePerfStatsSpec.hpp"
+
+
+
+
+namespace margelo::nitro::reactnativeperfstats {
+
+  using namespace facebook;
+
+  class JHybridReactNativePerfStatsSpec: public jni::HybridClass<JHybridReactNativePerfStatsSpec, JHybridObject>,
+                                         public virtual HybridReactNativePerfStatsSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativeperfstats/HybridReactNativePerfStatsSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridReactNativePerfStatsSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridReactNativePerfStatsSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridReactNativePerfStatsSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridReactNativePerfStatsSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void start(double intervalMs) override;
+    void stop() override;
+    void showOverlay() override;
+    void hideOverlay() override;
+    std::shared_ptr<Promise<PerfSample>> sample() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridReactNativePerfStatsSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::reactnativeperfstats