Proyectos de Subversion Iphone Microlearning

// Copyright 2020 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#import "FirebasePerformance/Sources/AppActivity/FPRScreenTraceTracker.h"

#import "FirebasePerformance/Sources/AppActivity/FPRScreenTraceTracker+Private.h"

#import <Foundation/Foundation.h>

#import <UIKit/UIKit.h>

#import "FirebasePerformance/Sources/Common/FPRDiagnostics.h"

NSString *const kFPRPrefixForScreenTraceName = @"_st_";

NSString *const kFPRFrozenFrameCounterName = @"_fr_fzn";

NSString *const kFPRSlowFrameCounterName = @"_fr_slo";

NSString *const kFPRTotalFramesCounterName = @"_fr_tot";

// Note: This was previously 60 FPS, but that resulted in 90% +  of all frames collected to be

// flagged as slow frames, and so the threshold for iOS is being changed to 59 FPS.

// TODO(b/73498642): Make these configurable.

CFTimeInterval const kFPRSlowFrameThreshold = 1.0 / 59.0;  // Anything less than 59 FPS is slow.

CFTimeInterval const kFPRFrozenFrameThreshold = 700.0 / 1000.0;

/** Constant that indicates an invalid time. */

CFAbsoluteTime const kFPRInvalidTime = -1.0;

/** Returns the class name without the prefixed module name present in Swift classes

 * (e.g. MyModule.MyViewController -> MyViewController).

 */

static NSString *FPRUnprefixedClassName(Class theClass) {

  NSString *className = NSStringFromClass(theClass);

  NSRange periodRange = [className rangeOfString:@"." options:NSBackwardsSearch];

  if (periodRange.location == NSNotFound) {

    return className;

  }

  return periodRange.location < className.length - 1

             ? [className substringFromIndex:periodRange.location + 1]

             : className;

}

/** Returns the name for the screen trace for a given UIViewController. It does the following:

 *  - Removes module name from swift classes - (e.g. MyModule.MyViewController -> MyViewController)

 *  - Prepends "_st_" to the class name

 *  - Truncates the length if it exceeds the maximum trace length.

 *

 *  @param viewController The view controller whose screen trace name we want. Cannot be nil.

 *  @return An NSString containing the trace name, or a string containing an error if the

 *      class was nil.

 */

static NSString *FPRScreenTraceNameForViewController(UIViewController *viewController) {

  NSString *unprefixedClassName = FPRUnprefixedClassName([viewController class]);

  if (unprefixedClassName.length != 0) {

    NSString *traceName =

        [NSString stringWithFormat:@"%@%@", kFPRPrefixForScreenTraceName, unprefixedClassName];

    return traceName.length > kFPRMaxNameLength ? [traceName substringToIndex:kFPRMaxNameLength]

                                                : traceName;

  } else {

    // This is unlikely, but might happen if there's a regression on iOS where the class name

    // returned for a non-nil class is nil or empty.

    return @"_st_ERROR_NIL_CLASS_NAME";

  }

}

@implementation FPRScreenTraceTracker {

  /** Instance variable storing the total frames observed so far. */

  atomic_int_fast64_t _totalFramesCount;

  /** Instance variable storing the slow frames observed so far. */

  atomic_int_fast64_t _slowFramesCount;

  /** Instance variable storing the frozen frames observed so far. */

  atomic_int_fast64_t _frozenFramesCount;

}

@dynamic totalFramesCount;

@dynamic frozenFramesCount;

@dynamic slowFramesCount;

+ (instancetype)sharedInstance {

  static FPRScreenTraceTracker *instance;

  static dispatch_once_t onceToken;

  dispatch_once(&onceToken, ^{

    instance = [[self alloc] init];

  });

  return instance;

}

