@momo-kits/native-kits 0.162.1-debug → 0.162.1-gif.1

package/ios/FPSMonitor/FPSMonitor.swift

@@ -0,0 +1,562 @@
+import UIKit
+import QuartzCore
+import Darwin
+
+@objc(FPSMonitor)
+public final class FPSMonitor: NSObject {
+    public static let shared = FPSMonitor()
+
+    public var onFPSLow: ((CGFloat) -> Void)?
+    public var onRamOverload: ((CGFloat) -> Void)?
+
+    @objc public private(set) var latestFPS: CGFloat = 0
+    @objc public private(set) var latestCPUPercent: CGFloat = 0
+    @objc public private(set) var latestGPUms: CGFloat = 0
+    @objc public private(set) var latestMemoryMB: CGFloat = 0
+
+    @objc public var ramThreshold: CGFloat
+    @objc public var fpsThreshold: CGFloat = 30
+    @objc public var updateInterval: TimeInterval = 0.2
+
+    private var overlayWindow: FPSOverlayWindow?
+    private var graphView: FPSGraphView?
+    private var displayLink: CADisplayLink?
+    private var lastTimestamp: CFTimeInterval = 0
+    private var frameCount = 0
+    private var lastFPSAlertTime: CFTimeInterval = 0
+    private var uiVisible = false
+
+    private override init() {
+        #if targetEnvironment(simulator)
+        ramThreshold = 1500
+        #else
+        ramThreshold = 500
+        #endif
+        super.init()
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(appDidBecomeActive),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(appWillResignActive),
+            name: UIApplication.willResignActiveNotification,
+            object: nil
+        )
+    }
+
+    @objc(shared)
+    public class func sharedObjC() -> FPSMonitor {
+        shared
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc public func startOverlay() {
+        runOnMain {
+            guard self.displayLink == nil else { return }
+            self.lastTimestamp = 0
+            self.frameCount = 0
+            self.uiVisible = false
+
+            let link = CADisplayLink(target: self, selector: #selector(self.tick(_:)))
+            link.add(to: .main, forMode: .common)
+            link.isPaused = false
+            self.displayLink = link
+        }
+    }
+
+    @objc public func stop() {
+        runOnMain {
+            self.displayLink?.invalidate()
+            self.displayLink = nil
+
+            self.graphView?.removeFromSuperview()
+            self.graphView?.isHidden = true
+            self.graphView = nil
+
+            self.overlayWindow?.isHidden = true
+            self.overlayWindow?.rootViewController = nil
+            self.overlayWindow = nil
+
+            self.lastTimestamp = 0
+            self.frameCount = 0
+            self.uiVisible = false
+        }
+    }
+
+    @objc public func showUI() {
+        runOnMain {
+            if self.overlayWindow == nil {
+                let window = FPSOverlayWindow(frame: UIScreen.main.bounds)
+                window.windowLevel = .statusBar + 99
+                window.backgroundColor = .clear
+                let windowScenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+                window.windowScene = windowScenes.first { $0.activationState == .foregroundActive } ?? windowScenes.first
+
+                let rootViewController = UIViewController()
+                rootViewController.view.backgroundColor = .clear
+                window.rootViewController = rootViewController
+
+                let graphView = self.graphView ?? FPSGraphView()
+                graphView.backgroundColor = .clear
+                window.draggableView = graphView
+                rootViewController.view.addSubview(graphView)
+
+                self.graphView = graphView
+                self.overlayWindow = window
+            }
+
+            if self.graphView == nil {
+                self.graphView = FPSGraphView(frame: CGRect(x: 10, y: 50, width: 150, height: 80))
+                self.overlayWindow?.draggableView = self.graphView
+                self.overlayWindow?.rootViewController?.view.addSubview(self.graphView!)
+            }
+
+            self.graphView?.frame = CGRect(x: 10, y: 50, width: 150, height: 80)
+            self.graphView?.isHidden = false
+            self.overlayWindow?.isHidden = false
+            self.uiVisible = true
+        }
+    }
+
+    @objc public func hideUI() {
+        runOnMain {
+            self.graphView?.isHidden = true
+            self.graphView?.frame = .zero
+            self.overlayWindow?.isHidden = true
+            self.uiVisible = false
+        }
+    }
+
+    @objc public func metricsSnapshot() -> [String: String] {
+        [
+            "fps": String(format: "%.2f", latestFPS),
+            "usedCPU": String(format: "%.2f", latestCPUPercent),
+            "usedGPU": String(format: "%.2f", latestGPUms),
+            "usedMemoryMB": String(format: "%.0f", latestMemoryMB),
+        ]
+    }
+
+    @objc private func appDidBecomeActive() {
+        displayLink?.isPaused = false
+    }
+
+    @objc private func appWillResignActive() {
+        displayLink?.isPaused = true
+    }
+
+    @objc private func tick(_ link: CADisplayLink) {
+        if lastTimestamp == 0 {
+            lastTimestamp = link.timestamp
+            return
+        }
+
+        frameCount += 1
+        let delta = link.timestamp - lastTimestamp
+        guard delta >= updateInterval else { return }
+
+        let fps = frameCount > 0 && delta > 0 ? CGFloat(Double(frameCount) / delta) : 0
+        let frameTime = frameCount > 0 ? delta / Double(frameCount) : 0
+        let baseGpuRatio: CGFloat = 0.4
+        let fpsVariation = (60 - min(fps, 60)) / 60
+        let gpuRatio = baseGpuRatio + fpsVariation * 0.3
+        let gpuTimePerFrameMs = CGFloat(frameTime) * gpuRatio * 1000
+
+        let cpuPercent = currentCPUPercent()
+        let memoryMB = currentMemoryMB()
+
+        if let onRamOverload, memoryMB > ramThreshold {
+            ramThreshold += 100
+            onRamOverload(memoryMB)
+        }
+
+        latestFPS = fps
+        latestCPUPercent = cpuPercent
+        latestGPUms = gpuTimePerFrameMs
+        latestMemoryMB = memoryMB
+
+        let now = CFAbsoluteTimeGetCurrent()
+        if let onFPSLow, fps < fpsThreshold, now - lastFPSAlertTime >= 0.2 {
+            onFPSLow(fps)
+            lastFPSAlertTime = now
+        }
+
+        if uiVisible, let graphView {
+            let bounds = UIScreen.main.bounds.size
+            let scale = UIScreen.main.scale
+            let resolution = CGSize(width: bounds.width * scale, height: bounds.height * scale)
+            let frameTimeMs = fps > 0 ? 1000 / fps : 0
+            let cpuTimeMs = frameTimeMs * min(max(cpuPercent, 0), 100) / 100
+
+            graphView.update(
+                resolution: resolution,
+                cpuTime: cpuTimeMs,
+                gpuTime: gpuTimePerFrameMs,
+                memory: memoryMB
+            )
+            graphView.addFPS(fps)
+            graphView.addCPUTime(cpuTimeMs)
+            graphView.addGPUTime(gpuTimePerFrameMs)
+        }
+
+        lastTimestamp = link.timestamp
+        frameCount = 0
+    }
+
+    private func currentMemoryMB() -> CGFloat {
+        var info = task_vm_info_data_t()
+        var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size)
+
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
+            }
+        }
+
+        guard result == KERN_SUCCESS else { return 0 }
+        return CGFloat(info.phys_footprint) / (1024 * 1024)
+    }
+
+    private func currentCPUPercent() -> CGFloat {
+        var threadList: thread_act_array_t?
+        var threadCount = mach_msg_type_number_t()
+
+        guard task_threads(mach_task_self_, &threadList, &threadCount) == KERN_SUCCESS,
+              let threads = threadList else {
+            return 0
+        }
+
+        defer {
+            let byteCount = vm_size_t(Int(threadCount) * MemoryLayout<thread_t>.stride)
+            vm_deallocate(mach_task_self_, vm_address_t(UInt(bitPattern: threads)), byteCount)
+        }
+
+        var cpuUsage: Float = 0
+        for index in 0..<Int(threadCount) {
+            var info = thread_basic_info()
+            var infoCount = mach_msg_type_number_t(THREAD_INFO_MAX)
+            let result = withUnsafeMutablePointer(to: &info) {
+                $0.withMemoryRebound(to: integer_t.self, capacity: Int(infoCount)) {
+                    thread_info(threads[index], thread_flavor_t(THREAD_BASIC_INFO), $0, &infoCount)
+                }
+            }
+
+            if result == KERN_SUCCESS, (info.flags & TH_FLAGS_IDLE) == 0 {
+                cpuUsage += Float(info.cpu_usage) / Float(TH_USAGE_SCALE) * 100
+            }
+        }
+
+        let cores = max(ProcessInfo.processInfo.activeProcessorCount, 1)
+        return CGFloat(cpuUsage / Float(cores))
+    }
+
+    private func runOnMain(_ block: @escaping () -> Void) {
+        if Thread.isMainThread {
+            block()
+        } else {
+            DispatchQueue.main.async(execute: block)
+        }
+    }
+}
+
+private final class FPSOverlayWindow: UIWindow {
+    weak var draggableView: UIView?
+
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        guard let draggableView else { return nil }
+        let pointInDragView = draggableView.convert(point, from: self)
+        guard draggableView.point(inside: pointInDragView, with: event) else { return nil }
+        return super.hitTest(point, with: event)
+    }
+}
+
+private final class FPSGraphView: UIView {
+    private var fpsValues: [CGFloat] = []
+    private var cpuTimeValues: [CGFloat] = []
+    private var gpuTimeValues: [CGFloat] = []
+    private let maxPoints = 100
+    private let pointSpacing: CGFloat = 2
+
+    private var currentResolution: CGSize = .zero
+    private var currentCPUTime: CGFloat = 0
+    private var currentGPUTime: CGFloat = 0
+    private var currentMemory: CGFloat = 0
+
+    private var isCollapsed = false
+    private var fullFrame: CGRect = .zero
+
+    override init(frame: CGRect = CGRect(x: 0, y: 100, width: 150, height: 80)) {
+        super.init(frame: frame)
+        isOpaque = false
+        layer.cornerRadius = 8
+        clipsToBounds = true
+        fullFrame = frame
+        addGestureRecognizer(UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:))))
+        addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(toggleCollapse)))
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+    }
+
+    func addFPS(_ fps: CGFloat) {
+        append(fps, to: &fpsValues)
+        setNeedsDisplay()
+    }
+
+    func addCPUTime(_ cpuTime: CGFloat) {
+        append(cpuTime, to: &cpuTimeValues)
+        setNeedsDisplay()
+    }
+
+    func addGPUTime(_ gpuTime: CGFloat) {
+        append(gpuTime, to: &gpuTimeValues)
+        setNeedsDisplay()
+    }
+
+    func update(resolution: CGSize, cpuTime: CGFloat, gpuTime: CGFloat, memory: CGFloat) {
+        currentResolution = resolution
+        currentCPUTime = cpuTime
+        currentGPUTime = gpuTime
+        currentMemory = memory
+        updateFrameIfNeeded()
+        setNeedsDisplay()
+    }
+
+    @objc private func toggleCollapse() {
+        if isCollapsed {
+            UIView.animate(withDuration: 0.25, animations: {
+                self.frame = self.fullFrame
+            }, completion: { _ in
+                self.isCollapsed = false
+                self.setNeedsDisplay()
+            })
+        } else {
+            fullFrame = frame
+            isCollapsed = true
+            UIView.animate(withDuration: 0.25, animations: {
+                self.frame.size = CGSize(width: 44, height: 24)
+            }, completion: { _ in
+                self.setNeedsDisplay()
+            })
+        }
+    }
+
+    @objc private func handlePan(_ gesture: UIPanGestureRecognizer) {
+        guard let superview else { return }
+        let translation = gesture.translation(in: superview)
+        var newCenter = CGPoint(x: center.x + translation.x, y: center.y + translation.y)
+        let halfWidth = bounds.width / 2
+        let halfHeight = bounds.height / 2
+        let screen = UIScreen.main.bounds.size
+        newCenter.x = max(halfWidth, min(newCenter.x, screen.width - halfWidth))
+        newCenter.y = max(halfHeight, min(newCenter.y, screen.height - halfHeight))
+        center = newCenter
+        gesture.setTranslation(.zero, in: superview)
+    }
+
+    override func draw(_ rect: CGRect) {
+        if isCollapsed {
+            drawCollapsed(rect)
+            return
+        }
+        drawExpanded(rect)
+    }
+
+    private func drawCollapsed(_ rect: CGRect) {
+        guard let context = UIGraphicsGetCurrentContext() else { return }
+        context.clear(rect)
+        context.setFillColor(UIColor(white: 0, alpha: 0.6).cgColor)
+        context.fill(rect)
+
+        let text = String(format: "%.0f", fpsValues.last ?? 0)
+        let attributes: [NSAttributedString.Key: Any] = [
+            .font: UIFont.monospacedDigitSystemFont(ofSize: 12, weight: .medium),
+            .foregroundColor: UIColor.white,
+        ]
+        let size = text.size(withAttributes: attributes)
+        text.draw(
+            at: CGPoint(x: (rect.width - size.width) / 2, y: (rect.height - size.height) / 2),
+            withAttributes: attributes
+        )
+    }
+
+    private func drawExpanded(_ rect: CGRect) {
+        guard let context = UIGraphicsGetCurrentContext() else { return }
+        context.clear(rect)
+        context.setFillColor(UIColor(white: 0, alpha: 0.6).cgColor)
+        context.fill(rect)
+
+        let margin: CGFloat = 8
+        let labelAttrs = attributes(color: .white)
+        let fpsColor = UIColor(red: 0, green: 1, blue: 0, alpha: 1)
+        let cpuColor = UIColor(red: 1, green: 0.65, blue: 0, alpha: 1)
+        let gpuColor = UIColor(red: 0, green: 0.75, blue: 1, alpha: 1)
+        let memColor = UIColor(red: 1, green: 0.41, blue: 0.71, alpha: 1)
+
+        var y = margin
+        let deviceName = UIDevice.current.name
+        let resolution = String(format: "[%.0fx%.0f]", currentResolution.width, currentResolution.height)
+        drawSplit(left: deviceName, right: resolution, y: y, color: .white, rect: rect)
+        y += textHeight(labelAttrs) + 2
+
+        let scale = String(format: "%.1fx", UIScreen.main.scale)
+        let refreshRate = "\(UIScreen.main.maximumFramesPerSecond)Hz"
+        drawSplit(left: scale, right: refreshRate, y: y, color: .white, rect: rect)
+        y += textHeight(labelAttrs) + 6
+
+        let cpuMinMax = minMax(cpuTimeValues, fallback: currentCPUTime)
+        let gpuMinMax = minMax(gpuTimeValues, fallback: currentGPUTime)
+        let fpsMinMax = minMax(fpsValues, fallback: fpsValues.last ?? 0)
+
+        drawSplit(
+            left: String(format: "Pre: %.2fms", currentCPUTime),
+            right: String(format: "[%.2f %.2f]", cpuMinMax.min, cpuMinMax.max),
+            y: y,
+            color: cpuColor,
+            rect: rect
+        )
+        y += textHeight(labelAttrs) + 2
+
+        drawSplit(
+            left: String(format: "GPU: %.2fms", currentGPUTime),
+            right: String(format: "[%.2f %.2f]", gpuMinMax.min, gpuMinMax.max),
+            y: y,
+            color: gpuColor,
+            rect: rect
+        )
+        y += textHeight(labelAttrs) + 2
+
+        drawText(String(format: "Mem: %.1fMB", currentMemory), at: CGPoint(x: margin, y: y), color: memColor)
+        y += textHeight(labelAttrs) + 2
+
+        drawSplit(
+            left: String(format: "FPS: %.2f", fpsValues.last ?? 0),
+            right: String(format: "[%.2f %.2f]", fpsMinMax.min, fpsMinMax.max),
+            y: y,
+            color: fpsColor,
+            rect: rect
+        )
+        y += textHeight(labelAttrs) + 6
+
+        let graphTop = y
+        let graphHeight = rect.height - graphTop - margin
+        guard graphHeight > 12 else { return }
+
+        drawGrid(context: context, x: margin, y: graphTop, width: rect.width - margin * 2, height: graphHeight)
+        drawLine(context: context, values: fpsValues, x: margin + 2, y: graphTop, width: rect.width - margin * 2 - 4, height: graphHeight, maxScale: 60, color: fpsColor)
+        drawLine(context: context, values: cpuTimeValues, x: margin + 2, y: graphTop, width: rect.width - margin * 2 - 4, height: graphHeight, maxScale: 50, color: cpuColor)
+    }
+
+    private func updateFrameIfNeeded() {
+        guard !isCollapsed else { return }
+        let attrs = attributes(color: .white)
+        let lines = [
+            "\(UIDevice.current.name) [\(Int(currentResolution.width))x\(Int(currentResolution.height))]",
+            String(format: "%.1fx %dHz", UIScreen.main.scale, UIScreen.main.maximumFramesPerSecond),
+            "Pre: 99.99ms [99.99 99.99]",
+            "GPU: 99.99ms [99.99 99.99]",
+            "Mem: 999.9MB",
+            "FPS: 99.99 [99.99 99.99]",
+        ]
+        let width = lines.map { $0.size(withAttributes: attrs).width }.max() ?? 150
+        let finalWidth = max(150, width + 16)
+        let finalHeight = max(80, textHeight(attrs) * CGFloat(lines.count) + 26)
+
+        if abs(frame.width - finalWidth) > 1 || abs(frame.height - finalHeight) > 1 {
+            frame.size = CGSize(width: finalWidth, height: finalHeight)
+            fullFrame = frame
+        }
+    }
+
+    private func append(_ value: CGFloat, to values: inout [CGFloat]) {
+        if values.count >= maxPoints {
+            values.removeFirst()
+        }
+        values.append(value)
+    }
+
+    private func drawSplit(left: String, right: String, y: CGFloat, color: UIColor, rect: CGRect) {
+        let margin: CGFloat = 8
+        let rightSize = right.size(withAttributes: attributes(color: color))
+        drawText(left, at: CGPoint(x: margin, y: y), color: color)
+        drawText(right, at: CGPoint(x: rect.width - margin - rightSize.width, y: y), color: color)
+    }
+
+    private func drawText(_ text: String, at point: CGPoint, color: UIColor) {
+        text.draw(at: point, withAttributes: attributes(color: color))
+    }
+
+    private func drawGrid(context: CGContext, x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) {
+        context.setStrokeColor(UIColor(white: 1, alpha: 0.1).cgColor)
+        context.setLineWidth(0.5)
+        for index in 1...3 {
+            let gridY = y + CGFloat(index) * (height / 4)
+            context.move(to: CGPoint(x: x, y: gridY))
+            context.addLine(to: CGPoint(x: x + width, y: gridY))
+        }
+        var gridX = x + 20
+        while gridX < x + width {
+            context.move(to: CGPoint(x: gridX, y: y))
+            context.addLine(to: CGPoint(x: gridX, y: y + height))
+            gridX += 20
+        }
+        context.strokePath()
+    }
+
+    private func drawLine(
+        context: CGContext,
+        values: [CGFloat],
+        x: CGFloat,
+        y: CGFloat,
+        width: CGFloat,
+        height: CGFloat,
+        maxScale: CGFloat,
+        color: UIColor
+    ) {
+        guard values.count > 1 else { return }
+        context.setStrokeColor(color.cgColor)
+        context.setLineWidth(1)
+
+        let visibleValues = Array(values.suffix(Int(width / pointSpacing)))
+        for index in 1..<visibleValues.count {
+            let previous = point(for: visibleValues[index - 1], index: index - 1, x: x, y: y, height: height, maxScale: maxScale)
+            let current = point(for: visibleValues[index], index: index, x: x, y: y, height: height, maxScale: maxScale)
+            context.move(to: previous)
+            context.addLine(to: current)
+            context.strokePath()
+        }
+    }
+
+    private func point(for value: CGFloat, index: Int, x: CGFloat, y: CGFloat, height: CGFloat, maxScale: CGFloat) -> CGPoint {
+        let normalized = max(0, min(value / maxScale, 1))
+        return CGPoint(
+            x: x + CGFloat(index) * pointSpacing,
+            y: y + height * (1 - normalized)
+        )
+    }
+
+    private func minMax(_ values: [CGFloat], fallback: CGFloat) -> (min: CGFloat, max: CGFloat) {
+        guard let minValue = values.min(), let maxValue = values.max() else {
+            return (fallback, fallback)
+        }
+        return (minValue, maxValue)
+    }
+
+    private func attributes(color: UIColor) -> [NSAttributedString.Key: Any] {
+        [
+            .font: UIFont.monospacedDigitSystemFont(ofSize: 10, weight: .regular),
+            .foregroundColor: color,
+        ]
+    }
+
+    private func textHeight(_ attributes: [NSAttributedString.Key: Any]) -> CGFloat {
+        "FPS".size(withAttributes: attributes).height
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.1-debug",
+  "version": "0.162.1-gif.1",
   "private": false,
   "dependencies": {},
   "devDependencies": {},

package/publish.sh

@@ -456,7 +456,7 @@ case "$PHASE" in
         ;;
     "maven")
         echo "Running PHASE 2 only: Publish to Maven"
-#        phase_publish_maven
+        phase_publish_maven
         ;;
     "npm")
         echo "Running PHASE 3 only: Publish to NPM"
@@ -465,7 +465,7 @@ case "$PHASE" in
     "all")
         echo "Running ALL PHASES"
         phase_check_version
-#        phase_publish_maven
+        phase_publish_maven
         phase_publish_npm
         echo ""
         echo "🎉 ALL PHASES COMPLETED SUCCESSFULLY!"

package/build.gradle.kts

@@ -1,11 +0,0 @@
-plugins {
-    // this is necessary to avoid the plugins to be loaded multiple times
-    // in each subproject's classloader
-    alias(libs.plugins.android.application) apply false
-    alias(libs.plugins.android.library) apply false
-    alias(libs.plugins.compose) apply false
-    alias(libs.plugins.kotlin.compose.compiler) apply false
-    alias(libs.plugins.jetbrains.kotlin.multiplatform) apply false
-    alias(libs.plugins.jetbrains.kotlin.serialization) apply false
-    alias(libs.plugins.vanniktech.mavenPublish) apply false
-}