cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/AppDelegateSwizzler/GULSceneDelegateSwizzler.m

@@ -0,0 +1,439 @@
+// 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

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/AppDelegateSwizzler/Internal/GULAppDelegateSwizzler_Private.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2018 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 <Foundation/Foundation.h>
+#import "GoogleUtilities/AppDelegateSwizzler/Public/GoogleUtilities/GULAppDelegateSwizzler.h"
+#import "GoogleUtilities/Network/Public/GoogleUtilities/GULMutableDictionary.h"
+
+@class GULApplication;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GULAppDelegateSwizzler ()
+
+/** ISA Swizzles the given appDelegate as the original app delegate would be.
+ *
+ *  @param appDelegate The object that needs to be isa swizzled. This should conform to the
+ *      application delegate protocol.
+ */
++ (void)proxyAppDelegate:(id<GULApplicationDelegate>)appDelegate;
+
+/** Returns a dictionary containing interceptor IDs mapped to a GULZeroingWeakContainer.
+ *
+ *  @return A dictionary of the form {NSString : GULZeroingWeakContainer}, where the NSString is
+ *      the interceptorID.
+ */
++ (GULMutableDictionary *)interceptors;
+
+/** Deletes all the registered interceptors. */
++ (void)clearInterceptors;
+
+/** Resets the token that prevents the app delegate proxy from being isa swizzled multiple times. */
++ (void)resetProxyOriginalDelegateOnceToken;
+
+/** Returns the original app delegate that was proxied.
+ *
+ *  @return The original app delegate instance that was proxied.
+ */
++ (id<GULApplicationDelegate>)originalDelegate;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/AppDelegateSwizzler/Internal/GULSceneDelegateSwizzler_Private.h

@@ -0,0 +1,48 @@
+/*
+ * 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 <Foundation/Foundation.h>
+#import "GoogleUtilities/AppDelegateSwizzler/Public/GoogleUtilities/GULSceneDelegateSwizzler.h"
+#import "GoogleUtilities/Network/Public/GoogleUtilities/GULMutableDictionary.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GULSceneDelegateSwizzler ()
+
+#if UISCENE_SUPPORTED
+
+/** Returns a dictionary containing interceptor IDs mapped to a GULZeroingWeakContainer.
+ *
+ *  @return A dictionary of the form {NSString : GULZeroingWeakContainer}, where the NSString is
+ *      the interceptorID.
+ */
++ (GULMutableDictionary *)interceptors;
+
+/** Deletes all the registered interceptors. */
++ (void)clearInterceptors;
+
+/** ISA Swizzles the given appDelegate as the original app delegate would be.
+ *
+ *  @param scene The scene whose delegate needs to be isa swizzled. This should conform to the
+ *      scene delegate protocol.
+ */
++ (void)proxySceneDelegateIfNeeded:(UIScene *)scene API_AVAILABLE(ios(13.0), tvos(13.0));
+
+#endif  // UISCENE_SUPPORTED
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/AppDelegateSwizzler/Public/GoogleUtilities/GULAppDelegateSwizzler.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2018 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 <Foundation/Foundation.h>
+
+#import "GULApplication.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NSString *const GULAppDelegateInterceptorID;
+
+/** This class contains methods that isa swizzle the app delegate. */
+@interface GULAppDelegateSwizzler : NSProxy
+
+/** Registers an app delegate interceptor whose methods will be invoked as they're invoked on the
+ *  original app delegate.
+ *
+ *  @param interceptor An instance of a class that conforms to the application delegate protocol.
+ *      The interceptor is NOT retained.
+ *  @return A unique GULAppDelegateInterceptorID if interceptor was successfully registered; nil
+ *      if it fails.
+ */
++ (nullable GULAppDelegateInterceptorID)registerAppDelegateInterceptor:
+    (id<GULApplicationDelegate>)interceptor;
+
+/** Unregisters an interceptor with the given ID if it exists.
+ *
+ *  @param interceptorID The object that was generated when the interceptor was registered.
+ */
++ (void)unregisterAppDelegateInterceptorWithID:(GULAppDelegateInterceptorID)interceptorID;
+
+/** This method ensures that the original app delegate has been proxied. Call this before
+ *  registering your interceptor. This method is safe to call multiple times (but it only proxies
+ *  the app delegate once).
+ *
+ *  This method doesn't proxy APNS related methods:
+ *  @code
+ *    - application:didRegisterForRemoteNotificationsWithDeviceToken:
+ *    - application:didFailToRegisterForRemoteNotificationsWithError:
+ *    - application:didReceiveRemoteNotification:fetchCompletionHandler:
+ *    - application:didReceiveRemoteNotification:
+ *  @endcode
+ *
+ *  To proxy these methods use +[GULAppDelegateSwizzler
+ *  proxyOriginalDelegateIncludingAPNSMethods]. The methods have to be proxied separately to
+ *  avoid potential warnings from Apple review about missing Push Notification Entitlement (e.g.
+ *  https://github.com/firebase/firebase-ios-sdk/issues/2807)
+ *
+ *  The method has no effect for extensions.
+ *
+ *  @see proxyOriginalDelegateIncludingAPNSMethods
+ */
++ (void)proxyOriginalDelegate;
+
+/** This method ensures that the original app delegate has been proxied including APNS related
+ *  methods. Call this before registering your interceptor. This method is safe to call multiple
+ *  times (but it only proxies the app delegate once) or
+ *  after +[GULAppDelegateSwizzler proxyOriginalDelegate]
+ *
+ *  This method calls +[GULAppDelegateSwizzler proxyOriginalDelegate] under the hood.
+ *  After calling this method the following App Delegate methods will be proxied in addition to
+ *  the methods proxied by proxyOriginalDelegate:
+ *  @code
+ *    - application:didRegisterForRemoteNotificationsWithDeviceToken:
+ *    - application:didFailToRegisterForRemoteNotificationsWithError:
+ *    - application:didReceiveRemoteNotification:fetchCompletionHandler:
+ *    - application:didReceiveRemoteNotification:
+ *  @endcode
+ *
+ *  The method has no effect for extensions.
+ *
+ *  @see proxyOriginalDelegate
+ */
++ (void)proxyOriginalDelegateIncludingAPNSMethods;
+
+/** Indicates whether app delegate proxy is explicitly disabled or enabled. Enabled by default.
+ *
+ *  @return YES if AppDelegateProxy is Enabled, NO otherwise.
+ */
++ (BOOL)isAppDelegateProxyEnabled;
+
+/** Returns the current sharedApplication.
+ *
+ *  @return the current application instance if in an app, or nil if in extension or if it doesn't
+ * exist.
+ */
++ (nullable GULApplication *)sharedApplication;
+
+/** Do not initialize this class. */
+- (instancetype)init NS_UNAVAILABLE;
+
+NS_ASSUME_NONNULL_END
+
+@end