- (instancetype)init {

  self = [super init];

  if (self) {

    // Weakly retain viewController, use pointer hashing.

    NSMapTableOptions keyOptions = NSMapTableWeakMemory | NSMapTableObjectPointerPersonality;

    // Strongly retain the FIRTrace.

    NSMapTableOptions valueOptions = NSMapTableStrongMemory;

    _activeScreenTraces = [NSMapTable mapTableWithKeyOptions:keyOptions valueOptions:valueOptions];

    _previouslyVisibleViewControllers = nil;  // Will be set when there is data.

    _screenTraceTrackerSerialQueue =

        dispatch_queue_create("com.google.FPRScreenTraceTracker", DISPATCH_QUEUE_SERIAL);

    _screenTraceTrackerDispatchGroup = dispatch_group_create();

    atomic_store_explicit(&_totalFramesCount, 0, memory_order_relaxed);

    atomic_store_explicit(&_frozenFramesCount, 0, memory_order_relaxed);

    atomic_store_explicit(&_slowFramesCount, 0, memory_order_relaxed);

    _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(displayLinkStep)];

    [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];

    // We don't receive background and foreground events from analytics and so we have to listen to

    // them ourselves.

    [[NSNotificationCenter defaultCenter] addObserver:self

                                             selector:@selector(appDidBecomeActiveNotification:)

                                                 name:UIApplicationDidBecomeActiveNotification

                                               object:[UIApplication sharedApplication]];

    [[NSNotificationCenter defaultCenter] addObserver:self

                                             selector:@selector(appWillResignActiveNotification:)

                                                 name:UIApplicationWillResignActiveNotification

                                               object:[UIApplication sharedApplication]];

  }

  return self;

}

- (void)dealloc {

  [_displayLink invalidate];

  [[NSNotificationCenter defaultCenter] removeObserver:self

                                                  name:UIApplicationDidBecomeActiveNotification

                                                object:[UIApplication sharedApplication]];

  [[NSNotificationCenter defaultCenter] removeObserver:self

                                                  name:UIApplicationWillResignActiveNotification

                                                object:[UIApplication sharedApplication]];

}

- (void)appDidBecomeActiveNotification:(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.

  int64_t currentTotalFrames = atomic_load_explicit(&_totalFramesCount, memory_order_relaxed);

  int64_t currentFrozenFrames = atomic_load_explicit(&_frozenFramesCount, memory_order_relaxed);

  int64_t currentSlowFrames = atomic_load_explicit(&_slowFramesCount, memory_order_relaxed);

  dispatch_group_async(self.screenTraceTrackerDispatchGroup, self.screenTraceTrackerSerialQueue, ^{

    for (id viewController in self.previouslyVisibleViewControllers) {

      [self startScreenTraceForViewController:viewController

                           currentTotalFrames:currentTotalFrames

                          currentFrozenFrames:currentFrozenFrames

                            currentSlowFrames:currentSlowFrames];

    }

    self.previouslyVisibleViewControllers = nil;

  });

}

- (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.

  int64_t currentTotalFrames = atomic_load_explicit(&_totalFramesCount, memory_order_relaxed);

  int64_t currentFrozenFrames = atomic_load_explicit(&_frozenFramesCount, memory_order_relaxed);

  int64_t currentSlowFrames = atomic_load_explicit(&_slowFramesCount, memory_order_relaxed);

  dispatch_group_async(self.screenTraceTrackerDispatchGroup, self.screenTraceTrackerSerialQueue, ^{

    self.previouslyVisibleViewControllers = [NSPointerArray weakObjectsPointerArray];

    id visibleViewControllersEnumerator = [self.activeScreenTraces keyEnumerator];

    id visibleViewController = nil;

    while (visibleViewController = [visibleViewControllersEnumerator nextObject]) {

      [self.previouslyVisibleViewControllers addPointer:(__bridge void *)(visibleViewController)];

    }

    for (id visibleViewController in self.previouslyVisibleViewControllers) {

      [self stopScreenTraceForViewController:visibleViewController

                          currentTotalFrames:currentTotalFrames

                         currentFrozenFrames:currentFrozenFrames

                           currentSlowFrames:currentSlowFrames];

    }

  });

}

#pragma mark - Frozen, slow and good frames

- (void)displayLinkStep {

  static CFAbsoluteTime previousTimestamp = kFPRInvalidTime;

  CFAbsoluteTime currentTimestamp = self.displayLink.timestamp;

  RecordFrameType(currentTimestamp, previousTimestamp, &_slowFramesCount, &_frozenFramesCount,

                  &_totalFramesCount);

  previousTimestamp = currentTimestamp;

}

