Proyectos de Subversion Iphone Microlearning

// Copyright 2019 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 <TargetConditionals.h>

#import "GoogleUtilities/AppDelegateSwizzler/Public/GoogleUtilities/GULSceneDelegateSwizzler.h"

#import "GoogleUtilities/AppDelegateSwizzler/Internal/GULSceneDelegateSwizzler_Private.h"

#import "GoogleUtilities/AppDelegateSwizzler/Public/GoogleUtilities/GULAppDelegateSwizzler.h"

#import "GoogleUtilities/Common/GULLoggerCodes.h"

#import "GoogleUtilities/Environment/Public/GoogleUtilities/GULAppEnvironmentUtil.h"

#import "GoogleUtilities/Logger/Public/GoogleUtilities/GULLogger.h"

#import "GoogleUtilities/Network/Public/GoogleUtilities/GULMutableDictionary.h"

#import <objc/runtime.h>

#if UISCENE_SUPPORTED

API_AVAILABLE(ios(13.0), tvos(13.0))

typedef void (*GULOpenURLContextsIMP)(id, SEL, UIScene *, NSSet<UIOpenURLContext *> *);

API_AVAILABLE(ios(13.0), tvos(13.0))

typedef void (^GULSceneDelegateInterceptorCallback)(id<UISceneDelegate>);

// The strings below are the keys for associated objects.

static char const *const kGULRealIMPBySelectorKey = "GUL_realIMPBySelector";

static char const *const kGULRealClassKey = "GUL_realClass";

#endif  // UISCENE_SUPPORTED

static GULLoggerService kGULLoggerSwizzler = @"[GoogleUtilities/SceneDelegateSwizzler]";

// Since Firebase SDKs also use this for app delegate proxying, in order to not be a breaking change

// we disable App Delegate proxying when either of these two flags are set to NO.

/** Plist key that allows Firebase developers to disable App and Scene Delegate Proxying. */

static NSString *const kGULFirebaseSceneDelegateProxyEnabledPlistKey =

    @"FirebaseAppDelegateProxyEnabled";

/** Plist key that allows developers not using Firebase to disable App and Scene Delegate Proxying.

 */

static NSString *const kGULGoogleUtilitiesSceneDelegateProxyEnabledPlistKey =

    @"GoogleUtilitiesAppDelegateProxyEnabled";

/** The prefix of the Scene Delegate. */

static NSString *const kGULSceneDelegatePrefix = @"GUL_";

/**

 * This class is necessary to store the delegates in an NSArray without retaining them.

 * [NSValue valueWithNonRetainedObject] also provides this functionality, but does not provide a

 * zeroing pointer. This will cause EXC_BAD_ACCESS when trying to access the object after it is

 * dealloced. Instead, this container stores a weak, zeroing reference to the object, which

 * automatically is set to nil by the runtime when the object is dealloced.

 */

@interface GULSceneZeroingWeakContainer : NSObject

/** Stores a weak object. */

@property(nonatomic, weak) id object;

@end

@implementation GULSceneZeroingWeakContainer

@end

@implementation GULSceneDelegateSwizzler

#pragma mark - Public methods

+ (BOOL)isSceneDelegateProxyEnabled {

  return [GULAppDelegateSwizzler isAppDelegateProxyEnabled];

}

+ (void)proxyOriginalSceneDelegate {

#if UISCENE_SUPPORTED

  if ([GULAppEnvironmentUtil isAppExtension]) {

    return;

  }

  static dispatch_once_t onceToken;

  dispatch_once(&onceToken, ^{

    if (@available(iOS 13.0, tvOS 13.0, *)) {

      if (![GULSceneDelegateSwizzler isSceneDelegateProxyEnabled]) {

        return;

      }

      [[NSNotificationCenter defaultCenter]

          addObserver:self

             selector:@selector(handleSceneWillConnectToNotification:)

                 name:UISceneWillConnectNotification

               object:nil];

    }

  });

#endif  // UISCENE_SUPPORTED

}

#if UISCENE_SUPPORTED

