cocoapods-catalyst-validator 0.1.0.beta.1

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

@@ -0,0 +1,178 @@
+/*
+ * 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/Public/GoogleDataTransport/GDTCORClock.h"
+
+#import <sys/sysctl.h>
+
+// Using a monotonic clock is necessary because CFAbsoluteTimeGetCurrent(), NSDate, and related all
+// are subject to drift. That it to say, multiple consecutive calls do not always result in a
+// time that is in the future. Clocks may be adjusted by the user, NTP, or any number of external
+// factors. This class attempts to determine the wall-clock time at the time of the event by
+// capturing the kernel start and time since boot to determine a wallclock time in UTC.
+//
+// Timezone offsets at the time of a snapshot are also captured in order to provide local-time
+// details. Other classes in this library depend on comparing times at some time in the future to
+// a time captured in the past, and this class needs to provide a mechanism to do that.
+//
+// TL;DR: This class attempts to accomplish two things: 1. Provide accurate event times. 2. Provide
+// a monotonic clock mechanism to accurately check if some clock snapshot was before or after
+// by using a shared reference point (kernel boot time).
+//
+// Note: Much of the mach time stuff doesn't work properly in the simulator. So this class can be
+// difficult to unit test.
+
+/** Returns the kernel boottime property from sysctl.
+ *
+ * Inspired by https://stackoverflow.com/a/40497811
+ *
+ * @return The KERN_BOOTTIME property from sysctl, in nanoseconds.
+ */
+static int64_t KernelBootTimeInNanoseconds() {
+  // Caching the result is not possible because clock drift would not be accounted for.
+  struct timeval boottime;
+  int mib[2] = {CTL_KERN, KERN_BOOTTIME};
+  size_t size = sizeof(boottime);
+  int rc = sysctl(mib, 2, &boottime, &size, NULL, 0);
+  if (rc != 0) {
+    return 0;
+  }
+  return (int64_t)boottime.tv_sec * NSEC_PER_SEC + (int64_t)boottime.tv_usec * NSEC_PER_USEC;
+}
+
+/** Returns value of gettimeofday, in nanoseconds.
+ *
+ * Inspired by https://stackoverflow.com/a/40497811
+ *
+ * @return The value of gettimeofday, in nanoseconds.
+ */
+static int64_t UptimeInNanoseconds() {
+  int64_t before_now_nsec;
+  int64_t after_now_nsec;
+  struct timeval now;
+
+  before_now_nsec = KernelBootTimeInNanoseconds();
+  // Addresses a race condition in which the system time has updated, but the boottime has not.
+  do {
+    gettimeofday(&now, NULL);
+    after_now_nsec = KernelBootTimeInNanoseconds();
+  } while (after_now_nsec != before_now_nsec);
+  return (int64_t)now.tv_sec * NSEC_PER_SEC + (int64_t)now.tv_usec * NSEC_PER_USEC -
+         before_now_nsec;
+}
+
+// TODO: Consider adding a 'trustedTime' property that can be populated by the response from a BE.
+@implementation GDTCORClock
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _kernelBootTimeNanoseconds = KernelBootTimeInNanoseconds();
+    _uptimeNanoseconds = UptimeInNanoseconds();
+    _timeMillis =
+        (int64_t)((CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970) * NSEC_PER_USEC);
+    _timezoneOffsetSeconds = [[NSTimeZone systemTimeZone] secondsFromGMT];
+  }
+  return self;
+}
+
++ (GDTCORClock *)snapshot {
+  return [[GDTCORClock alloc] init];
+}
+
++ (instancetype)clockSnapshotInTheFuture:(uint64_t)millisInTheFuture {
+  GDTCORClock *snapshot = [self snapshot];
+  snapshot->_timeMillis += millisInTheFuture;
+  return snapshot;
+}
+
+- (BOOL)isAfter:(GDTCORClock *)otherClock {
+  // These clocks are trivially comparable when they share a kernel boot time.
+  if (_kernelBootTimeNanoseconds == otherClock->_kernelBootTimeNanoseconds) {
+    int64_t timeDiff = (_timeMillis + _timezoneOffsetSeconds) -
+                       (otherClock->_timeMillis + otherClock->_timezoneOffsetSeconds);
+    return timeDiff > 0;
+  } else {
+    int64_t kernelBootTimeDiff =
+        otherClock->_kernelBootTimeNanoseconds - _kernelBootTimeNanoseconds;
+    // This isn't a great solution, but essentially, if the other clock's boot time is 'later', NO
+    // is returned. This can be altered by changing the system time and rebooting.
+    return kernelBootTimeDiff < 0 ? YES : NO;
+  }
+}
+
+- (int64_t)uptimeMilliseconds {
+  return self.uptimeNanoseconds / NSEC_PER_MSEC;
+}
+
+- (NSUInteger)hash {
+  return [@(_kernelBootTimeNanoseconds) hash] ^ [@(_uptimeNanoseconds) hash] ^
+         [@(_timeMillis) hash] ^ [@(_timezoneOffsetSeconds) hash];
+}
+
+- (BOOL)isEqual:(id)object {
+  return [self hash] == [object hash];
+}
+
+#pragma mark - NSSecureCoding
+
+/** NSKeyedCoder key for timeMillis property. */
+static NSString *const kGDTCORClockTimeMillisKey = @"GDTCORClockTimeMillis";
+
+/** NSKeyedCoder key for timezoneOffsetMillis property. */
+static NSString *const kGDTCORClockTimezoneOffsetSeconds = @"GDTCORClockTimezoneOffsetSeconds";
+
+/** NSKeyedCoder key for _kernelBootTime ivar. */
+static NSString *const kGDTCORClockKernelBootTime = @"GDTCORClockKernelBootTime";
+
+/** NSKeyedCoder key for _uptimeNanoseconds ivar. */
+static NSString *const kGDTCORClockUptime = @"GDTCORClockUptime";
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  self = [super init];
+  if (self) {
+    // TODO: If the kernelBootTimeNanoseconds is more recent, we need to change the kernel boot time
+    // and uptimeMillis ivars
+    _timeMillis = [aDecoder decodeInt64ForKey:kGDTCORClockTimeMillisKey];
+    _timezoneOffsetSeconds = [aDecoder decodeInt64ForKey:kGDTCORClockTimezoneOffsetSeconds];
+    _kernelBootTimeNanoseconds = [aDecoder decodeInt64ForKey:kGDTCORClockKernelBootTime];
+    _uptimeNanoseconds = [aDecoder decodeInt64ForKey:kGDTCORClockUptime];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeInt64:_timeMillis forKey:kGDTCORClockTimeMillisKey];
+  [aCoder encodeInt64:_timezoneOffsetSeconds forKey:kGDTCORClockTimezoneOffsetSeconds];
+  [aCoder encodeInt64:_kernelBootTimeNanoseconds forKey:kGDTCORClockKernelBootTime];
+  [aCoder encodeInt64:_uptimeNanoseconds forKey:kGDTCORClockUptime];
+}
+
+#pragma mark - Deprecated properties
+
+- (int64_t)kernelBootTime {
+  return self.kernelBootTimeNanoseconds;
+}
+
+- (int64_t)uptime {
+  return self.uptimeNanoseconds;
+}
+
+@end

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