/** This function increments the relevant frame counters based on the current and previous

 *  timestamp provided by the displayLink.

 *

 *  @param currentTimestamp The current timestamp of the displayLink.

 *  @param previousTimestamp The previous timestamp of the displayLink.

 *  @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,

                     atomic_int_fast64_t *slowFramesCounter,

                     atomic_int_fast64_t *frozenFramesCounter,

                     atomic_int_fast64_t *totalFramesCounter) {

  CFTimeInterval frameDuration = currentTimestamp - previousTimestamp;

  if (previousTimestamp == kFPRInvalidTime) {

    return;

  }

  if (frameDuration > kFPRSlowFrameThreshold) {

    atomic_fetch_add_explicit(slowFramesCounter, 1, memory_order_relaxed);

  }

  if (frameDuration > kFPRFrozenFrameThreshold) {

    atomic_fetch_add_explicit(frozenFramesCounter, 1, memory_order_relaxed);

  }

  atomic_fetch_add_explicit(totalFramesCounter, 1, memory_order_relaxed);

}

#pragma mark - Helper methods

/** Starts a screen trace for the given UIViewController instance if it doesn't exist. This method

 *  does NOT ensure thread safety - the caller is responsible for making sure that this is invoked

 *  in a thread safe manner.

 *

 *  @param viewController The UIViewController instance for which the trace is to be started.

 *  @param currentTotalFrames The value of the totalFramesCount before this method was called.

 *  @param currentFrozenFrames The value of the frozenFramesCount before this method was called.

 *  @param currentSlowFrames The value of the slowFramesCount before this method was called.

 */

- (void)startScreenTraceForViewController:(UIViewController *)viewController

                       currentTotalFrames:(int64_t)currentTotalFrames

                      currentFrozenFrames:(int64_t)currentFrozenFrames

                        currentSlowFrames:(int64_t)currentSlowFrames {

  if (![self shouldCreateScreenTraceForViewController:viewController]) {

    return;

  }

  // If there's a trace for this viewController, don't do anything.

  if (![self.activeScreenTraces objectForKey:viewController]) {

    NSString *traceName = FPRScreenTraceNameForViewController(viewController);

    FIRTrace *newTrace = [[FIRTrace alloc] initInternalTraceWithName:traceName];

    [newTrace start];

    [newTrace setIntValue:currentTotalFrames forMetric:kFPRTotalFramesCounterName];

    [newTrace setIntValue:currentFrozenFrames forMetric:kFPRFrozenFrameCounterName];

    [newTrace setIntValue:currentSlowFrames forMetric:kFPRSlowFrameCounterName];

    [self.activeScreenTraces setObject:newTrace forKey:viewController];

  }

}

/** Stops a screen trace for the given UIViewController instance if it exist. This method does NOT

 *  ensure thread safety - the caller is responsible for making sure that this is invoked in a

 *  thread safe manner.

 *

 *  @param viewController The UIViewController instance for which the trace is to be stopped.

 *  @param currentTotalFrames The value of the totalFramesCount before this method was called.

 *  @param currentFrozenFrames The value of the frozenFramesCount before this method was called.

 *  @param currentSlowFrames The value of the slowFramesCount before this method was called.

 */

- (void)stopScreenTraceForViewController:(UIViewController *)viewController

                      currentTotalFrames:(int64_t)currentTotalFrames

                     currentFrozenFrames:(int64_t)currentFrozenFrames

                       currentSlowFrames:(int64_t)currentSlowFrames {

  FIRTrace *previousScreenTrace = [self.activeScreenTraces objectForKey:viewController];

  // Get a diff between the counters now and what they were at trace start.

  int64_t actualTotalFrames =

      currentTotalFrames - [previousScreenTrace valueForIntMetric:kFPRTotalFramesCounterName];

  int64_t actualFrozenFrames =

      currentFrozenFrames - [previousScreenTrace valueForIntMetric:kFPRFrozenFrameCounterName];

  int64_t actualSlowFrames =

      currentSlowFrames - [previousScreenTrace valueForIntMetric:kFPRSlowFrameCounterName];

  // Update the values in the trace.

  if (actualTotalFrames != 0) {

    [previousScreenTrace setIntValue:actualTotalFrames forMetric:kFPRTotalFramesCounterName];

  } else {

    [previousScreenTrace deleteMetric:kFPRTotalFramesCounterName];

  }

  if (actualFrozenFrames != 0) {

    [previousScreenTrace setIntValue:actualFrozenFrames forMetric:kFPRFrozenFrameCounterName];

  } else {

    [previousScreenTrace deleteMetric:kFPRFrozenFrameCounterName];

  }

  if (actualSlowFrames != 0) {

    [previousScreenTrace setIntValue:actualSlowFrames forMetric:kFPRSlowFrameCounterName];

  } else {

    [previousScreenTrace deleteMetric:kFPRSlowFrameCounterName];

  }

  if (previousScreenTrace.numberOfCounters > 0) {

    [previousScreenTrace stop];

  } else {

    // The trace did not collect any data. Don't log it.

    [previousScreenTrace cancel];

  }

  [self.activeScreenTraces removeObjectForKey:viewController];

}