+ (GULSceneDelegateInterceptorID)registerSceneDelegateInterceptor:(id<UISceneDelegate>)interceptor {

  NSAssert(interceptor, @"SceneDelegateProxy cannot add nil interceptor");

  NSAssert([interceptor conformsToProtocol:@protocol(UISceneDelegate)],

           @"SceneDelegateProxy interceptor does not conform to UIApplicationDelegate");

  if (!interceptor) {

    GULLogError(kGULLoggerSwizzler, NO,

                [NSString stringWithFormat:@"I-SWZ%06ld",

                                           (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling000],

                @"SceneDelegateProxy cannot add nil interceptor.");

    return nil;

  }

  if (![interceptor conformsToProtocol:@protocol(UISceneDelegate)]) {

    GULLogError(kGULLoggerSwizzler, NO,

                [NSString stringWithFormat:@"I-SWZ%06ld",

                                           (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling001],

                @"SceneDelegateProxy interceptor does not conform to UIApplicationDelegate");

    return nil;

  }

  // The ID should be the same given the same interceptor object.

  NSString *interceptorID =

      [NSString stringWithFormat:@"%@%p", kGULSceneDelegatePrefix, interceptor];

  if (!interceptorID.length) {

    GULLogError(kGULLoggerSwizzler, NO,

                [NSString stringWithFormat:@"I-SWZ%06ld",

                                           (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling002],

                @"SceneDelegateProxy cannot create Interceptor ID.");

    return nil;

  }

  GULSceneZeroingWeakContainer *weakObject = [[GULSceneZeroingWeakContainer alloc] init];

  weakObject.object = interceptor;

  [GULSceneDelegateSwizzler interceptors][interceptorID] = weakObject;

  return interceptorID;

}

+ (void)unregisterSceneDelegateInterceptorWithID:(GULSceneDelegateInterceptorID)interceptorID {

  NSAssert(interceptorID, @"SceneDelegateProxy cannot unregister nil interceptor ID.");

  NSAssert(((NSString *)interceptorID).length != 0,

           @"SceneDelegateProxy cannot unregister empty interceptor ID.");

  if (!interceptorID) {

    GULLogError(kGULLoggerSwizzler, NO,

                [NSString stringWithFormat:@"I-SWZ%06ld",

                                           (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling003],

                @"SceneDelegateProxy cannot unregister empty interceptor ID.");

    return;

  }

  GULSceneZeroingWeakContainer *weakContainer =

      [GULSceneDelegateSwizzler interceptors][interceptorID];

  if (!weakContainer.object) {

    GULLogError(kGULLoggerSwizzler, NO,

                [NSString stringWithFormat:@"I-SWZ%06ld",

                                           (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling004],

                @"SceneDelegateProxy cannot unregister interceptor that was not registered. "

                 "Interceptor ID %@",

                interceptorID);

    return;

  }

  [[GULSceneDelegateSwizzler interceptors] removeObjectForKey:interceptorID];

}

#pragma mark - Helper methods

+ (GULMutableDictionary *)interceptors {

  static dispatch_once_t onceToken;

  static GULMutableDictionary *sInterceptors;

  dispatch_once(&onceToken, ^{

    sInterceptors = [[GULMutableDictionary alloc] init];

  });

  return sInterceptors;

}

+ (void)clearInterceptors {

  [[self interceptors] removeAllObjects];

}

+ (nullable NSValue *)originalImplementationForSelector:(SEL)selector object:(id)object {

  NSDictionary *realImplementationBySelector =

      objc_getAssociatedObject(object, &kGULRealIMPBySelectorKey);

  return realImplementationBySelector[NSStringFromSelector(selector)];

}

+ (void)proxyDestinationSelector:(SEL)destinationSelector

    implementationsFromSourceSelector:(SEL)sourceSelector

                            fromClass:(Class)sourceClass

                              toClass:(Class)destinationClass

                            realClass:(Class)realClass

     storeDestinationImplementationTo:

         (NSMutableDictionary<NSString *, NSValue *> *)destinationImplementationsBySelector {

  [self addInstanceMethodWithDestinationSelector:destinationSelector

            withImplementationFromSourceSelector:sourceSelector

                                       fromClass:sourceClass

                                         toClass:destinationClass];

  IMP sourceImplementation =

      [GULSceneDelegateSwizzler implementationOfMethodSelector:destinationSelector

                                                     fromClass:realClass];

  NSValue *sourceImplementationPointer = [NSValue valueWithPointer:sourceImplementation];

  NSString *destinationSelectorString = NSStringFromSelector(destinationSelector);

  destinationImplementationsBySelector[destinationSelectorString] = sourceImplementationPointer;

}

/** Copies a method identified by the methodSelector from one class to the other. After this method

 *  is called, performing [toClassInstance methodSelector] will be similar to calling

 *  [fromClassInstance methodSelector]. This method does nothing if toClass already has a method

 *  identified by methodSelector.

 *

 *  @param methodSelector The SEL that identifies both the method on the fromClass as well as the

 *      one on the toClass.

 *  @param fromClass The class from which a method is sourced.

 *  @param toClass The class to which the method is added. If the class already has a method with

 *      the same selector, this has no effect.

 */

+ (void)addInstanceMethodWithSelector:(SEL)methodSelector

                            fromClass:(Class)fromClass

                              toClass:(Class)toClass {

  [self addInstanceMethodWithDestinationSelector:methodSelector

            withImplementationFromSourceSelector:methodSelector

                                       fromClass:fromClass

                                         toClass:toClass];

}

/** Copies a method identified by the sourceSelector from the fromClass as a method for the

 *  destinationSelector on the toClass. After this method is called, performing

 *  [toClassInstance destinationSelector] will be similar to calling

 *  [fromClassInstance sourceSelector]. This method does nothing if toClass already has a method

 *  identified by destinationSelector.

 *

 *  @param destinationSelector The SEL that identifies the method on the toClass.

 *  @param sourceSelector The SEL that identifies the method on the fromClass.

 *  @param fromClass The class from which a method is sourced.

 *  @param toClass The class to which the method is added. If the class already has a method with

 *      the same selector, this has no effect.

 */

+ (void)addInstanceMethodWithDestinationSelector:(SEL)destinationSelector

            withImplementationFromSourceSelector:(SEL)sourceSelector

                                       fromClass:(Class)fromClass

                                         toClass:(Class)toClass {

  Method method = class_getInstanceMethod(fromClass, sourceSelector);

  IMP methodIMP = method_getImplementation(method);

  const char *types = method_getTypeEncoding(method);

  if (!class_addMethod(toClass, destinationSelector, methodIMP, types)) {

    GULLogWarning(

        kGULLoggerSwizzler, NO,

        [NSString

            stringWithFormat:@"I-SWZ%06ld", (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling009],

        @"Cannot copy method to destination selector %@ as it already exists",

        NSStringFromSelector(destinationSelector));

  }

}

/** Gets the IMP of the instance method on the class identified by the selector.

 *

 *  @param selector The selector of which the IMP is to be fetched.

 *  @param aClass The class from which the IMP is to be fetched.

 *  @return The IMP of the instance method identified by selector and aClass.

 */

+ (IMP)implementationOfMethodSelector:(SEL)selector fromClass:(Class)aClass {

  Method aMethod = class_getInstanceMethod(aClass, selector);

  return method_getImplementation(aMethod);

}

/** Enumerates through all the interceptors and if they respond to a given selector, executes a

 *  GULSceneDelegateInterceptorCallback with the interceptor.

 *

 *  @param methodSelector The SEL to check if an interceptor responds to.

 *  @param callback the GULSceneDelegateInterceptorCallback.

 */

+ (void)notifyInterceptorsWithMethodSelector:(SEL)methodSelector

                                    callback:(GULSceneDelegateInterceptorCallback)callback

    API_AVAILABLE(ios(13.0)) {

  if (!callback) {

    return;

  }

  NSDictionary *interceptors = [GULSceneDelegateSwizzler interceptors].dictionary;

  [interceptors enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {

    GULSceneZeroingWeakContainer *interceptorContainer = obj;

    id interceptor = interceptorContainer.object;

    if (!interceptor) {

      GULLogWarning(

          kGULLoggerSwizzler, NO,

          [NSString stringWithFormat:@"I-SWZ%06ld",

                                     (long)kGULSwizzlerMessageCodeSceneDelegateSwizzling010],

          @"SceneDelegateProxy cannot find interceptor with ID %@. Removing the interceptor.", key);

      [[GULSceneDelegateSwizzler interceptors] removeObjectForKey:key];

      return;

    }

    if ([interceptor respondsToSelector:methodSelector]) {

      callback(interceptor);

    }

  }];

}

+ (void)handleSceneWillConnectToNotification:(NSNotification *)notification {

  if (@available(iOS 13.0, tvOS 13.0, *)) {

    if ([notification.object isKindOfClass:[UIScene class]]) {

      UIScene *scene = (UIScene *)notification.object;

      [GULSceneDelegateSwizzler proxySceneDelegateIfNeeded:scene];

    }

  }

}

#pragma mark - [Donor Methods] UISceneDelegate URL handler

- (void)scene:(UIScene *)scene

    openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts API_AVAILABLE(ios(13.0), tvos(13.0)) {

  if (@available(iOS 13.0, tvOS 13.0, *)) {

    SEL methodSelector = @selector(scene:openURLContexts:);

    // Call the real implementation if the real Scene Delegate has any.

    NSValue *openURLContextsIMPPointer =

        [GULSceneDelegateSwizzler originalImplementationForSelector:methodSelector object:self];

    GULOpenURLContextsIMP openURLContextsIMP = [openURLContextsIMPPointer pointerValue];

    [GULSceneDelegateSwizzler

        notifyInterceptorsWithMethodSelector:methodSelector

                                    callback:^(id<UISceneDelegate> interceptor) {

                                      if ([interceptor

                                              conformsToProtocol:@protocol(UISceneDelegate)]) {

                                        id<UISceneDelegate> sceneInterceptor =

                                            (id<UISceneDelegate>)interceptor;

                                        [sceneInterceptor scene:scene openURLContexts:URLContexts];

                                      }

                                    }];

    if (openURLContextsIMP) {

      openURLContextsIMP(self, methodSelector, scene, URLContexts);

    }

  }

}

+ (void)proxySceneDelegateIfNeeded:(UIScene *)scene {

  Class realClass = [scene.delegate class];

  NSString *className = NSStringFromClass(realClass);

  // Skip proxying if failed to get the delegate class name for some reason (e.g. `delegate == nil`)

  // or the class has a prefix of kGULAppDelegatePrefix, which means it has been proxied before.

  if (className == nil || [className hasPrefix:kGULSceneDelegatePrefix]) {

    return;

  }

  NSString *classNameWithPrefix = [kGULSceneDelegatePrefix stringByAppendingString:className];

  NSString *newClassName =

      [NSString stringWithFormat:@"%@-%@", classNameWithPrefix, [NSUUID UUID].UUIDString];

  if (NSClassFromString(newClassName)) {

    GULLogError(

        kGULLoggerSwizzler, NO,

        [NSString

            stringWithFormat:@"I-SWZ%06ld",

                             (long)

                                 kGULSwizzlerMessageCodeSceneDelegateSwizzlingInvalidSceneDelegate],

        @"Cannot create a proxy for Scene Delegate. Subclass already exists. Original Class"

        @": %@, subclass: %@",

        className, newClassName);

    return;

  }

  // Register the new class as subclass of the real one. Do not allocate more than the real class

  // size.

  Class sceneDelegateSubClass = objc_allocateClassPair(realClass, newClassName.UTF8String, 0);

  if (sceneDelegateSubClass == Nil) {

    GULLogError(

        kGULLoggerSwizzler, NO,

        [NSString

            stringWithFormat:@"I-SWZ%06ld",

                             (long)

                                 kGULSwizzlerMessageCodeSceneDelegateSwizzlingInvalidSceneDelegate],

        @"Cannot create a proxy for Scene Delegate. Subclass already exists. Original Class"

        @": %@, subclass: Nil",

        className);

    return;

  }

  NSMutableDictionary<NSString *, NSValue *> *realImplementationsBySelector =

      [[NSMutableDictionary alloc] init];

  // For scene:openURLContexts:

  SEL openURLContextsSEL = @selector(scene:openURLContexts:);

  [self proxyDestinationSelector:openURLContextsSEL

      implementationsFromSourceSelector:openURLContextsSEL

                              fromClass:[GULSceneDelegateSwizzler class]

                                toClass:sceneDelegateSubClass

                              realClass:realClass

       storeDestinationImplementationTo:realImplementationsBySelector];

  // Store original implementations to a fake property of the original delegate.

  objc_setAssociatedObject(scene.delegate, &kGULRealIMPBySelectorKey,

                           [realImplementationsBySelector copy], OBJC_ASSOCIATION_RETAIN_NONATOMIC);

  objc_setAssociatedObject(scene.delegate, &kGULRealClassKey, realClass,

                           OBJC_ASSOCIATION_RETAIN_NONATOMIC);

  // The subclass size has to be exactly the same size with the original class size. The subclass

  // cannot have more ivars/properties than its superclass since it will cause an offset in memory

  // that can lead to overwriting the isa of an object in the next frame.

  if (class_getInstanceSize(realClass) != class_getInstanceSize(sceneDelegateSubClass)) {

    GULLogError(

        kGULLoggerSwizzler, NO,

        [NSString

            stringWithFormat:@"I-SWZ%06ld",

                             (long)

                                 kGULSwizzlerMessageCodeSceneDelegateSwizzlingInvalidSceneDelegate],

        @"Cannot create subclass of Scene Delegate, because the created subclass is not the "

        @"same size. %@",

        className);

    NSAssert(NO, @"Classes must be the same size to swizzle isa");

    return;

  }

  // Make the newly created class to be the subclass of the real Scene Delegate class.

  objc_registerClassPair(sceneDelegateSubClass);

  if (object_setClass(scene.delegate, sceneDelegateSubClass)) {

    GULLogDebug(

        kGULLoggerSwizzler, NO,

        [NSString

            stringWithFormat:@"I-SWZ%06ld",

                             (long)

                                 kGULSwizzlerMessageCodeSceneDelegateSwizzlingInvalidSceneDelegate],

        @"Successfully created Scene Delegate Proxy automatically. To disable the "

        @"proxy, set the flag %@ to NO (Boolean) in the Info.plist",

        [GULSceneDelegateSwizzler correctSceneDelegateProxyKey]);

  }

}

+ (NSString *)correctSceneDelegateProxyKey {

  return NSClassFromString(@"FIRCore") ? kGULFirebaseSceneDelegateProxyEnabledPlistKey

                                       : kGULGoogleUtilitiesSceneDelegateProxyEnabledPlistKey;

}

#endif  // UISCENE_SUPPORTED

@end