cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCCTLibrary/GDTCCTUploader.m

@@ -0,0 +1,210 @@
+/*
+ * 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/GDTCCTLibrary/Private/GDTCCTUploader.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORPlatform.h"
+#import "GoogleDataTransport/GDTCORLibrary/Internal/GDTCORRegistrar.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREndpoints.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREvent.h"
+
+#import "GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTUploadOperation.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GDTCCTUploader () <NSURLSessionDelegate, GDTCCTUploadMetadataProvider>
+
+@property(nonatomic, readonly) NSOperationQueue *uploadOperationQueue;
+@property(nonatomic, readonly) dispatch_queue_t uploadQueue;
+
+@property(nonatomic, readonly)
+    NSMutableDictionary<NSNumber * /*GDTCORTarget*/, GDTCORClock *> *nextUploadTimeByTarget;
+
+@end
+
+@implementation GDTCCTUploader
+
+static NSURL *_testServerURL = nil;
+
++ (void)load {
+  GDTCCTUploader *uploader = [GDTCCTUploader sharedInstance];
+  [[GDTCORRegistrar sharedInstance] registerUploader:uploader target:kGDTCORTargetCCT];
+  [[GDTCORRegistrar sharedInstance] registerUploader:uploader target:kGDTCORTargetFLL];
+  [[GDTCORRegistrar sharedInstance] registerUploader:uploader target:kGDTCORTargetCSH];
+  [[GDTCORRegistrar sharedInstance] registerUploader:uploader target:kGDTCORTargetINT];
+}
+
++ (instancetype)sharedInstance {
+  static GDTCCTUploader *sharedInstance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[GDTCCTUploader alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _uploadQueue = dispatch_queue_create("com.google.GDTCCTUploader", DISPATCH_QUEUE_SERIAL);
+    _uploadOperationQueue = [[NSOperationQueue alloc] init];
+    _uploadOperationQueue.maxConcurrentOperationCount = 1;
+    _nextUploadTimeByTarget = [[NSMutableDictionary alloc] init];
+  }
+  return self;
+}
+
+- (void)uploadTarget:(GDTCORTarget)target withConditions:(GDTCORUploadConditions)conditions {
+  // Current GDTCCTUploader expected behaviour:
+  // 1. Accept multiple upload request
+  // 2. Verify if there are events eligible for upload and start upload for the first suitable
+  // target
+  // 3. Ignore other requests while an upload is in-progress.
+
+  // TODO: Revisit expected behaviour.
+  // Potentially better option:
+  // 1. Accept and enqueue all upload requests
+  // 2. Notify the client of upload stages
+  // 3. Allow the client cancelling upload requests as needed.
+
+  id<GDTCORStoragePromiseProtocol> storage = GDTCORStoragePromiseInstanceForTarget(target);
+  if (storage == nil) {
+    GDTCORLogError(GDTCORMCEGeneralError,
+                   @"Failed to upload target: %ld - could not find corresponding storage instance.",
+                   (long)target);
+    return;
+  }
+
+  GDTCCTUploadOperation *uploadOperation =
+      [[GDTCCTUploadOperation alloc] initWithTarget:target
+                                         conditions:conditions
+                                          uploadURL:[[self class] serverURLForTarget:target]
+                                              queue:self.uploadQueue
+                                            storage:storage
+                                   metadataProvider:self];
+
+  GDTCORLogDebug(@"Upload operation created: %@, target: %@", uploadOperation, @(target));
+
+  __weak __auto_type weakSelf = self;
+  __weak GDTCCTUploadOperation *weakOperation = uploadOperation;
+  uploadOperation.completionBlock = ^{
+    __auto_type strongSelf = weakSelf;
+    GDTCCTUploadOperation *strongOperation = weakOperation;
+    if (strongSelf == nil || strongOperation == nil) {
+      GDTCORLogDebug(@"Internal inconsistency: GDTCCTUploader was deallocated during upload.", nil);
+      return;
+    }
+
+    GDTCORLogDebug(@"Upload operation finished: %@, uploadAttempted: %@", strongOperation,
+                   @(strongOperation.uploadAttempted));
+
+    if (strongOperation.uploadAttempted) {
+      // Ignore all upload requests received when the upload was in progress.
+      [strongSelf.uploadOperationQueue cancelAllOperations];
+    }
+  };
+
+  [self.uploadOperationQueue addOperation:uploadOperation];
+  GDTCORLogDebug(@"Upload operation scheduled: %@, operation count: %@", uploadOperation,
+                 @(self.uploadOperationQueue.operationCount));
+}
+
+#pragma mark - URLs
+
++ (void)setTestServerURL:(NSURL *_Nullable)serverURL {
+  _testServerURL = serverURL;
+}
+
++ (NSURL *_Nullable)testServerURL {
+  return _testServerURL;
+}
+
++ (nullable NSURL *)serverURLForTarget:(GDTCORTarget)target {
+#if !NDEBUG
+  if (_testServerURL) {
+    return _testServerURL;
+  }
+#endif  // !NDEBUG
+
+  return [GDTCOREndpoints uploadURLForTarget:target];
+}
+
+- (NSString *)FLLAndCSHAndINTAPIKey {
+  static NSString *defaultServerKey;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    // These strings should be interleaved to construct the real key.
+    const char *p1 = "AzSBG0honD6A-PxV5nBc";
+    const char *p2 = "Iay44Iwtu2vV0AOrz1C";
+    const char defaultKey[40] = {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], '\0'};
+    defaultServerKey = [NSString stringWithUTF8String:defaultKey];
+  });
+  return defaultServerKey;
+}
+
+#pragma mark - GDTCCTUploadMetadataProvider
+
+- (nullable GDTCORClock *)nextUploadTimeForTarget:(GDTCORTarget)target {
+  @synchronized(self.nextUploadTimeByTarget) {
+    return self.nextUploadTimeByTarget[@(target)];
+  }
+}
+
+- (void)setNextUploadTime:(nullable GDTCORClock *)time forTarget:(GDTCORTarget)target {
+  @synchronized(self.nextUploadTimeByTarget) {
+    self.nextUploadTimeByTarget[@(target)] = time;
+  }
+}
+
+- (nullable NSString *)APIKeyForTarget:(GDTCORTarget)target {
+  if (target == kGDTCORTargetFLL || target == kGDTCORTargetCSH) {
+    return [self FLLAndCSHAndINTAPIKey];
+  }
+
+  if (target == kGDTCORTargetINT) {
+    return [self FLLAndCSHAndINTAPIKey];
+  }
+
+  return nil;
+}
+
+#if !NDEBUG
+
+- (BOOL)waitForUploadFinishedWithTimeout:(NSTimeInterval)timeout {
+  NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:timeout];
+  while ([expirationDate compare:[NSDate date]] == NSOrderedDescending) {
+    if (self.uploadOperationQueue.operationCount == 0) {
+      return YES;
+    } else {
+      [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
+    }
+  }
+
+  GDTCORLogDebug(@"Uploader wait for finish timeout exceeded. Operations still in queue: %@",
+                 self.uploadOperationQueue.operations);
+  return NO;
+}
+
+#endif  // !NDEBUG
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCCTLibrary/GDTCOREvent+GDTCCTSupport.m