#pragma mark - Filtering for screen traces

/** Determines whether to create a screen trace for the given UIViewController instance.

 *

 *  @param viewController The UIViewController instance.

 *  @return YES if a screen trace should be created for the given UIViewController instance,

        NO otherwise.

 */

- (BOOL)shouldCreateScreenTraceForViewController:(UIViewController *)viewController {

  if (viewController == nil) {

    return NO;

  }

  // Ignore non-main bundle view controllers whose class or superclass is an internal iOS view

  // controller. This is borrowed from the logic for tracking screens in Firebase Analytics.

  NSBundle *bundle = [NSBundle bundleForClass:[viewController class]];

  if (bundle != [NSBundle mainBundle]) {

    NSString *className = FPRUnprefixedClassName([viewController class]);

    if ([className hasPrefix:@"_"]) {

      return NO;

    }

    NSString *superClassName = FPRUnprefixedClassName([viewController superclass]);

    if ([superClassName hasPrefix:@"_"]) {

      return NO;

    }

  }

  // We are not creating screen traces for these view controllers because they're container view

  // controllers. They always have a child view controller which will provide better context for a

  // screen trace. We are however capturing traces if a developer subclasses these as there may be

  // some context. Special case: We are not capturing screen traces for any input view

  // controllers.

  return !([viewController isMemberOfClass:[UINavigationController class]] ||

           [viewController isMemberOfClass:[UITabBarController class]] ||

           [viewController isMemberOfClass:[UISplitViewController class]] ||

           [viewController isMemberOfClass:[UIPageViewController class]] ||

           [viewController isKindOfClass:[UIInputViewController class]]);

}

#pragma mark - Screen Traces swizzling hooks

- (void)viewControllerDidAppear:(UIViewController *)viewController {

  // 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.

  int64_t currentTotalFrames = atomic_load_explicit(&_totalFramesCount, memory_order_relaxed);

  int64_t currentFrozenFrames = atomic_load_explicit(&_frozenFramesCount, memory_order_relaxed);

  int64_t currentSlowFrames = atomic_load_explicit(&_slowFramesCount, memory_order_relaxed);

  dispatch_sync(self.screenTraceTrackerSerialQueue, ^{

    [self startScreenTraceForViewController:viewController

                         currentTotalFrames:currentTotalFrames

                        currentFrozenFrames:currentFrozenFrames

                          currentSlowFrames:currentSlowFrames];

  });

}

- (void)viewControllerDidDisappear:(id)viewController {

  // 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.

  int64_t currentTotalFrames = atomic_load_explicit(&_totalFramesCount, memory_order_relaxed);

  int64_t currentFrozenFrames = atomic_load_explicit(&_frozenFramesCount, memory_order_relaxed);

  int64_t currentSlowFrames = atomic_load_explicit(&_slowFramesCount, memory_order_relaxed);

  dispatch_sync(self.screenTraceTrackerSerialQueue, ^{

    [self stopScreenTraceForViewController:viewController

                        currentTotalFrames:currentTotalFrames

                       currentFrozenFrames:currentFrozenFrames

                         currentSlowFrames:currentSlowFrames];

  });

}

#pragma mark - Test Helper Methods

- (int_fast64_t)totalFramesCount {

  return atomic_load_explicit(&_totalFramesCount, memory_order_relaxed);

}

- (void)setTotalFramesCount:(int_fast64_t)count {

  atomic_store_explicit(&_totalFramesCount, count, memory_order_relaxed);

}

- (int_fast64_t)slowFramesCount {

  return atomic_load_explicit(&_slowFramesCount, memory_order_relaxed);

}

- (void)setSlowFramesCount:(int_fast64_t)count {

  atomic_store_explicit(&_slowFramesCount, count, memory_order_relaxed);

}

- (int_fast64_t)frozenFramesCount {

  return atomic_load_explicit(&_frozenFramesCount, memory_order_relaxed);

}

- (void)setFrozenFramesCount:(int_fast64_t)count {

  atomic_store_explicit(&_frozenFramesCount, count, memory_order_relaxed);

}

@end