@@ -0,0 +1,55 @@
+/*
+ * 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/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+volatile NSInteger GDTCORConsoleLoggerLoggingLevel = GDTCORLoggingLevelErrors;
+
+/** The console logger prefix. */
+static NSString *kGDTCORConsoleLogger = @"[GoogleDataTransport]";
+
+NSString *GDTCORMessageCodeEnumToString(GDTCORMessageCode code) {
+  return [[NSString alloc] initWithFormat:@"I-GDTCOR%06ld", (long)code];
+}
+
+void GDTCORLog(GDTCORMessageCode code, GDTCORLoggingLevel logLevel, NSString *format, ...) {
+// Don't log anything in not debug builds.
+#if !NDEBUG
+  if (logLevel >= GDTCORConsoleLoggerLoggingLevel) {
+    NSString *logFormat = [NSString stringWithFormat:@"%@[%@] %@", kGDTCORConsoleLogger,
+                                                     GDTCORMessageCodeEnumToString(code), format];
+    va_list args;
+    va_start(args, format);
+    NSLogv(logFormat, args);
+    va_end(args);
+  }
+#endif  // !NDEBUG
+}
+
+void GDTCORLogAssert(
+    BOOL wasFatal, NSString *_Nonnull file, NSInteger line, NSString *_Nullable format, ...) {
+// Don't log anything in not debug builds.
+#if !NDEBUG
+  GDTCORMessageCode code = wasFatal ? GDTCORMCEFatalAssertion : GDTCORMCEGeneralError;
+  NSString *logFormat =
+      [NSString stringWithFormat:@"%@[%@] (%@:%ld) : %@", kGDTCORConsoleLogger,
+                                 GDTCORMessageCodeEnumToString(code), file, (long)line, format];
+  va_list args;
+  va_start(args, format);
+  NSLogv(logFormat, args);
+  va_end(args);
+#endif  // !NDEBUG
+}

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