@@ -0,0 +1,240 @@
+/*
+ * 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/GDTCCTLibrary/Public/GDTCOREvent+GDTCCTSupport.h"
+
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCORConsoleLogger.h"
+
+NSString *const GDTCCTNeedsNetworkConnectionInfo = @"needs_network_connection_info";
+
+NSString *const GDTCCTNetworkConnectionInfo = @"network_connection_info";
+
+NSString *const GDTCCTEventCodeInfo = @"event_code_info";
+
+@implementation GDTCOREvent (GDTCCTSupport)
+
+- (void)setNeedsNetworkConnectionInfoPopulated:(BOOL)needsNetworkConnectionInfoPopulated {
+  if (!needsNetworkConnectionInfoPopulated) {
+    if (!self.customBytes) {
+      return;
+    }
+
+    // Make sure we don't destroy the eventCode data, if any is present.
+    @try {
+      NSError *error;
+      NSMutableDictionary *bytesDict =
+          [[NSJSONSerialization JSONObjectWithData:self.customBytes options:0
+                                             error:&error] mutableCopy];
+      if (error) {
+        GDTCORLogDebug(@"Error when setting an event's event_code: %@", error);
+        return;
+      }
+      NSNumber *eventCode = bytesDict[GDTCCTEventCodeInfo];
+      if (eventCode != nil) {
+        self.customBytes =
+            [NSJSONSerialization dataWithJSONObject:@{GDTCCTEventCodeInfo : eventCode}
+                                            options:0
+                                              error:&error];
+      }
+    } @catch (NSException *exception) {
+      GDTCORLogDebug(@"Error when setting the event for needs_network_connection_info: %@",
+                     exception);
+    }
+  } else {
+    @try {
+      NSError *error;
+      NSMutableDictionary *bytesDict;
+      if (self.customBytes) {
+        bytesDict = [[NSJSONSerialization JSONObjectWithData:self.customBytes
+                                                     options:0
+                                                       error:&error] mutableCopy];
+        if (error) {
+          GDTCORLogDebug(@"Error when setting an even'ts event_code: %@", error);
+          return;
+        }
+      } else {
+        bytesDict = [[NSMutableDictionary alloc] init];
+      }
+      [bytesDict setObject:@YES forKey:GDTCCTNeedsNetworkConnectionInfo];
+      self.customBytes = [NSJSONSerialization dataWithJSONObject:bytesDict options:0 error:&error];
+    } @catch (NSException *exception) {
+      GDTCORLogDebug(@"Error when setting the event for needs_network_connection_info: %@",
+                     exception);
+    }
+  }
+}
+
+- (BOOL)needsNetworkConnectionInfoPopulated {
+  if (self.customBytes) {
+    @try {
+      NSError *error;
+      NSDictionary *bytesDict = [NSJSONSerialization JSONObjectWithData:self.customBytes
+                                                                options:0
+                                                                  error:&error];
+      return bytesDict && !error && [bytesDict[GDTCCTNeedsNetworkConnectionInfo] boolValue];
+    } @catch (NSException *exception) {
+      GDTCORLogDebug(@"Error when checking the event for needs_network_connection_info: %@",
+                     exception);
+    }
+  }
+  return NO;
+}
+
+- (void)setNetworkConnectionInfoData:(NSData *)networkConnectionInfoData {
+  @try {
+    NSError *error;
+    NSString *dataString = [networkConnectionInfoData base64EncodedStringWithOptions:0];
+    if (dataString != nil) {
+      NSMutableDictionary *bytesDict;
+      if (self.customBytes) {
+        bytesDict = [[NSJSONSerialization JSONObjectWithData:self.customBytes
+                                                     options:0
+                                                       error:&error] mutableCopy];
+        if (error) {
+          GDTCORLogDebug(@"Error when setting an even'ts event_code: %@", error);
+          return;
+        }
+      } else {
+        bytesDict = [[NSMutableDictionary alloc] init];
+      }
+      [bytesDict setObject:dataString forKey:GDTCCTNetworkConnectionInfo];
+      self.customBytes = [NSJSONSerialization dataWithJSONObject:bytesDict options:0 error:&error];
+      if (error) {
+        self.customBytes = nil;
+        GDTCORLogDebug(@"Error when setting an event's network_connection_info: %@", error);
+      }
+    }
+  } @catch (NSException *exception) {
+    GDTCORLogDebug(@"Error when setting an event's network_connection_info: %@", exception);
+  }
+}
+
+- (nullable NSData *)networkConnectionInfoData {
+  if (self.customBytes) {
+    @try {
+      NSError *error;
+      NSDictionary *bytesDict = [NSJSONSerialization JSONObjectWithData:self.customBytes
+                                                                options:0
+                                                                  error:&error];
+      NSString *base64Data = bytesDict[GDTCCTNetworkConnectionInfo];
+      if (base64Data == nil) {
+        return nil;
+      }
+
+      NSData *networkConnectionInfoData = [[NSData alloc] initWithBase64EncodedString:base64Data
+                                                                              options:0];
+      if (error) {
+        GDTCORLogDebug(@"Error when getting an event's network_connection_info: %@", error);
+        return nil;
+      } else {
+        return networkConnectionInfoData;
+      }
+    } @catch (NSException *exception) {
+      GDTCORLogDebug(@"Error when getting an event's network_connection_info: %@", exception);
+    }
+  }
+  return nil;
+}
+
+- (NSNumber *)eventCode {
+  if (self.customBytes) {
+    @try {
+      NSError *error;
+      NSDictionary *bytesDict = [NSJSONSerialization JSONObjectWithData:self.customBytes
+                                                                options:0
+                                                                  error:&error];
+      NSString *eventCodeString = bytesDict[GDTCCTEventCodeInfo];
+
+      if (!eventCodeString) {
+        return nil;
+      }
+
+      NSNumberFormatter *formatter = [[NSNumberFormatter alloc] init];
+      formatter.numberStyle = NSNumberFormatterDecimalStyle;
+      NSNumber *eventCode = [formatter numberFromString:eventCodeString];
+
+      if (error) {
+        GDTCORLogDebug(@"Error when getting an event's network_connection_info: %@", error);
+        return nil;
+      } else {
+        return eventCode;
+      }
+    } @catch (NSException *exception) {
+      GDTCORLogDebug(@"Error when getting an event's event_code: %@", exception);
+    }
+  }
+  return nil;
+}
+
+- (void)setEventCode:(NSNumber *)eventCode {
+  if (eventCode == nil) {
+    if (!self.customBytes) {
+      return;
+    }
+
+    NSError *error;
+    NSMutableDictionary *bytesDict = [[NSJSONSerialization JSONObjectWithData:self.customBytes
+                                                                      options:0
+                                                                        error:&error] mutableCopy];
+    if (error) {
+      GDTCORLogDebug(@"Error when setting an event's event_code: %@", error);
+      return;
+    }
+
+    [bytesDict removeObjectForKey:GDTCCTEventCodeInfo];
+    self.customBytes = [NSJSONSerialization dataWithJSONObject:bytesDict options:0 error:&error];
+    if (error) {
+      self.customBytes = nil;
+      GDTCORLogDebug(@"Error when setting an event's event_code: %@", error);
+      return;
+    }
+    return;
+  }
+
+  @try {
+    NSMutableDictionary *bytesDict;
+    NSError *error;
+    if (self.customBytes) {
+      bytesDict = [[NSJSONSerialization JSONObjectWithData:self.customBytes options:0
+                                                     error:&error] mutableCopy];
+      if (error) {
+        GDTCORLogDebug(@"Error when setting an event's event_code: %@", error);
+        return;
+      }
+    } else {
+      bytesDict = [[NSMutableDictionary alloc] init];
+    }
+
+    NSString *eventCodeString = [eventCode stringValue];
+    if (eventCodeString == nil) {
+      return;
+    }
+
+    [bytesDict setObject:eventCodeString forKey:GDTCCTEventCodeInfo];
+
+    self.customBytes = [NSJSONSerialization dataWithJSONObject:bytesDict options:0 error:&error];
+    if (error) {
+      self.customBytes = nil;
+      GDTCORLogDebug(@"Error when setting an event's network_connection_info: %@", error);
+      return;
+    }
+
+  } @catch (NSException *exception) {
+    GDTCORLogDebug(@"Error when getting an event's network_connection_info: %@", exception);
+  }
+}
+
+@end

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTCompressionHelper.h

@@ -0,0 +1,40 @@
+/*
+ * 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>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** A class with methods to help with gzipped data. */
+@interface GDTCCTCompressionHelper : NSObject
+
+/** Compresses the given data and returns a new data object.
+ *
+ * @note Reduced version from GULNSData+zlib.m of GoogleUtilities.
+ * @return Compressed data, or nil if there was an error.
+ */
++ (nullable NSData *)gzippedData:(NSData *)data;
+
+/** Returns YES if the data looks like it was gzip compressed by checking for the gzip magic number.
+ *
+ * @note: From https://en.wikipedia.org/wiki/Gzip, gzip's magic number is 1f 8b.
+ * @return YES if the data appears gzipped, NO otherwise.
+ */
++ (BOOL)isGzipped:(NSData *)data;
+
+@end
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTNanopbHelpers.h

