cocoapods-catalyst-validator 0.1.0.beta.1

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

@@ -0,0 +1,50 @@
+/*
+ * 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>
+
+#if TARGET_OS_IOS || TARGET_OS_TV
+
+#import <UIKit/UIKit.h>
+
+#define GULApplication UIApplication
+#define GULApplicationDelegate UIApplicationDelegate
+#define GULUserActivityRestoring UIUserActivityRestoring
+
+static NSString *const kGULApplicationClassName = @"UIApplication";
+
+#elif TARGET_OS_OSX
+
+#import <AppKit/AppKit.h>
+
+#define GULApplication NSApplication
+#define GULApplicationDelegate NSApplicationDelegate
+#define GULUserActivityRestoring NSUserActivityRestoring
+
+static NSString *const kGULApplicationClassName = @"NSApplication";
+
+#elif TARGET_OS_WATCH
+
+#import <WatchKit/WatchKit.h>
+
+// We match the according watchOS API but swizzling should not work in watch
+#define GULApplication WKExtension
+#define GULApplicationDelegate WKExtensionDelegate
+#define GULUserActivityRestoring NSUserActivityRestoring
+
+static NSString *const kGULApplicationClassName = @"WKExtension";
+
+#endif

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

@@ -0,0 +1,76 @@
+/*
+ * 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 <TargetConditionals.h>
+
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#endif  // !TARGET_OS_OSX
+
+#if ((TARGET_OS_IOS || TARGET_OS_TV) && (__IPHONE_OS_VERSION_MAX_ALLOWED >= 130000))
+#define UISCENE_SUPPORTED 1
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NSString *const GULSceneDelegateInterceptorID;
+
+/** This class contains methods that isa swizzle the scene delegate. */
+@interface GULSceneDelegateSwizzler : NSProxy
+
+#if UISCENE_SUPPORTED
+
+/** Registers a scene delegate interceptor whose methods will be invoked as they're invoked on the
+ *  original scene delegate.
+ *
+ *  @param interceptor An instance of a class that conforms to the application delegate protocol.
+ *      The interceptor is NOT retained.
+ *  @return A unique GULSceneDelegateInterceptorID if interceptor was successfully registered; nil
+ *      if it fails.
+ */
++ (nullable GULSceneDelegateInterceptorID)registerSceneDelegateInterceptor:
+    (id<UISceneDelegate>)interceptor API_AVAILABLE(ios(13.0), tvos(13.0));
+
+/** Unregisters an interceptor with the given ID if it exists.
+ *
+ *  @param interceptorID The object that was generated when the interceptor was registered.
+ */
++ (void)unregisterSceneDelegateInterceptorWithID:(GULSceneDelegateInterceptorID)interceptorID
+    API_AVAILABLE(ios(13.0), tvos(13.0));
+
+/** Do not initialize this class. */
+- (instancetype)init NS_UNAVAILABLE;
+
+#endif  // UISCENE_SUPPORTED
+
+/** This method ensures that the original scene delegate has been proxied. Call this before
+ *  registering your interceptor. This method is safe to call multiple times (but it only proxies
+ *  the scene delegate once).
+ *
+ *  The method has no effect for extensions.
+ */
++ (void)proxyOriginalSceneDelegate;
+
+/** Indicates whether scene delegate proxy is explicitly disabled or enabled. Enabled by default.
+ *
+ *  @return YES if SceneDelegateProxy is Enabled, NO otherwise.
+ */
++ (BOOL)isSceneDelegateProxyEnabled;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Common/GULLoggerCodes.h