@@ -0,0 +1,101 @@
+/*
+ * 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 "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORDirectorySizeTracker.h"
+
+@interface GDTCORDirectorySizeTracker ()
+
+/** The observed directory path. */
+@property(nonatomic, readonly) NSString *directoryPath;
+
+/** The cached content size of the observed directory. */
+@property(nonatomic, nullable) NSNumber *cachedSizeBytes;
+
+@end
+
+@implementation GDTCORDirectorySizeTracker
+
+- (instancetype)initWithDirectoryPath:(NSString *)path {
+  self = [super init];
+  if (self) {
+    _directoryPath = path;
+  }
+  return self;
+}
+
+- (GDTCORStorageSizeBytes)directoryContentSize {
+  if (self.cachedSizeBytes == nil) {
+    self.cachedSizeBytes = @([self calculateDirectoryContentSize]);
+  }
+
+  return self.cachedSizeBytes.unsignedLongLongValue;
+}
+
+- (void)fileWasAddedAtPath:(NSString *)path withSize:(GDTCORStorageSizeBytes)fileSize {
+  if (![path hasPrefix:self.directoryPath]) {
+    // Ignore because the file is not inside the directory.
+    return;
+  }
+
+  self.cachedSizeBytes = @([self directoryContentSize] + fileSize);
+}
+
+- (void)fileWasRemovedAtPath:(NSString *)path withSize:(GDTCORStorageSizeBytes)fileSize {
+  if (![path hasPrefix:self.directoryPath]) {
+    // Ignore because the file is not inside the directory.
+    return;
+  }
+
+  self.cachedSizeBytes = @([self directoryContentSize] - fileSize);
+}
+
+- (void)resetCachedSize {
+  self.cachedSizeBytes = nil;
+}
+
+- (GDTCORStorageSizeBytes)calculateDirectoryContentSize {
+  NSArray *prefetchedProperties = @[ NSURLIsRegularFileKey, NSURLFileSizeKey ];
+  uint64_t totalBytes = 0;
+  NSURL *directoryURL = [NSURL fileURLWithPath:self.directoryPath];
+
+  NSDirectoryEnumerator *enumerator = [[NSFileManager defaultManager]
+                 enumeratorAtURL:directoryURL
+      includingPropertiesForKeys:prefetchedProperties
+                         options:NSDirectoryEnumerationSkipsHiddenFiles
+                    errorHandler:^BOOL(NSURL *_Nonnull url, NSError *_Nonnull error) {
+                      return YES;
+                    }];
+
+  for (NSURL *fileURL in enumerator) {
+    @autoreleasepool {
+      NSNumber *isRegularFile;
+      [fileURL getResourceValue:&isRegularFile forKey:NSURLIsRegularFileKey error:nil];
+      if (isRegularFile.boolValue) {
+        totalBytes += [self fileSizeAtURL:fileURL];
+      }
+    }
+  }
+
+  return totalBytes;
+}
+
+- (GDTCORStorageSizeBytes)fileSizeAtURL:(NSURL *)fileURL {
+  NSNumber *fileSize;
+  [fileURL getResourceValue:&fileSize forKey:NSURLFileSizeKey error:nil];
+  return fileSize.unsignedLongLongValue;
+}
+
+@end

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

