cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORUploadCoordinator.m

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2018 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 "GoogleDataTransport/GDTCORLibrary/Private/GDTCORUploadCoordinator.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORAssert.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORReachability.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORClock.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORRegistrar_Private.h"
+
+@implementation GDTCORUploadCoordinator
+
++ (instancetype)sharedInstance {
+  static GDTCORUploadCoordinator *sharedUploader;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedUploader = [[GDTCORUploadCoordinator alloc] init];
+    [sharedUploader startTimer];
+  });
+  return sharedUploader;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _coordinationQueue =
+        dispatch_queue_create("com.google.GDTCORUploadCoordinator", DISPATCH_QUEUE_SERIAL);
+    _registrar = [GDTCORRegistrar sharedInstance];
+    _timerInterval = 30 * NSEC_PER_SEC;
+    _timerLeeway = 5 * NSEC_PER_SEC;
+  }
+  return self;
+}
+
+- (void)forceUploadForTarget:(GDTCORTarget)target {
+  dispatch_async(_coordinationQueue, ^{
+    GDTCORLogDebug(@"Forcing an upload of target %ld", (long)target);
+    GDTCORUploadConditions conditions = [self uploadConditions];
+    conditions |= GDTCORUploadConditionHighPriority;
+    [self uploadTargets:@[ @(target) ] conditions:conditions];
+  });
+}
+
+#pragma mark - Private helper methods
+
+/** Starts a timer that checks whether or not events can be uploaded at regular intervals. It will
+ * check the next-upload clocks of all targets to determine if an upload attempt can be made.
+ */
+- (void)startTimer {
+  dispatch_async(_coordinationQueue, ^{
+    if (self->_timer) {
+      // The timer has been already started.
+      return;
+    }
+
+    // Delay the timer slightly so it doesn't run while +load calls are still running.
+    dispatch_time_t deadline = dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC / 2);
+
+    self->_timer =
+        dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self->_coordinationQueue);
+    dispatch_source_set_timer(self->_timer, deadline, self->_timerInterval, self->_timerLeeway);
+
+    dispatch_source_set_event_handler(self->_timer, ^{
+      if (![[GDTCORApplication sharedApplication] isRunningInBackground]) {
+        GDTCORUploadConditions conditions = [self uploadConditions];
+        GDTCORLogDebug(@"%@", @"Upload timer fired");
+        [self uploadTargets:[self.registrar.targetToUploader allKeys] conditions:conditions];
+      }
+    });
+    GDTCORLogDebug(@"%@", @"Upload timer started");
+    dispatch_resume(self->_timer);
+  });
+}
+
+/** Stops the currently running timer. */
+- (void)stopTimer {
+  if (_timer) {
+    dispatch_source_cancel(_timer);
+    _timer = nil;
+  }
+}
+
+/** Triggers the uploader implementations for the given targets to upload.
+ *
+ * @param targets An array of targets to trigger.
+ * @param conditions The set of upload conditions.
+ */
+- (void)uploadTargets:(NSArray<NSNumber *> *)targets conditions:(GDTCORUploadConditions)conditions {
+  dispatch_async(_coordinationQueue, ^{
+    // TODO: The reachability signal may be not reliable enough to prevent an upload attempt.
+    // See https://developer.apple.com/videos/play/wwdc2019/712/ (49:40) for more details.
+    if ((conditions & GDTCORUploadConditionNoNetwork) == GDTCORUploadConditionNoNetwork) {
+      return;
+    }
+    for (NSNumber *target in targets) {
+      id<GDTCORUploader> uploader = self->_registrar.targetToUploader[target];
+      [uploader uploadTarget:target.intValue withConditions:conditions];
+    }
+  });
+}
+
+- (void)signalToStoragesToCheckExpirations {
+  // The same storage may be associated with several targets. Make sure to check for expirations
+  // only once per storage.
+  NSSet<id<GDTCORStorageProtocol>> *storages =
+      [NSSet setWithArray:[_registrar.targetToStorage allValues]];
+  for (id<GDTCORStorageProtocol> storage in storages) {
+    [storage checkForExpirations];
+  }
+}
+
+/** Returns the registered storage for the given NSNumber wrapped GDTCORTarget.
+ *
+ * @param target The NSNumber wrapping of a GDTCORTarget to find the storage instance of.
+ * @return The storage instance for the given target.
+ */
+- (nullable id<GDTCORStorageProtocol>)storageForTarget:(NSNumber *)target {
+  id<GDTCORStorageProtocol> storage = [GDTCORRegistrar sharedInstance].targetToStorage[target];
+  GDTCORAssert(storage, @"A storage must be registered for target %@", target);
+  return storage;
+}
+
+/** Returns the current upload conditions after making determinations about the network connection.
+ *
+ * @return The current upload conditions.
+ */
+- (GDTCORUploadConditions)uploadConditions {
+  GDTCORNetworkReachabilityFlags currentFlags = [GDTCORReachability currentFlags];
+  BOOL networkConnected = GDTCORReachabilityFlagsReachable(currentFlags);
+  if (!networkConnected) {
+    return GDTCORUploadConditionNoNetwork;
+  }
+  BOOL isWWAN = GDTCORReachabilityFlagsContainWWAN(currentFlags);
+  if (isWWAN) {
+    return GDTCORUploadConditionMobileData;
+  } else {
+    return GDTCORUploadConditionWifiData;
+  }
+}
+
+#pragma mark - GDTCORLifecycleProtocol
+
+- (void)appWillForeground:(GDTCORApplication *)app {
+  // -startTimer is thread-safe.
+  [self startTimer];
+  [self signalToStoragesToCheckExpirations];
+}
+
+- (void)appWillBackground:(GDTCORApplication *)app {
+  dispatch_async(_coordinationQueue, ^{
+    [self stopTimer];
+  });
+}
+
+- (void)appWillTerminate:(GDTCORApplication *)application {
+  dispatch_sync(_coordinationQueue, ^{
+    [self stopTimer];
+  });
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/Internal/GDTCORAssert.h

@@ -0,0 +1,95 @@
+/*
+ * 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 "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** A block type that could be run instead of normal assertion logging. No return type, no params.
+ */
+typedef void (^GDTCORAssertionBlock)(void);
+
+/** Returns the result of executing a soft-linked method present in unit tests that allows a block
+ * to be run instead of normal assertion logging. This helps ameliorate issues with catching
+ * exceptions that occur on a dispatch_queue.
+ *
+ * @return A block that can be run instead of normal assert printing.
+ */
+FOUNDATION_EXPORT GDTCORAssertionBlock _Nullable GDTCORAssertionBlockToRunInstead(void);
+
+#if defined(NS_BLOCK_ASSERTIONS)
+
+#define GDTCORAssert(condition, ...) \
+  do {                               \
+  } while (0);
+
+#define GDTCORFatalAssert(condition, ...) \
+  do {                                    \
+  } while (0);
+
+#else  // defined(NS_BLOCK_ASSERTIONS)
+
+/** Asserts using a console log, unless a block was specified to be run instead.
+ *
+ * @param condition The condition you'd expect to be YES.
+ */
+#define GDTCORAssert(condition, format, ...)                                     \
+  do {                                                                           \
+    __PRAGMA_PUSH_NO_EXTRA_ARG_WARNINGS                                          \
+    if (__builtin_expect(!(condition), 0)) {                                     \
+      GDTCORAssertionBlock assertionBlock = GDTCORAssertionBlockToRunInstead();  \
+      if (assertionBlock) {                                                      \
+        assertionBlock();                                                        \
+      } else {                                                                   \
+        NSString *__assert_file__ = [NSString stringWithUTF8String:__FILE__];    \
+        __assert_file__ = __assert_file__ ? __assert_file__ : @"<Unknown File>"; \
+        GDTCORLogAssert(NO, __assert_file__, __LINE__, format, ##__VA_ARGS__);   \
+        __PRAGMA_POP_NO_EXTRA_ARG_WARNINGS                                       \
+      }                                                                          \
+    }                                                                            \
+  } while (0);
+
+/** Asserts by logging to the console and throwing an exception if NS_BLOCK_ASSERTIONS is not
+ * defined.
+ *
+ * @param condition The condition you'd expect to be YES.
+ */
+#define GDTCORFatalAssert(condition, format, ...)                                          \
+  do {                                                                                     \
+    __PRAGMA_PUSH_NO_EXTRA_ARG_WARNINGS                                                    \
+    if (__builtin_expect(!(condition), 0)) {                                               \
+      GDTCORAssertionBlock assertionBlock = GDTCORAssertionBlockToRunInstead();            \
+      if (assertionBlock) {                                                                \
+        assertionBlock();                                                                  \
+      } else {                                                                             \
+        NSString *__assert_file__ = [NSString stringWithUTF8String:__FILE__];              \
+        __assert_file__ = __assert_file__ ? __assert_file__ : @"<Unknown File>";           \
+        GDTCORLogAssert(YES, __assert_file__, __LINE__, format, ##__VA_ARGS__);            \
+        [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd                    \
+                                                            object:self                    \
+                                                              file:__assert_file__         \
+                                                        lineNumber:__LINE__                \
+                                                       description:format, ##__VA_ARGS__]; \
+        __PRAGMA_POP_NO_EXTRA_ARG_WARNINGS                                                 \
+      }                                                                                    \
+    }                                                                                      \
+  } while (0);
+
+#endif  // defined(NS_BLOCK_ASSERTIONS)
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/Internal/GDTCORDirectorySizeTracker.h

@@ -0,0 +1,66 @@
+/*
+ * 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 <Foundation/Foundation.h>
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORStorageProtocol.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The class calculates and caches the specified directory content size and uses add/remove signals
+ *  from client the client to keep the size up to date without accessing file system.
+ *  This is an internal class designed to be used by `GDTCORFlatFileStorage`.
+ *  NOTE: The class is not thread-safe. The client must take care of synchronization.
+ */
+@interface GDTCORDirectorySizeTracker : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/** Initializes the object with a directory path.
+ * @param path The directory path to track content size.
+ */
+- (instancetype)initWithDirectoryPath:(NSString *)path;
+
+/** Returns a cached or calculates (if there is no cached) directory content size.
+ * @return The directory content size in bytes calculated based on `NSURLFileSizeKey`.
+ */
+- (GDTCORStorageSizeBytes)directoryContentSize;
+
+/** The client must call this method or `resetCachedSize` method each time a file or directory is
+ * added to the tracked directory.
+ *  @param path The path to the added file. If the path is outside the tracked directory then the
+ *  @param fileSize The size of the added file.
+ * method is no-op.
+ */
+- (void)fileWasAddedAtPath:(NSString *)path withSize:(GDTCORStorageSizeBytes)fileSize;
+
+/** The client must call this method or `resetCachedSize` method each time a file or directory is
+ * removed from the tracked directory.
+ *  @param path The path to the removed file. If the path is outside the tracked directory then the
+ *  @param fileSize The size of the removed file.
+ * method is no-op.
+ */
+- (void)fileWasRemovedAtPath:(NSString *)path withSize:(GDTCORStorageSizeBytes)fileSize;
+
+/** Invalidates cached directory size. */
+- (void)resetCachedSize;
+
+/** Returns URL resource value for `NSURLFileSizeKey` key for the specified URL. */
+- (GDTCORStorageSizeBytes)fileSizeAtURL:(NSURL *)fileURL;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/Internal/GDTCORLifecycle.h

@@ -0,0 +1,63 @@
+/*
+ * 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 "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h"
+
+@class GDTCOREvent;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** A protocol defining the lifecycle events objects in the library must respond to immediately. */
+@protocol GDTCORLifecycleProtocol <NSObject>
+
+@optional
+
+/** Indicates an imminent app termination in the rare occurrence when -applicationWillTerminate: has
+ * been called.
+ *
+ * @param app The GDTCORApplication instance.
+ */
+- (void)appWillTerminate:(GDTCORApplication *)app;
+
+/** Indicates that the app is moving to background and eventual suspension or the current UIScene is
+ * deactivating.
+ *
+ * @param app The GDTCORApplication instance.
+ */
+- (void)appWillBackground:(GDTCORApplication *)app;
+
+/** Indicates that the app is resuming operation or a UIScene is activating.
+ *
+ * @param app The GDTCORApplication instance.
+ */
+- (void)appWillForeground:(GDTCORApplication *)app;
+
+@end
+
+/** This class manages the library's response to app lifecycle events.
+ *
+ * When backgrounding, the library doesn't stop processing events, it's just that several background
+ * tasks will end up being created for every event that's sent, and the stateful objects of the
+ * library (GDTCORStorage and GDTCORUploadCoordinator instances) will deserialize themselves from
+ * and to disk before and after every operation, respectively.
+ */
+@interface GDTCORLifecycle : NSObject <GDTCORApplicationDelegate>
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h

@@ -0,0 +1,225 @@
+/*
+ * 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>
+
+#if !TARGET_OS_WATCH
+#import <SystemConfiguration/SystemConfiguration.h>
+#endif
+
+#if TARGET_OS_IOS || TARGET_OS_TV
+#import <UIKit/UIKit.h>
+#elif TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#elif TARGET_OS_WATCH
+#import <WatchKit/WatchKit.h>
+#endif  // TARGET_OS_IOS || TARGET_OS_TV
+
+#if TARGET_OS_IOS
+#import <CoreTelephony/CTTelephonyNetworkInfo.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The GoogleDataTransport library version. */
+FOUNDATION_EXPORT NSString *const kGDTCORVersion;
+
+/** A notification sent out if the app is backgrounding. */
+FOUNDATION_EXPORT NSString *const kGDTCORApplicationDidEnterBackgroundNotification;
+
+/** A notification sent out if the app is foregrounding. */
+FOUNDATION_EXPORT NSString *const kGDTCORApplicationWillEnterForegroundNotification;
+
+/** A notification sent out if the app is terminating. */
+FOUNDATION_EXPORT NSString *const kGDTCORApplicationWillTerminateNotification;
+
+/** The different possible network connection type. */
+typedef NS_ENUM(NSInteger, GDTCORNetworkType) {
+  GDTCORNetworkTypeUNKNOWN = 0,
+  GDTCORNetworkTypeWIFI = 1,
+  GDTCORNetworkTypeMobile = 2,
+};
+
+/** The different possible network connection mobile subtype. */
+typedef NS_ENUM(NSInteger, GDTCORNetworkMobileSubtype) {
+  GDTCORNetworkMobileSubtypeUNKNOWN = 0,
+  GDTCORNetworkMobileSubtypeGPRS = 1,
+  GDTCORNetworkMobileSubtypeEdge = 2,
+  GDTCORNetworkMobileSubtypeWCDMA = 3,
+  GDTCORNetworkMobileSubtypeHSDPA = 4,
+  GDTCORNetworkMobileSubtypeHSUPA = 5,
+  GDTCORNetworkMobileSubtypeCDMA1x = 6,
+  GDTCORNetworkMobileSubtypeCDMAEVDORev0 = 7,
+  GDTCORNetworkMobileSubtypeCDMAEVDORevA = 8,
+  GDTCORNetworkMobileSubtypeCDMAEVDORevB = 9,
+  GDTCORNetworkMobileSubtypeHRPD = 10,
+  GDTCORNetworkMobileSubtypeLTE = 11,
+};
+
+#if !TARGET_OS_WATCH
+/** Define SCNetworkReachabilityFlags as GDTCORNetworkReachabilityFlags on non-watchOS. */
+typedef SCNetworkReachabilityFlags GDTCORNetworkReachabilityFlags;
+
+/** Define SCNetworkReachabilityRef as GDTCORNetworkReachabilityRef on non-watchOS. */
+typedef SCNetworkReachabilityRef GDTCORNetworkReachabilityRef;
+
+#else
+/** The different possible reachabilityFlags option on watchOS. */
+typedef NS_OPTIONS(uint32_t, GDTCORNetworkReachabilityFlags) {
+  kGDTCORNetworkReachabilityFlagsReachable = 1 << 1,
+  // TODO(doudounan): Add more options on watchOS if watchOS network connection information relative
+  // APIs available in the future.
+};
+
+/** Define a struct as GDTCORNetworkReachabilityRef on watchOS to store network connection
+ * information. */
+typedef struct {
+  // TODO(doudounan): Store network connection information on watchOS if watchOS network connection
+  // information relative APIs available in the future.
+} GDTCORNetworkReachabilityRef;
+#endif
+
+/** Returns a URL to the root directory under which all GDT-associated data must be saved.
+ *
+ * @return A URL to the root directory under which all GDT-associated data must be saved.
+ */
+NSURL *GDTCORRootDirectory(void);
+
+/** Compares flags with the reachable flag (on non-watchos with both reachable and
+ * connectionRequired flags), if available, and returns YES if network reachable.
+ *
+ * @param flags The set of reachability flags.
+ * @return YES if the network is reachable, NO otherwise.
+ */
+BOOL GDTCORReachabilityFlagsReachable(GDTCORNetworkReachabilityFlags flags);
+
+/** Compares flags with the WWAN reachability flag, if available, and returns YES if present.
+ *
+ * @param flags The set of reachability flags.
+ * @return YES if the WWAN flag is set, NO otherwise.
+ */
+BOOL GDTCORReachabilityFlagsContainWWAN(GDTCORNetworkReachabilityFlags flags);
+
+/** Generates an enum message GDTCORNetworkType representing network connection type.
+ *
+ * @return A GDTCORNetworkType representing network connection type.
+ */
+GDTCORNetworkType GDTCORNetworkTypeMessage(void);
+
+/** Generates an enum message GDTCORNetworkMobileSubtype representing network connection mobile
+ * subtype.
+ *
+ * @return A GDTCORNetworkMobileSubtype representing network connection mobile subtype.
+ */
+GDTCORNetworkMobileSubtype GDTCORNetworkMobileSubTypeMessage(void);
+
+/** Identifies the model of the device on which the library is currently working on.
+ *
+ * @return A NSString representing the device model.
+ */
+NSString *_Nonnull GDTCORDeviceModel(void);
+
+/** Writes the given object to the given fileURL and populates the given error if it fails.
+ *
+ * @param obj The object to encode.
+ * @param filePath The path to write the object to. Can be nil if you just need the data.
+ * @param error The error to populate if something goes wrong.
+ * @return The data of the archive. If error is nil, it's been written to disk.
+ */
+NSData *_Nullable GDTCOREncodeArchive(id<NSSecureCoding> obj,
+                                      NSString *_Nullable filePath,
+                                      NSError *_Nullable *error);
+
+/** Decodes an object of the given class from the given archive path or data and populates the given
+ * error if it fails.
+ *
+ * @param archiveClass The class of the archive's root object.
+ * @param archivePath The path to the archived data. Don't use with the archiveData param.
+ * @param archiveData The data to decode. Don't use with the archivePath param.
+ * @param error The error to populate if something goes wrong.
+ */
+id<NSSecureCoding> _Nullable GDTCORDecodeArchive(Class archiveClass,
+                                                 NSString *_Nullable archivePath,
+                                                 NSData *_Nullable archiveData,
+                                                 NSError *_Nullable *error);
+
+/** Writes the provided data to a file at the provided  path. Intermediate directories will be
+ * created as needed.
+ *  @param data The file content.
+ *  @param filePath The path to the file to write the provided data.
+ *  @param outError The error to populate if something goes wrong.
+ *  @return `YES` in the case of success, `NO` otherwise.
+ */
+BOOL GDTCORWriteDataToFile(NSData *data, NSString *filePath, NSError *_Nullable *outError);
+
+/** A typedef identify background identifiers. */
+typedef volatile NSUInteger GDTCORBackgroundIdentifier;
+
+/** A background task's invalid sentinel value. */
+FOUNDATION_EXPORT const GDTCORBackgroundIdentifier GDTCORBackgroundIdentifierInvalid;
+
+#if TARGET_OS_IOS || TARGET_OS_TV
+/** A protocol that wraps UIApplicationDelegate, WKExtensionDelegate or NSObject protocol, depending
+ * on the platform.
+ */
+@protocol GDTCORApplicationDelegate <UIApplicationDelegate>
+#elif TARGET_OS_OSX
+@protocol GDTCORApplicationDelegate <NSApplicationDelegate>
+#elif TARGET_OS_WATCH
+@protocol GDTCORApplicationDelegate <WKExtensionDelegate>
+#else
+@protocol GDTCORApplicationDelegate <NSObject>
+#endif  // TARGET_OS_IOS || TARGET_OS_TV
+
+@end
+
+@protocol GDTCORApplicationProtocol <NSObject>
+
+@required
+
+/** Flag to determine if the application is running in the background. */
+@property(atomic, readonly) BOOL isRunningInBackground;
+
+/** Creates a background task with the returned identifier if on a suitable platform.
+ *
+ * @name name The name of the task, useful for debugging which background tasks are running.
+ * @param handler The handler block that is called if the background task expires.
+ * @return An identifier for the background task, or GDTCORBackgroundIdentifierInvalid if one
+ * couldn't be created.
+ */
+- (GDTCORBackgroundIdentifier)beginBackgroundTaskWithName:(NSString *)name
+                                        expirationHandler:(void (^__nullable)(void))handler;
+
+/** Ends the background task if the identifier is valid.
+ *
+ * @param bgID The background task to end.
+ */
+- (void)endBackgroundTask:(GDTCORBackgroundIdentifier)bgID;
+
+@end
+
+/** A cross-platform application class. */
+@interface GDTCORApplication : NSObject <GDTCORApplicationProtocol, GDTCORApplicationDelegate>
+
+/** Creates and/or returns the shared application instance.
+ *
+ * @return The shared application instance.
+ */
++ (nullable GDTCORApplication *)sharedApplication;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/Internal/GDTCORReachability.h

@@ -0,0 +1,31 @@
+/*
+ * 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 "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** This class helps determine upload conditions by determining connectivity. */
+@interface GDTCORReachability : NSObject
+
+/** The current set flags indicating network conditions */
++ (GDTCORNetworkReachabilityFlags)currentFlags;
+
+@end
+
+NS_ASSUME_NONNULL_END