@@ -0,0 +1,128 @@
+/*
+ * 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/GDTCORReachability.h"
+#import "GoogleDataTransport/GDTCORLibrary/Public/GoogleDataTransport/GDTCOREvent.h"
+
+#import "GoogleDataTransport/GDTCCTLibrary/Protogen/nanopb/cct.nanopb.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+#pragma mark - General purpose encoders
+
+/** Converts an NSString* to a pb_bytes_array_t*.
+ *
+ * @note calloc is called in this method. Ensure that pb_release is called on this or the parent.
+ *
+ * @param string The string to convert.
+ * @return A newly allocated array of bytes representing the UTF8 encoding of the string.
+ */
+pb_bytes_array_t *GDTCCTEncodeString(NSString *string);
+
+/** Converts an NSData to a pb_bytes_array_t*.
+ *
+ * @note calloc is called in this method. Ensure that pb_release is called on this or the parent.
+ *
+ * @param data The data to convert.
+ * @return A newly allocated array of bytes with [data bytes] copied into it.
+ */
+pb_bytes_array_t *GDTCCTEncodeData(NSData *data);
+
+#pragma mark - CCT object constructors
+
+/** Encodes a batched log request.
+ *
+ * @note Ensure that pb_release is called on the batchedLogRequest param.
+ *
+ * @param batchedLogRequest A pointer to the log batch to encode to bytes.
+ * @return An NSData object representing the bytes of the log request batch.
+ */
+FOUNDATION_EXPORT
+NSData *GDTCCTEncodeBatchedLogRequest(gdt_cct_BatchedLogRequest *batchedLogRequest);
+
+/** Constructs a gdt_cct_BatchedLogRequest given sets of events segemented by mapping ID.
+ *
+ * @note calloc is called in this method. Ensure that pb_release is called on this or the parent.
+ *
+ * @param logMappingIDToLogSet A map of mapping IDs to sets of events to convert into a batch.
+ * @return A newly created gdt_cct_BatchedLogRequest.
+ */
+FOUNDATION_EXPORT
+gdt_cct_BatchedLogRequest GDTCCTConstructBatchedLogRequest(
+    NSDictionary<NSString *, NSSet<GDTCOREvent *> *> *logMappingIDToLogSet);
+
+/** Constructs a log request given a log source and a set of events.
+ *
+ * @note calloc is called in this method. Ensure that pb_release is called on this or the parent.
+ * @param logSource The CCT log source to put into the log request.
+ * @param logSet The set of events to send in this log request.
+ */
+FOUNDATION_EXPORT
+gdt_cct_LogRequest GDTCCTConstructLogRequest(int32_t logSource, NSSet<GDTCOREvent *> *logSet);
+
+/** Constructs a gdt_cct_LogEvent given a GDTCOREvent*.
+ *
+ * @param event The GDTCOREvent to convert.
+ * @return The new gdt_cct_LogEvent object.
+ */
+FOUNDATION_EXPORT
+gdt_cct_LogEvent GDTCCTConstructLogEvent(GDTCOREvent *event);
+
+/** Constructs a gdt_cct_ClientInfo representing the client device.
+ *
+ * @return The new gdt_cct_ClientInfo object.
+ */
+FOUNDATION_EXPORT
+gdt_cct_ClientInfo GDTCCTConstructClientInfo(void);
+
+/** Constructs a gdt_cct_IosClientInfo representing the client device.
+ *
+ * @return The new gdt_cct_IosClientInfo object.
+ */
+FOUNDATION_EXPORT
+gdt_cct_IosClientInfo GDTCCTConstructiOSClientInfo(void);
+
+/** Constructs the data of a gdt_cct_NetworkConnectionInfo representing the client nework connection
+ * information.
+ *
+ * @return The data of a gdt_cct_NetworkConnectionInfo object.
+ */
+FOUNDATION_EXPORT
+NSData *GDTCCTConstructNetworkConnectionInfoData(void);
+
+/** Return a gdt_cct_NetworkConnectionInfo_MobileSubtype representing the client
+ *
+ * @return The gdt_cct_NetworkConnectionInfo_MobileSubtype.
+ */
+FOUNDATION_EXPORT
+gdt_cct_NetworkConnectionInfo_MobileSubtype GDTCCTNetworkConnectionInfoNetworkMobileSubtype(void);
+
+#pragma mark - CCT object decoders
+
+/** Decodes a gdt_cct_LogResponse given proto bytes.
+ *
+ * @note calloc is called in this method. Ensure that pb_release is called on the return value.
+ *
+ * @param data The proto bytes of the gdt_cct_LogResponse.
+ * @param error An error that will be populated if something went wrong during decoding.
+ * @return A newly allocated gdt_cct_LogResponse from the data, if the bytes decoded properly.
+ */
+FOUNDATION_EXPORT
+gdt_cct_LogResponse GDTCCTDecodeLogResponse(NSData *data, NSError **error);
+
+NS_ASSUME_NONNULL_END