@@ -0,0 +1,92 @@
+/*
+ * 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 "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREndpoints.h"
+
+static NSString *const kINTServerURL =
+    @"https://dummyapiverylong-dummy.dummy.com/dummy/api/very/long";
+
+@implementation GDTCOREndpoints
+
++ (NSDictionary<NSNumber *, NSURL *> *)uploadURLs {
+  // These strings should be interleaved to construct the real URL. This is just to (hopefully)
+  // fool github URL scanning bots.
+  static NSURL *CCTServerURL;
+  static dispatch_once_t CCTOnceToken;
+  dispatch_once(&CCTOnceToken, ^{
+    const char *p1 = "hts/frbslgiggolai.o/0clgbth";
+    const char *p2 = "tp:/ieaeogn.ogepscmvc/o/ac";
+    const char URL[54] = {p1[0],  p2[0],  p1[1],  p2[1],  p1[2],  p2[2],  p1[3],  p2[3],  p1[4],
+                          p2[4],  p1[5],  p2[5],  p1[6],  p2[6],  p1[7],  p2[7],  p1[8],  p2[8],
+                          p1[9],  p2[9],  p1[10], p2[10], p1[11], p2[11], p1[12], p2[12], p1[13],
+                          p2[13], p1[14], p2[14], p1[15], p2[15], p1[16], p2[16], p1[17], p2[17],
+                          p1[18], p2[18], p1[19], p2[19], p1[20], p2[20], p1[21], p2[21], p1[22],
+                          p2[22], p1[23], p2[23], p1[24], p2[24], p1[25], p2[25], p1[26], '\0'};
+    CCTServerURL = [NSURL URLWithString:[NSString stringWithUTF8String:URL]];
+  });
+
+  static NSURL *FLLServerURL;
+  static dispatch_once_t FLLOnceToken;
+  dispatch_once(&FLLOnceToken, ^{
+    const char *p1 = "hts/frbslgigp.ogepscmv/ieo/eaybtho";
+    const char *p2 = "tp:/ieaeogn-agolai.o/1frlglgc/aclg";
+    const char URL[69] = {p1[0],  p2[0],  p1[1],  p2[1],  p1[2],  p2[2],  p1[3],  p2[3],  p1[4],
+                          p2[4],  p1[5],  p2[5],  p1[6],  p2[6],  p1[7],  p2[7],  p1[8],  p2[8],
+                          p1[9],  p2[9],  p1[10], p2[10], p1[11], p2[11], p1[12], p2[12], p1[13],
+                          p2[13], p1[14], p2[14], p1[15], p2[15], p1[16], p2[16], p1[17], p2[17],
+                          p1[18], p2[18], p1[19], p2[19], p1[20], p2[20], p1[21], p2[21], p1[22],
+                          p2[22], p1[23], p2[23], p1[24], p2[24], p1[25], p2[25], p1[26], p2[26],
+                          p1[27], p2[27], p1[28], p2[28], p1[29], p2[29], p1[30], p2[30], p1[31],
+                          p2[31], p1[32], p2[32], p1[33], p2[33], '\0'};
+    FLLServerURL = [NSURL URLWithString:[NSString stringWithUTF8String:URL]];
+  });
+
+  static NSURL *CSHServerURL;
+  static dispatch_once_t CSHOnceToken;
+  dispatch_once(&CSHOnceToken, ^{
+    // These strings should be interleaved to construct the real URL. This is just to (hopefully)
+    // fool github URL scanning bots.
+    const char *p1 = "hts/cahyiseot-agolai.o/1frlglgc/aclg";
+    const char *p2 = "tp:/rsltcrprsp.ogepscmv/ieo/eaybtho";
+    const char URL[72] = {p1[0],  p2[0],  p1[1],  p2[1],  p1[2],  p2[2],  p1[3],  p2[3],  p1[4],
+                          p2[4],  p1[5],  p2[5],  p1[6],  p2[6],  p1[7],  p2[7],  p1[8],  p2[8],
+                          p1[9],  p2[9],  p1[10], p2[10], p1[11], p2[11], p1[12], p2[12], p1[13],
+                          p2[13], p1[14], p2[14], p1[15], p2[15], p1[16], p2[16], p1[17], p2[17],
+                          p1[18], p2[18], p1[19], p2[19], p1[20], p2[20], p1[21], p2[21], p1[22],
+                          p2[22], p1[23], p2[23], p1[24], p2[24], p1[25], p2[25], p1[26], p2[26],
+                          p1[27], p2[27], p1[28], p2[28], p1[29], p2[29], p1[30], p2[30], p1[31],
+                          p2[31], p1[32], p2[32], p1[33], p2[33], p1[34], p2[34], p1[35], '\0'};
+    CSHServerURL = [NSURL URLWithString:[NSString stringWithUTF8String:URL]];
+  });
+  static NSDictionary<NSNumber *, NSURL *> *uploadURLs;
+  static dispatch_once_t URLOnceToken;
+  dispatch_once(&URLOnceToken, ^{
+    uploadURLs = @{
+      @(kGDTCORTargetCCT) : CCTServerURL,
+      @(kGDTCORTargetFLL) : FLLServerURL,
+      @(kGDTCORTargetCSH) : CSHServerURL,
+      @(kGDTCORTargetINT) : [NSURL URLWithString:kINTServerURL]
+    };
+  });
+  return uploadURLs;
+}
+
++ (nullable NSURL *)uploadURLForTarget:(GDTCORTarget)target {
+  NSDictionary<NSNumber *, NSURL *> *URLs = [self uploadURLs];
+  return [URLs objectForKey:@(target)];
+}
+
+@end

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

@@ -0,0 +1,153 @@
+/*
+ * 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/Public/GoogleDataTransport/GDTCOREvent.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORAssert.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORStorageProtocol.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORClock.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCOREvent_Private.h"
+
+@implementation GDTCOREvent
+
++ (NSString *)nextEventID {
+  // Replace special non-alphanumeric characters to avoid potential conflicts with storage logic.
+  return [[NSUUID UUID].UUIDString stringByReplacingOccurrencesOfString:@"-" withString:@""];
+}
+
+- (nullable instancetype)initWithMappingID:(NSString *)mappingID target:(GDTCORTarget)target {
+  GDTCORAssert(mappingID.length > 0, @"Please give a valid mapping ID");
+  GDTCORAssert(target > 0, @"A target cannot be negative or 0");
+  if (mappingID.length == 0 || target <= 0) {
+    return nil;
+  }
+  self = [super init];
+  if (self) {
+    _eventID = [GDTCOREvent nextEventID];
+    _mappingID = mappingID;
+    _target = target;
+    _qosTier = GDTCOREventQosDefault;
+    _expirationDate = [NSDate dateWithTimeIntervalSinceNow:604800];  // 7 days.
+
+    GDTCORLogDebug(@"Event %@ created. ID:%@ mappingID: %@ target:%ld", self, _eventID, mappingID,
+                   (long)target);
+  }
+
+  return self;
+}
+
+- (instancetype)copy {
+  GDTCOREvent *copy = [[GDTCOREvent alloc] initWithMappingID:_mappingID target:_target];
+  copy->_eventID = _eventID;
+  copy.dataObject = _dataObject;
+  copy.qosTier = _qosTier;
+  copy.clockSnapshot = _clockSnapshot;
+  copy.customBytes = _customBytes;
+  GDTCORLogDebug(@"Copying event %@ to event %@", self, copy);
+  return copy;
+}
+
+- (NSUInteger)hash {
+  // This loses some precision, but it's probably fine.
+  NSUInteger eventIDHash = [_eventID hash];
+  NSUInteger mappingIDHash = [_mappingID hash];
+  NSUInteger timeHash = [_clockSnapshot hash];
+  NSInteger serializedBytesHash = [_serializedDataObjectBytes hash];
+
+  return eventIDHash ^ mappingIDHash ^ _target ^ _qosTier ^ timeHash ^ serializedBytesHash;
+}
+
+- (BOOL)isEqual:(id)object {
+  return [self hash] == [object hash];
+}
+
+#pragma mark - Property overrides
+
+- (void)setDataObject:(id<GDTCOREventDataObject>)dataObject {
+  // If you're looking here because of a performance issue in -transportBytes slowing the assignment
+  // of -dataObject, one way to address this is to add a queue to this class,
+  // dispatch_(barrier_ if concurrent)async here, and implement the getter with a dispatch_sync.
+  if (dataObject != _dataObject) {
+    _dataObject = dataObject;
+  }
+  self->_serializedDataObjectBytes = [dataObject transportBytes];
+}
+
+#pragma mark - NSSecureCoding and NSCoding Protocols
+
+/** NSCoding key for eventID property. */
+static NSString *kEventIDKey = @"GDTCOREventEventIDKey";
+
+/** NSCoding key for mappingID property. */
+static NSString *kMappingIDKey = @"GDTCOREventMappingIDKey";
+
+/** NSCoding key for target property. */
+static NSString *kTargetKey = @"GDTCOREventTargetKey";
+
+/** NSCoding key for qosTier property. */
+static NSString *kQoSTierKey = @"GDTCOREventQoSTierKey";
+
+/** NSCoding key for clockSnapshot property. */
+static NSString *kClockSnapshotKey = @"GDTCOREventClockSnapshotKey";
+
+/** NSCoding key for expirationDate property. */
+static NSString *kExpirationDateKey = @"GDTCOREventExpirationDateKey";
+
+/** NSCoding key for serializedDataObjectBytes property. */
+static NSString *kSerializedDataObjectBytes = @"GDTCOREventSerializedDataObjectBytesKey";
+
+/** NSCoding key for customData property. */
+static NSString *kCustomDataKey = @"GDTCOREventCustomDataKey";
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (id)initWithCoder:(NSCoder *)aDecoder {
+  self = [self init];
+  if (self) {
+    _mappingID = [aDecoder decodeObjectOfClass:[NSString class] forKey:kMappingIDKey];
+    _target = [aDecoder decodeIntegerForKey:kTargetKey];
+    _eventID = [aDecoder decodeObjectOfClass:[NSString class] forKey:kEventIDKey]
+                   ?: [GDTCOREvent nextEventID];
+    _qosTier = [aDecoder decodeIntegerForKey:kQoSTierKey];
+    _clockSnapshot = [aDecoder decodeObjectOfClass:[GDTCORClock class] forKey:kClockSnapshotKey];
+    _customBytes = [aDecoder decodeObjectOfClass:[NSData class] forKey:kCustomDataKey];
+    _expirationDate = [aDecoder decodeObjectOfClass:[NSDate class] forKey:kExpirationDateKey];
+    _serializedDataObjectBytes = [aDecoder decodeObjectOfClass:[NSData class]
+                                                        forKey:kSerializedDataObjectBytes];
+    if (!_serializedDataObjectBytes) {
+      return nil;
+    }
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeObject:_eventID forKey:kEventIDKey];
+  [aCoder encodeObject:_mappingID forKey:kMappingIDKey];
+  [aCoder encodeInteger:_target forKey:kTargetKey];
+  [aCoder encodeInteger:_qosTier forKey:kQoSTierKey];
+  [aCoder encodeObject:_clockSnapshot forKey:kClockSnapshotKey];
+  [aCoder encodeObject:_customBytes forKey:kCustomDataKey];
+  [aCoder encodeObject:_expirationDate forKey:kExpirationDateKey];
+  [aCoder encodeObject:self.serializedDataObjectBytes forKey:kSerializedDataObjectBytes];
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCORLibrary/GDTCORFlatFileStorage+Promises.m

@@ -0,0 +1,104 @@
+/*
+ * 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 "GoogleDataTransport/GDTCORLibrary/Private/GDTCORFlatFileStorage+Promises.h"
+
+#if __has_include(<FBLPromises/FBLPromises.h>)
+#import <FBLPromises/FBLPromises.h>
+#else
+#import "FBLPromises.h"
+#endif
+
+#import "GoogleDataTransport/GDTCORLibrary/Private/GDTCORUploadBatch.h"
+
+@implementation GDTCORFlatFileStorage (Promises)
+
+- (FBLPromise<NSSet<NSNumber *> *> *)batchIDsForTarget:(GDTCORTarget)target {
+  return [FBLPromise onQueue:self.storageQueue
+        wrapObjectCompletion:^(FBLPromiseObjectCompletion _Nonnull handler) {
+          [self batchIDsForTarget:target onComplete:handler];
+        }];
+}
+
+- (FBLPromise<NSNull *> *)removeBatchWithID:(NSNumber *)batchID deleteEvents:(BOOL)deleteEvents {
+  return [FBLPromise onQueue:self.storageQueue
+              wrapCompletion:^(FBLPromiseCompletion _Nonnull handler) {
+                [self removeBatchWithID:batchID deleteEvents:deleteEvents onComplete:handler];
+              }];
+}
+
+- (FBLPromise<NSNull *> *)removeBatchesWithIDs:(NSSet<NSNumber *> *)batchIDs
+                                  deleteEvents:(BOOL)deleteEvents {
+  NSMutableArray<FBLPromise *> *removeBatchPromises =
+      [NSMutableArray arrayWithCapacity:batchIDs.count];
+  for (NSNumber *batchID in batchIDs) {
+    [removeBatchPromises addObject:[self removeBatchWithID:batchID deleteEvents:deleteEvents]];
+  }
+
+  return [FBLPromise onQueue:self.storageQueue all:[removeBatchPromises copy]].thenOn(
+      self.storageQueue, ^id(id result) {
+        return [FBLPromise resolvedWith:[NSNull null]];
+      });
+}
+
+- (FBLPromise<NSNull *> *)removeAllBatchesForTarget:(GDTCORTarget)target
+                                       deleteEvents:(BOOL)deleteEvents {
+  return
+      [self batchIDsForTarget:target].thenOn(self.storageQueue, ^id(NSSet<NSNumber *> *batchIDs) {
+        if (batchIDs.count == 0) {
+          return [FBLPromise resolvedWith:[NSNull null]];
+        } else {
+          return [self removeBatchesWithIDs:batchIDs deleteEvents:NO];
+        }
+      });
+}
+
+- (FBLPromise<NSNumber *> *)hasEventsForTarget:(GDTCORTarget)target {
+  return [FBLPromise onQueue:self.storageQueue
+          wrapBoolCompletion:^(FBLPromiseBoolCompletion _Nonnull handler) {
+            [self hasEventsForTarget:target onComplete:handler];
+          }];
+}
+
+- (FBLPromise<GDTCORUploadBatch *> *)batchWithEventSelector:
+                                         (GDTCORStorageEventSelector *)eventSelector
+                                            batchExpiration:(NSDate *)expiration {
+  return [FBLPromise
+      onQueue:self.storageQueue
+        async:^(FBLPromiseFulfillBlock _Nonnull fulfill, FBLPromiseRejectBlock _Nonnull reject) {
+          [self batchWithEventSelector:eventSelector
+                       batchExpiration:expiration
+                            onComplete:^(NSNumber *_Nullable newBatchID,
+                                         NSSet<GDTCOREvent *> *_Nullable batchEvents) {
+                              if (newBatchID == nil || batchEvents == nil) {
+                                reject([self genericRejectedPromiseErrorWithReason:
+                                                 @"There are no events for the selector."]);
+                              } else {
+                                fulfill([[GDTCORUploadBatch alloc] initWithBatchID:newBatchID
+                                                                            events:batchEvents]);
+                              }
+                            }];
+        }];
+}
+
+// TODO: Move to a separate class/extension when needed in more places.
+- (NSError *)genericRejectedPromiseErrorWithReason:(NSString *)reason {
+  return [NSError errorWithDomain:@"GDTCORFlatFileStorage"
+                             code:-1
+                         userInfo:@{NSLocalizedFailureReasonErrorKey : reason}];
+}
+
+@end