Cache slow frame budget and implement a refresh on app active

Author: JesusRojass

FirebasePerformance/Sources/AppActivity/FPRScreenTraceTracker+Private.h

@@ -39,13 +39,14 @@ FOUNDATION_EXTERN NSString *const kFPRTotalFramesCounterName;
 
 /** Legacy slow frame threshold constant (formerly 1/59).
  *  NOTE: This constant is deprecated and maintained only for test compatibility.
- *  The actual slow frame detection now uses UIScreen.maximumFramesPerSecond dynamically.
+ *  The actual slow frame detection uses a cached value computed from
+ *  UIScreen.maximumFramesPerSecond (slow threshold = 1000 / maxFPS ms).
  *  New code should not rely on this value.
  */
 FOUNDATION_EXTERN CFTimeInterval const kFPRSlowFrameThreshold;
 
 /** Frozen frame threshold (for time difference between current and previous frame render time)
- *  in sec.
+ *  in sec. Frozen threshold = 700 ms (>700 ms).
  */
 FOUNDATION_EXTERN CFTimeInterval const kFPRFrozenFrameThreshold;
 

FirebasePerformance/Sources/AppActivity/FPRScreenTraceTracker.m

@@ -27,11 +27,13 @@
 
 // Note: The slow frame threshold is now dynamically computed based on UIScreen's
 // maximumFramesPerSecond to align with device capabilities (ProMotion, tvOS, etc.).
+// Slow threshold = 1000 / UIScreen.maximumFramesPerSecond ms (or 1.0 / maxFPS seconds).
 // For devices reporting 60 FPS, the threshold is approximately 16.67ms (1/60).
+// The threshold is cached and refreshed when the app becomes active.
 // TODO(b/73498642): Make these configurable.
 
 // Legacy constant maintained for test compatibility. The actual slow frame detection
-// uses FPRSlowBudgetSeconds() which queries UIScreen.maximumFramesPerSecond dynamically.
+// uses a cached value computed from UIScreen.maximumFramesPerSecond.
 CFTimeInterval const kFPRSlowFrameThreshold = 1.0 / 60.0;
 
 CFTimeInterval const kFPRFrozenFrameThreshold = 700.0 / 1000.0;
@@ -91,6 +93,14 @@ static inline CFTimeInterval FPRSlowBudgetSeconds(void) {
   }
 }
 
+@interface FPRScreenTraceTracker ()
+
+@property(nonatomic) NSInteger fpr_cachedMaxFPS;
+
+@property(nonatomic) CFTimeInterval fpr_cachedSlowBudget;
+
+@end
+
 @implementation FPRScreenTraceTracker {
   /** Instance variable storing the total frames observed so far. */
   atomic_int_fast64_t _totalFramesCount;
@@ -146,6 +156,17 @@ - (instancetype)init {
                                              selector:@selector(appWillResignActiveNotification:)
                                                  name:UIApplicationWillResignActiveNotification
                                                object:[UIApplication sharedApplication]];
+
+    // Initialize cached FPS and slow budget
+    NSInteger __fps = UIScreen.mainScreen.maximumFramesPerSecond ?: 60;
+    self.fpr_cachedMaxFPS = __fps;
+    self.fpr_cachedSlowBudget = 1.0 / (double)__fps;
+
+    // Observe app becoming active to refresh FPS cache
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(appDidBecomeActive:)
+                                                 name:UIApplicationDidBecomeActiveNotification
+                                               object:nil];
   }
   return self;
 }
@@ -156,6 +177,9 @@ - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self
                                                   name:UIApplicationDidBecomeActiveNotification
                                                 object:[UIApplication sharedApplication]];
+  [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                  name:UIApplicationDidBecomeActiveNotification
+                                                object:nil];
   [[NSNotificationCenter defaultCenter] removeObserver:self
                                                   name:UIApplicationWillResignActiveNotification
                                                 object:[UIApplication sharedApplication]];
@@ -179,6 +203,12 @@ - (void)appDidBecomeActiveNotification:(NSNotification *)notification {
   });
 }
 
+- (void)appDidBecomeActive:(NSNotification *)note {
+  NSInteger __fps = UIScreen.mainScreen.maximumFramesPerSecond ?: 60;
+  self.fpr_cachedMaxFPS = __fps;
+  self.fpr_cachedSlowBudget = 1.0 / (double)__fps;
+}
+
 - (void)appWillResignActiveNotification:(NSNotification *)notification {
   // To get the most accurate numbers of total, frozen and slow frames, we need to capture them as
   // soon as we're notified of an event.
@@ -208,8 +238,9 @@ - (void)appWillResignActiveNotification:(NSNotification *)notification {
 - (void)displayLinkStep {
   static CFAbsoluteTime previousTimestamp = kFPRInvalidTime;
   CFAbsoluteTime currentTimestamp = self.displayLink.timestamp;
-  RecordFrameType(currentTimestamp, previousTimestamp, &_slowFramesCount, &_frozenFramesCount,
-                  &_totalFramesCount);
+  CFTimeInterval slowBudget = self.fpr_cachedSlowBudget;
+  RecordFrameType(currentTimestamp, previousTimestamp, slowBudget, &_slowFramesCount,
+                  &_frozenFramesCount, &_totalFramesCount);
   previousTimestamp = currentTimestamp;
 }
 
@@ -218,21 +249,22 @@ - (void)displayLinkStep {
  *
  *  @param currentTimestamp The current timestamp of the displayLink.
  *  @param previousTimestamp The previous timestamp of the displayLink.
+ *  @param slowBudget The cached slow frame budget in seconds (1.0 / maxFPS).
  *  @param slowFramesCounter The value of the slowFramesCount before this function was called.
  *  @param frozenFramesCounter The value of the frozenFramesCount before this function was called.
  *  @param totalFramesCounter The value of the totalFramesCount before this function was called.
  */
 FOUNDATION_STATIC_INLINE
 void RecordFrameType(CFAbsoluteTime currentTimestamp,
                      CFAbsoluteTime previousTimestamp,
+                     CFTimeInterval slowBudget,
                      atomic_int_fast64_t *slowFramesCounter,
                      atomic_int_fast64_t *frozenFramesCounter,
                      atomic_int_fast64_t *totalFramesCounter) {
   CFTimeInterval frameDuration = currentTimestamp - previousTimestamp;
   if (previousTimestamp == kFPRInvalidTime) {
     return;
   }
-  CFTimeInterval slowBudget = FPRSlowBudgetSeconds();
   if (frameDuration > slowBudget) {
     atomic_fetch_add_explicit(slowFramesCounter, 1, memory_order_relaxed);
   }

FirebasePerformance/Tests/Unit/FPRScreenTraceTrackerTest.m

@@ -969,6 +969,8 @@ + (NSString *)expectedTraceNameForViewController:(UIViewController *)viewControl
 /** Helper to run a single FPS test case with the given tracker and expectations. */
 static inline void FPRRunFpsTestCase(FPRScreenTraceTrackerTest *testCase, FPRFpsCase fpsCase) {
   [testCase setTestMaxFPSOverride:fpsCase.fps];
+  // Force the tracker to recompute the cache with the overridden FPS
+  [testCase.tracker appDidBecomeActive:nil];
 
   CFAbsoluteTime firstFrameRenderTimestamp = 1.0;
   // Frame that should be classified as slow (exceeds budget)