data/examples/AExample/Pods/GoogleDataTransport/GoogleDataTransport/GDTCCTLibrary/Private/GDTCCTUploadOperation.h

@@ -0,0 +1,76 @@
+/*
+ * 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/GDTCORUploader.h"
+
+@protocol GDTCORStoragePromiseProtocol;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The protocol defines methods to retrieve/update data shared between different upload operations.
+@protocol GDTCCTUploadMetadataProvider <NSObject>
+
+/** Returns a GDTCORClock object representing time after which a next upload attempt is allowed for
+ * the specified target. Upload is allowed now if `nil`. */
+- (nullable GDTCORClock *)nextUploadTimeForTarget:(GDTCORTarget)target;
+
+/** Stores or resets time after which  a next upload attempt is allowed for the specified target. */
+- (void)setNextUploadTime:(nullable GDTCORClock *)time forTarget:(GDTCORTarget)target;
+
+/** Returns an API key for the specified target. */
+- (nullable NSString *)APIKeyForTarget:(GDTCORTarget)target;
+
+@end
+
+/** Class capable of uploading events to the CCT backend. */
+@interface GDTCCTUploadOperation : NSOperation
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/** The designated initializer.
+ *  @param target The events target to upload.
+ *  @param conditions A set of upload conditions. The conditions affect the set of events to be
+ * uploaded, e.g. events with some QoS are not uploaded on a cellular network, etc.
+ *  @param uploadURL The backend URL to upload the events.
+ *  @param queue A queue to dispatch async upload steps.
+ *  @param storage A storage object to fetch events for upload.
+ *  @param metadataProvider An object to retrieve/update data shared between different upload
+ * operations.
+ *  @return An instance of GDTCCTUploadOperation ready to be added to an NSOperationQueue.
+ */
+- (instancetype)initWithTarget:(GDTCORTarget)target
+                    conditions:(GDTCORUploadConditions)conditions
+                     uploadURL:(NSURL *)uploadURL
+                         queue:(dispatch_queue_t)queue
+                       storage:(id<GDTCORStoragePromiseProtocol>)storage
+              metadataProvider:(id<GDTCCTUploadMetadataProvider>)metadataProvider
+    NS_DESIGNATED_INITIALIZER;
+
+/** YES if a batch upload attempt was performed. NO otherwise. If NO for the finished operation,
+ * then  there were no events suitable for upload. */
+@property(nonatomic, readonly) BOOL uploadAttempted;
+
+/** The queue on which all CCT uploading will occur. */
+@property(nonatomic, readonly) dispatch_queue_t uploaderQueue;
+
+/** The current upload task. */
+@property(nullable, nonatomic, readonly) NSURLSessionUploadTask *currentTask;
+
+@end
+
+NS_ASSUME_NONNULL_END