@@ -0,0 +1,56 @@
+/*
+ * 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>
+
+typedef NS_ENUM(NSInteger, GULSwizzlerMessageCode) {
+  // App Delegate Swizzling.
+  kGULSwizzlerMessageCodeAppDelegateSwizzling000 = 1000,                 // I-SWZ001000
+  kGULSwizzlerMessageCodeAppDelegateSwizzling001 = 1001,                 // I-SWZ001001
+  kGULSwizzlerMessageCodeAppDelegateSwizzling002 = 1002,                 // I-SWZ001002
+  kGULSwizzlerMessageCodeAppDelegateSwizzling003 = 1003,                 // I-SWZ001003
+  kGULSwizzlerMessageCodeAppDelegateSwizzling004 = 1004,                 // I-SWZ001004
+  kGULSwizzlerMessageCodeAppDelegateSwizzling005 = 1005,                 // I-SWZ001005
+  kGULSwizzlerMessageCodeAppDelegateSwizzling006 = 1006,                 // I-SWZ001006
+  kGULSwizzlerMessageCodeAppDelegateSwizzling007 = 1007,                 // I-SWZ001007
+  kGULSwizzlerMessageCodeAppDelegateSwizzling008 = 1008,                 // I-SWZ001008
+  kGULSwizzlerMessageCodeAppDelegateSwizzling009 = 1009,                 // I-SWZ001009
+  kGULSwizzlerMessageCodeAppDelegateSwizzling010 = 1010,                 // I-SWZ001010
+  kGULSwizzlerMessageCodeAppDelegateSwizzling011 = 1011,                 // I-SWZ001011
+  kGULSwizzlerMessageCodeAppDelegateSwizzling012 = 1012,                 // I-SWZ001012
+  kGULSwizzlerMessageCodeAppDelegateSwizzling013 = 1013,                 // I-SWZ001013
+  kGULSwizzlerMessageCodeAppDelegateSwizzlingInvalidAppDelegate = 1014,  // I-SWZ001014
+
+  // Scene Delegate Swizzling.
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling000 = 1100,                   // I-SWZ001100
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling001 = 1101,                   // I-SWZ001101
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling002 = 1102,                   // I-SWZ001102
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling003 = 1103,                   // I-SWZ001103
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling004 = 1104,                   // I-SWZ001104
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling005 = 1105,                   // I-SWZ001105
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling006 = 1106,                   // I-SWZ001106
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling007 = 1107,                   // I-SWZ001107
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling008 = 1108,                   // I-SWZ001108
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling009 = 1109,                   // I-SWZ001109
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling010 = 1110,                   // I-SWZ001110
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling011 = 1111,                   // I-SWZ001111
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling012 = 1112,                   // I-SWZ001112
+  kGULSwizzlerMessageCodeSceneDelegateSwizzling013 = 1113,                   // I-SWZ001113
+  kGULSwizzlerMessageCodeSceneDelegateSwizzlingInvalidSceneDelegate = 1114,  // I-SWZ001114
+
+  // Method Swizzling.
+  kGULSwizzlerMessageCodeMethodSwizzling000 = 2000,  // I-SWZ002000
+};

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Environment/GULHeartbeatDateStorage.m

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2019 Google
+ *
+ * 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 "GoogleUtilities/Environment/Public/GoogleUtilities/GULHeartbeatDateStorage.h"
+#import "GoogleUtilities/Environment/Public/GoogleUtilities/GULSecureCoding.h"
+
+NSString *const kGULHeartbeatStorageDirectory = @"Google/FIRApp";
+
+@interface GULHeartbeatDateStorage ()
+
+/** The name of the file that stores heartbeat information. */
+@property(nonatomic, readonly) NSString *fileName;
+@end
+
+@implementation GULHeartbeatDateStorage
+
+@synthesize fileURL = _fileURL;
+
+- (instancetype)initWithFileName:(NSString *)fileName {
+  if (fileName == nil) return nil;
+
+  self = [super init];
+  if (self) {
+    _fileName = fileName;
+  }
+  return self;
+}
+
+/** Lazy getter for fileURL.
+ * @return fileURL where heartbeat information is stored.
+ */
+- (NSURL *)fileURL {
+  if (!_fileURL) {
+    NSURL *directoryURL = [self directoryPathURL];
+    [self checkAndCreateDirectory:directoryURL];
+    _fileURL = [directoryURL URLByAppendingPathComponent:_fileName];
+  }
+  return _fileURL;
+}
+
+/** Returns the URL path of the directory for heartbeat storage data.
+ * @return the URL path of the directory for heartbeat storage data.
+ */
+- (NSURL *)directoryPathURL {
+  NSArray<NSString *> *paths;
+#if TARGET_OS_TV
+  paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+#else
+  paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES);
+#endif  // TARGET_OS_TV
+  NSString *rootPath = [paths lastObject];
+  NSURL *rootURL = [NSURL fileURLWithPath:rootPath];
+  NSURL *directoryURL = [rootURL URLByAppendingPathComponent:kGULHeartbeatStorageDirectory];
+  return directoryURL;
+}
+
+/** Check for the existence of the directory specified by the URL, and create it if it does not
+ * exist.
+ * @param directoryPathURL The path to the directory that needs to exist.
+ */
+- (void)checkAndCreateDirectory:(NSURL *)directoryPathURL {
+  NSError *error;
+  if (![directoryPathURL checkResourceIsReachableAndReturnError:&error]) {
+    NSError *error;
+    [[NSFileManager defaultManager] createDirectoryAtURL:directoryPathURL
+                             withIntermediateDirectories:YES
+                                              attributes:nil
+                                                   error:&error];
+  }
+}
+
+- (nullable NSDate *)heartbeatDateForTag:(NSString *)tag {
+  @synchronized(self.class) {
+    NSDictionary *heartbeatDictionary = [self heartbeatDictionaryWithFileURL:self.fileURL];
+    NSDate *heartbeatDate = heartbeatDictionary[tag];
+
+    // Validate the value type. If the storage file was corrupted or updated with a different format
+    // by a newer SDK version the value type may be different.
+    if (![heartbeatDate isKindOfClass:[NSDate class]]) {
+      heartbeatDate = nil;
+    }
+
+    return heartbeatDate;
+  }
+}
+
+- (BOOL)setHearbeatDate:(NSDate *)date forTag:(NSString *)tag {
+  // Synchronize on the class to ensure that the different instances of the class will not access
+  // the same file concurrently.
+  // TODO: Consider a different synchronization strategy here and in `-heartbeatDateForTag:` method.
+  // Currently no heartbeats can be read/written concurrently even if they are in different files.
+  @synchronized(self.class) {
+    NSMutableDictionary *heartbeatDictionary =
+        [[self heartbeatDictionaryWithFileURL:self.fileURL] mutableCopy];
+    heartbeatDictionary[tag] = date;
+    NSError *error;
+    BOOL isSuccess = [self writeDictionary:[heartbeatDictionary copy]
+                             forWritingURL:self.fileURL
+                                     error:&error];
+    return isSuccess;
+  }
+}
+
+- (NSDictionary *)heartbeatDictionaryWithFileURL:(NSURL *)readingFileURL {
+  NSDictionary *heartbeatDictionary;
+
+  NSError *error;
+  NSData *objectData = [NSData dataWithContentsOfURL:readingFileURL options:0 error:&error];
+
+  if (objectData.length > 0 && error == nil) {
+    NSSet<Class> *objectClasses =
+        [NSSet setWithArray:@[ NSDictionary.class, NSDate.class, NSString.class ]];
+    heartbeatDictionary = [GULSecureCoding unarchivedObjectOfClasses:objectClasses
+                                                            fromData:objectData
+                                                               error:&error];
+  }
+
+  if (heartbeatDictionary.count == 0 || error != nil) {
+    heartbeatDictionary = [NSDictionary dictionary];
+  }
+
+  return heartbeatDictionary;
+}
+
+- (BOOL)writeDictionary:(NSDictionary *)dictionary
+          forWritingURL:(NSURL *)writingFileURL
+                  error:(NSError **)outError {
+  // Archive a mutable copy `dictionary` for writing to disk. This is done for
+  // backwards compatibility. See Google Utilities issue #36 for more context.
+  // TODO: Remove usage of mutable copy in a future version of Google Utilities.
+  NSData *data = [GULSecureCoding archivedDataWithRootObject:[dictionary mutableCopy]
+                                                       error:outError];
+  if (data.length == 0) {
+    return NO;
+  }
+
+  return [data writeToURL:writingFileURL atomically:YES];
+}
+
+@end

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Environment/GULHeartbeatDateStorageUserDefaults.m

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 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 "GoogleUtilities/Environment/Public/GoogleUtilities/GULHeartbeatDateStorageUserDefaults.h"
+
+@interface GULHeartbeatDateStorageUserDefaults ()
+
+/** The storage to store the date of the last sent heartbeat. */
+@property(nonatomic, readonly) NSUserDefaults *userDefaults;
+
+/** The key for user defaults to store heartbeat information. */
+@property(nonatomic, readonly) NSString *key;
+
+@end
+
+@implementation GULHeartbeatDateStorageUserDefaults
+
+- (instancetype)initWithDefaults:(NSUserDefaults *)defaults key:(NSString *)key {
+  self = [super init];
+  if (self) {
+    _userDefaults = defaults;
+    _key = key;
+  }
+  return self;
+}
+
+- (NSMutableDictionary *)heartbeatDictionaryFromDefaults {
+  NSDictionary *heartbeatDict = [self.userDefaults objectForKey:self.key];
+  if (heartbeatDict != nil) {
+    return [heartbeatDict mutableCopy];
+  } else {
+    return [NSMutableDictionary dictionary];
+  }
+}
+
+- (nullable NSDate *)heartbeatDateForTag:(NSString *)tag {
+  NSDate *date = nil;
+  @synchronized(self.userDefaults) {
+    NSMutableDictionary *dict = [self heartbeatDictionaryFromDefaults];
+    date = dict[tag];
+  }
+
+  return date;
+}
+
+- (BOOL)setHearbeatDate:(NSDate *)date forTag:(NSString *)tag {
+  @synchronized(self.userDefaults) {
+    NSMutableDictionary *dict = [self heartbeatDictionaryFromDefaults];
+    dict[tag] = date;
+    [self.userDefaults setObject:dict forKey:self.key];
+  }
+  return true;
+}
+
+@end

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Environment/GULSecureCoding.m

