fixes, add refresh rate getters

Author: Nodonisko

android/src/main/java/com/margelo/nitro/performancetoolkit/HybridPerformanceToolkit.kt

@@ -234,4 +234,24 @@ class HybridPerformanceToolkit : HybridPerformanceToolkitSpec() {
       0
     }
   }
+
+  override fun getDeviceMaxRefreshRate(): Double {
+    val context = NitroModules.applicationContext as? ReactApplicationContext
+    return if (context != null) {
+      com.performancetoolkit.DeviceUtils.getDeviceMaxRefreshRate(context)
+    } else {
+      android.util.Log.w("PerformanceToolkit", "ReactApplicationContext not available, returning default 60 Hz")
+      60.0
+    }
+  }
+  
+  override fun getDeviceCurrentRefreshRate(): Double {
+    val context = NitroModules.applicationContext as? ReactApplicationContext
+    return if (context != null) {
+      com.performancetoolkit.DeviceUtils.getDeviceCurrentRefreshRate(context)
+    } else {
+      android.util.Log.w("PerformanceToolkit", "ReactApplicationContext not available, returning default 60 Hz")
+      60.0
+    }
+  }
 }

android/src/main/java/com/performancetoolkit/DeviceUtils.kt

@@ -0,0 +1,60 @@
+package com.performancetoolkit
+
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import android.view.WindowManager
+import com.facebook.react.bridge.ReactApplicationContext
+import kotlin.math.roundToInt
+
+object DeviceUtils {
+  private const val TAG = "PerformanceToolkit"
+  
+  fun getDeviceMaxRefreshRate(context: ReactApplicationContext): Double {
+    return try {
+      val display = getDisplay(context)
+      
+      // Get maximum refresh rate from supported modes (API 23+)
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        display?.supportedModes
+          ?.maxOfOrNull { it.refreshRate }
+          ?.roundToInt()?.toDouble() ?: 60.0
+      } else {
+        // Fall back to current refresh rate on older devices
+        display?.refreshRate?.roundToInt()?.toDouble() ?: 60.0
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error getting max device refresh rate, defaulting to 60", e)
+      60.0
+    }
+  }
+  
+  fun getDeviceCurrentRefreshRate(context: ReactApplicationContext): Double {
+    return try {
+      val display = getDisplay(context)
+      
+      // Get current refresh rate
+      display?.refreshRate?.roundToInt()?.toDouble() ?: 60.0
+    } catch (e: Exception) {
+      Log.e(TAG, "Error getting current device refresh rate, defaulting to 60", e)
+      60.0
+    }
+  }
+  
+  private fun getDisplay(context: ReactApplicationContext): android.view.Display? {
+    // Try to get display from current activity first
+    val display = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      context.currentActivity?.display
+    } else {
+      null
+    }
+    
+    // Fall back to WindowManager's default display
+    return display ?: run {
+      val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as? WindowManager
+      @Suppress("DEPRECATION")
+      windowManager?.defaultDisplay
+    }
+  }
+}
+

android/src/main/java/com/performancetoolkit/PerformanceToolkitTurboModule.kt

@@ -39,7 +39,7 @@ class PerformanceToolkitTurboModule(reactContext: ReactApplicationContext) :
       ?: throw IllegalStateException("PerformanceToolkit: React Native runtime executor is not available. Please ensure New Architecture is enabled.")
 
     runtimeExecutor = executor
-    val deviceFps = getDeviceRefreshRate(reactContext)
+    val deviceFps = DeviceUtils.getDeviceMaxRefreshRate(reactContext)
 
     try {
       hybridData = initHybrid(runtimeExecutor, deviceFps)
@@ -48,29 +48,6 @@ class PerformanceToolkitTurboModule(reactContext: ReactApplicationContext) :
       throw e
     }
   }
-  
-  private fun getDeviceRefreshRate(context: ReactApplicationContext): Double {
-    return try {
-      // Try to get display from current activity first
-      val display = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        context.currentActivity?.display
-      } else {
-        null
-      }
-      
-      // Fall back to WindowManager's default display
-      val finalDisplay = display ?: run {
-        val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as? WindowManager
-        @Suppress("DEPRECATION")
-        windowManager?.defaultDisplay
-      }
-      
-      finalDisplay?.refreshRate?.toDouble() ?: 60.0
-    } catch (e: Exception) {
-      Log.e(TAG, "Error getting device refresh rate, defaulting to 60", e)
-      60.0
-    }
-  }
 
   override fun invalidate() {
     try {

cpp/HybridJsFpsTracking.cpp

@@ -52,7 +52,8 @@ class JsFpsTracker : public std::enable_shared_from_this<JsFpsTracker> {
 
     auto self = shared_from_this();
     // Get frame interval dynamically based on device refresh rate
-    const double frameIntervalMs = RuntimeBridgeState::get().getFrameIntervalMs();
+    // const double frameIntervalMs = RuntimeBridgeState::get().getFrameIntervalMs();
+    const double frameIntervalMs = 16.666666666666668; // For now fix it to 60 FPS
     const auto frameInterval = std::chrono::duration_cast<std::chrono::steady_clock::duration>(
       std::chrono::duration<double, std::milli>(frameIntervalMs)
     );
@@ -127,7 +128,8 @@ class JsFpsTracker : public std::enable_shared_from_this<JsFpsTracker> {
           fps = 0.0;
         }
 
-        double deviceMaxFps = RuntimeBridgeState::get().getDeviceRefreshRate();
+        // double deviceMaxFps = RuntimeBridgeState::get().getDeviceRefreshRate();
+        const double deviceMaxFps = 60.0; // For now fix it to 60 FPS
         double cappedFps = std::min(std::round(fps), deviceMaxFps);
 
         // Write to native buffer as Int32 (not on JS thread)

example/App.tsx

@@ -5,6 +5,8 @@ import {
   useCpuUsage,
   useMemoryUsage,
   useFpsJs,
+  getDeviceMaxRefreshRate,
+  getDeviceCurrentRefreshRate,
 } from 'react-native-performance-toolkit';
 import { GestureHandlerRootView } from 'react-native-gesture-handler';
 import {
@@ -84,6 +86,15 @@ function App(): React.JSX.Element {
         </Text>
       </TouchableOpacity>
 
+      <View>
+        <Text style={styles.subtitle}>
+          Device Max Refresh Rate: {getDeviceMaxRefreshRate()} Hz
+        </Text>
+        <Text style={styles.subtitle}>
+          Device Current Refresh Rate: {getDeviceCurrentRefreshRate()} Hz
+        </Text>
+      </View>
+
       <View>
         <Text style={styles.subtitle}>JS Thread updated values</Text>
       </View>

ios/HybridPerformanceToolkit.swift

@@ -292,4 +292,24 @@ class HybridPerformanceToolkit: HybridPerformanceToolkitSpec {
 
         return Double(info.phys_footprint) / 1_048_576.0
     }
+    
+    func getDeviceMaxRefreshRate() throws -> Double {
+        return maxDeviceFps
+    }
+    
+    func getDeviceCurrentRefreshRate() throws -> Double {
+        // On iOS, the current refresh rate is the same as max for most cases
+        // ProMotion devices (120Hz) may throttle down, but CADisplayLink will reflect this
+        if let displayLink = displayLink {
+            // preferredFramesPerSecond returns the actual frame rate being used
+            // 0 means maximum available, so we return maxDeviceFps
+            if displayLink.preferredFramesPerSecond == 0 {
+                return maxDeviceFps
+            }
+            return Double(displayLink.preferredFramesPerSecond)
+        }
+        
+        // Fallback to current screen refresh rate
+        return Double(UIScreen.main.maximumFramesPerSecond)
+    }
 }

src/hooks/jsThreadHooks.ts

@@ -8,6 +8,16 @@ const getUiFpsBuffer = () => PerformanceToolkit.getUiFpsBuffer()
 const getCpuUsageBuffer = () => PerformanceToolkit.getCpuUsageBuffer()
 const getMemoryUsageBuffer = () => PerformanceToolkit.getMemoryUsageBuffer()
 
+const getValueFromBuffer = (buffer: ArrayBuffer) => {
+  const view = new DataView(buffer)
+  return view.getInt32(0, true) // true = littleEndian
+}
+
+export const getJsFps = () => getValueFromBuffer(getJsFpsBuffer())
+export const getUiFps = () => getValueFromBuffer(getUiFpsBuffer())
+export const getCpuUsage = () => getValueFromBuffer(getCpuUsageBuffer())
+export const getMemoryUsage = () => getValueFromBuffer(getMemoryUsageBuffer())
+
 const prepareOnChange = (
   bufferGetter: () => ArrayBuffer,
   intervalMs: number = 1000
@@ -19,8 +29,7 @@ const prepareOnChange = (
         console.error(`Failed to get buffer.`)
         return
       }
-      const view = new DataView(buffer)
-      callback(view.getInt32(0, true)) // true = littleEndian
+      callback(getValueFromBuffer(buffer))
     }, intervalMs)
 
     return () => {

src/index.tsx

@@ -2,6 +2,7 @@ import './specs/TurboPerformanceToolkit'
 
 import React from 'react'
 import { UIThreadReanimatedCounter } from './components/UIThreadReanimatedCounter'
+import { PerformanceToolkit } from './hybrids'
 
 export {
   BoxedJsFpsTracking,
@@ -25,4 +26,10 @@ export const MemoryUsageCounter = () => {
   return <UIThreadReanimatedCounter label="RAM" type="memory" />
 }
 
+export const getDeviceMaxRefreshRate = () =>
+  PerformanceToolkit.getDeviceMaxRefreshRate()
+
+export const getDeviceCurrentRefreshRate = () =>
+  PerformanceToolkit.getDeviceCurrentRefreshRate()
+
 export * from './hooks/jsThreadHooks'

src/specs/performance-toolkit.nitro.ts

@@ -5,4 +5,6 @@ export interface PerformanceToolkit
   getUiFpsBuffer(): ArrayBuffer
   getCpuUsageBuffer(): ArrayBuffer
   getMemoryUsageBuffer(): ArrayBuffer
+  getDeviceMaxRefreshRate(): number
+  getDeviceCurrentRefreshRate(): number
 }