@@ -0,0 +1,103 @@
+// Copyright 2019 Google
+//
+// 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 "GoogleUtilities/Environment/Public/GoogleUtilities/GULSecureCoding.h"
+
+NSString *const kGULSecureCodingError = @"GULSecureCodingError";
+
+@implementation GULSecureCoding
+
++ (nullable id)unarchivedObjectOfClasses:(NSSet<Class> *)classes
+                                fromData:(NSData *)data
+                                   error:(NSError **)outError {
+  id object;
+#if __has_builtin(__builtin_available)
+  if (@available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)) {
+    object = [NSKeyedUnarchiver unarchivedObjectOfClasses:classes fromData:data error:outError];
+  } else
+#endif  // __has_builtin(__builtin_available)
+  {
+    @try {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+      NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
+#pragma clang diagnostic pop
+      unarchiver.requiresSecureCoding = YES;
+
+      object = [unarchiver decodeObjectOfClasses:classes forKey:NSKeyedArchiveRootObjectKey];
+    } @catch (NSException *exception) {
+      if (outError) {
+        *outError = [self archivingErrorWithException:exception];
+      }
+    }
+
+    if (object == nil && outError && *outError == nil) {
+      NSString *failureReason = @"NSKeyedUnarchiver failed to unarchive data.";
+      *outError = [NSError errorWithDomain:kGULSecureCodingError
+                                      code:-1
+                                  userInfo:@{NSLocalizedFailureReasonErrorKey : failureReason}];
+    }
+  }
+
+  return object;
+}
+
++ (nullable id)unarchivedObjectOfClass:(Class)class
+                              fromData:(NSData *)data
+                                 error:(NSError **)outError {
+  return [self unarchivedObjectOfClasses:[NSSet setWithObject:class] fromData:data error:outError];
+}
+
++ (nullable NSData *)archivedDataWithRootObject:(id<NSCoding>)object error:(NSError **)outError {
+  NSData *archiveData;
+#if __has_builtin(__builtin_available)
+  if (@available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)) {
+    archiveData = [NSKeyedArchiver archivedDataWithRootObject:object
+                                        requiringSecureCoding:YES
+                                                        error:outError];
+  } else
+#endif  // __has_builtin(__builtin_available)
+  {
+    @try {
+      NSMutableData *data = [NSMutableData data];
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+      NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
+#pragma clang diagnostic pop
+      archiver.requiresSecureCoding = YES;
+
+      [archiver encodeObject:object forKey:NSKeyedArchiveRootObjectKey];
+      [archiver finishEncoding];
+
+      archiveData = [data copy];
+    } @catch (NSException *exception) {
+      if (outError) {
+        *outError = [self archivingErrorWithException:exception];
+      }
+    }
+  }
+
+  return archiveData;
+}
+
++ (NSError *)archivingErrorWithException:(NSException *)exception {
+  NSString *failureReason = [NSString
+      stringWithFormat:@"NSKeyedArchiver exception with name: %@, reason: %@, userInfo: %@",
+                       exception.name, exception.reason, exception.userInfo];
+  NSDictionary *errorUserInfo = @{NSLocalizedFailureReasonErrorKey : failureReason};
+
+  return [NSError errorWithDomain:kGULSecureCodingError code:-1 userInfo:errorUserInfo];
+}
+
+@end

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Environment/Public/GoogleUtilities/GULAppEnvironmentUtil.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2017 Google
+ *
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GULAppEnvironmentUtil : NSObject
+
+/// Indicates whether the app is from Apple Store or not. Returns NO if the app is on simulator,
+/// development environment or sideloaded.
++ (BOOL)isFromAppStore;
+
+/// Indicates whether the app is a Testflight app. Returns YES if the app has sandbox receipt.
+/// Returns NO otherwise.
++ (BOOL)isAppStoreReceiptSandbox;
+
+/// Indicates whether the app is on simulator or not at runtime depending on the device
+/// architecture.
++ (BOOL)isSimulator;
+
+/// The current device model. Returns an empty string if device model cannot be retrieved.
++ (nullable NSString *)deviceModel;
+
+/// The current operating system version. Returns an empty string if the system version cannot be
+/// retrieved.
++ (NSString *)systemVersion;
+
+/// Indicates whether it is running inside an extension or an app.
++ (BOOL)isAppExtension;
+
+/// @return Returns @YES when is run on iOS version greater or equal to 7.0
++ (BOOL)isIOS7OrHigher DEPRECATED_MSG_ATTRIBUTE(
+    "Always `YES` because only iOS 8 and higher supported. The method will be removed.");
+
+/// @return YES if Swift runtime detected in the app.
++ (BOOL)hasSwiftRuntime __deprecated;
+
+/// @return An Apple platform. Possible values "ios", "tvos", "macos", "watchos", "maccatalyst".
++ (NSString *)applePlatform;
+
+/// @return The way the library was added to the app, e.g. "swiftpm", "cocoapods", etc.
++ (NSString *)deploymentType;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Environment/Public/GoogleUtilities/GULHeartbeatDateStorable.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Describes an object that can store and fetch heartbeat dates for given tags.
+ */
+@protocol GULHeartbeatDateStorable <NSObject>
+
+/**
+ * Reads the date from the specified file for the given tag.
+ * @return Returns date if exists, otherwise `nil`.
+ */
+- (nullable NSDate *)heartbeatDateForTag:(NSString *)tag;
+
+/**
+ * Saves the date for the specified tag in the specified file.
+ * @return YES on success, NO otherwise.
+ */
+- (BOOL)setHearbeatDate:(NSDate *)date forTag:(NSString *)tag;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleUtilities/GoogleUtilities/Environment/Public/GoogleUtilities/GULHeartbeatDateStorage.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 Google
+ *
+ * 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 "GULHeartbeatDateStorable.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The name of the directory where the heartbeat data is stored.
+extern NSString *const kGULHeartbeatStorageDirectory;
+
+/// Stores either a date or a dictionary to a specified file.
+@interface GULHeartbeatDateStorage : NSObject <GULHeartbeatDateStorable>
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@property(nonatomic, readonly) NSURL *fileURL;
+
+/**
+ * Default initializer.
+ * @param fileName The name of the file to store the date information.
+ * exist, it will be created if needed.
+ */
+- (instancetype)initWithFileName:(NSString *)fileName;
+
+/**
+ * Reads the date from the specified file for the given tag.
+ * @return Returns date if exists, otherwise `nil`.
+ */
+- (nullable NSDate *)heartbeatDateForTag:(NSString *)tag;
+
+/**
+ * Saves the date for the specified tag in the specified file.
+ * @return YES on success, NO otherwise.
+ */
+- (BOOL)setHearbeatDate:(NSDate *)date forTag:(NSString *)tag;
+
+@end
+
+NS_ASSUME_NONNULL_END