Expand the upload package capabilities (#2976)

* Add -isEqual method to GDTEvent

* Expand the capabilities of the upload package

* Style

* More style

* Change API usage for GDTUploadCoordinator test

* Add a missing import

* Consolidate methods

* Style

Author: mikehaney24

GoogleDataTransport/GDTLibrary/GDTEvent.m

@@ -53,6 +53,10 @@ - (NSUInteger)hash {
   return mappingIDHash ^ _target ^ dataObjectTransportBytesHash ^ _qosTier ^ timeHash;
 }
 
+- (BOOL)isEqual:(id)object {
+  return [self hash] == [object hash];
+}
+
 - (void)setDataObject:(id<GDTEventDataObject>)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,

GoogleDataTransport/GDTLibrary/GDTUploadPackage.m

@@ -16,21 +16,36 @@
 
 #import <GoogleDataTransport/GDTUploadPackage.h>
 
+#import <GoogleDataTransport/GDTClock.h>
+
 #import "GDTLibrary/Private/GDTStorage_Private.h"
 #import "GDTLibrary/Private/GDTUploadPackage_Private.h"
 
-@implementation GDTUploadPackage
+@implementation GDTUploadPackage {
+  /** If YES, is being handled by the handler. */
+  BOOL _isHandled;
+
+  /** A timer that will regularly check to see whether this package has expired or not. */
+  NSTimer *_expirationTimer;
+}
 
-- (instancetype)init {
+- (instancetype)initWithTarget:(GDTTarget)target {
   self = [super init];
   if (self) {
+    _target = target;
     _storage = [GDTStorage sharedInstance];
+    _deliverByTime = [GDTClock clockSnapshotInTheFuture:180000];
+    _expirationTimer = [NSTimer scheduledTimerWithTimeInterval:5.0
+                                                        target:self
+                                                      selector:@selector(checkIfPackageIsExpired:)
+                                                      userInfo:nil
+                                                       repeats:YES];
   }
   return self;
 }
 
 - (instancetype)copy {
-  GDTUploadPackage *newPackage = [[GDTUploadPackage alloc] init];
+  GDTUploadPackage *newPackage = [[GDTUploadPackage alloc] initWithTarget:_target];
   newPackage->_events = [_events copy];
   return newPackage;
 }
@@ -43,10 +58,84 @@ - (BOOL)isEqual:(id)object {
   return [self hash] == [object hash];
 }
 
+- (void)dealloc {
+  [_expirationTimer invalidate];
+}
+
 - (void)setStorage:(GDTStorage *)storage {
   if (storage != _storage) {
     _storage = storage;
   }
 }
 
+- (void)completeDelivery {
+  if (!_isHandled && _handler &&
+      [_handler respondsToSelector:@selector(packageDelivered:successful:)]) {
+    [_expirationTimer invalidate];
+    _isHandled = YES;
+    [_handler packageDelivered:self successful:YES];
+  }
+}
+
+- (void)retryDeliveryInTheFuture {
+  if (!_isHandled && _handler &&
+      [_handler respondsToSelector:@selector(packageDelivered:successful:)]) {
+    [_expirationTimer invalidate];
+    _isHandled = YES;
+    [_handler packageDelivered:self successful:NO];
+  }
+}
+
+- (void)checkIfPackageIsExpired:(NSTimer *)timer {
+  if ([[GDTClock snapshot] isAfter:_deliverByTime]) {
+    if (_handler && [_handler respondsToSelector:@selector(packageExpired:)]) {
+      _isHandled = YES;
+      [_expirationTimer invalidate];
+      [_handler packageExpired:self];
+    }
+  }
+}
+
+#pragma mark - NSSecureCoding
+
+/** The keyed archiver key for the events property. */
+static NSString *const kEventsKey = @"GDTUploadPackageEventsKey";
+
+/** The keyed archiver key for the _isHandled property. */
+static NSString *const kDeliverByTimeKey = @"GDTUploadPackageDeliveryByTimeKey";
+
+/** The keyed archiver key for the _isHandled ivar. */
+static NSString *const kIsHandledKey = @"GDTUploadPackageIsHandledKey";
+
+/** The keyed archiver key for the handler property. */
+static NSString *const kHandlerKey = @"GDTUploadPackageHandlerKey";
+
+/** The keyed archiver key for the target property. */
+static NSString *const kTargetKey = @"GDTUploadPackageTargetKey";
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (void)encodeWithCoder:(nonnull NSCoder *)aCoder {
+  [aCoder encodeObject:_events forKey:kEventsKey];
+  [aCoder encodeObject:_deliverByTime forKey:kDeliverByTimeKey];
+  [aCoder encodeBool:_isHandled forKey:kIsHandledKey];
+  [aCoder encodeObject:_handler forKey:kHandlerKey];
+  [aCoder encodeInteger:_target forKey:kTargetKey];
+}
+
+- (nullable instancetype)initWithCoder:(nonnull NSCoder *)aDecoder {
+  GDTTarget target = [aDecoder decodeIntegerForKey:kTargetKey];
+  self = [self initWithTarget:target];
+  if (self) {
+    _events = [aDecoder decodeObjectOfClass:[NSSet class] forKey:kEventsKey];
+    _deliverByTime = [aDecoder decodeObjectOfClass:[GDTClock class] forKey:kDeliverByTimeKey];
+    _isHandled = [aDecoder decodeBoolForKey:kIsHandledKey];
+    // Isn't technically NSSecureCoding, because we don't know the class of this object.
+    _handler = [aDecoder decodeObjectForKey:kHandlerKey];
+  }
+  return self;
+}
+
 @end

GoogleDataTransport/GDTLibrary/Private/GDTUploadPackage_Private.h

@@ -23,4 +23,7 @@
 /** The storage object this upload package will use to resolve event hashes to files. */
 @property(nonatomic) GDTStorage *storage;
 
+/** A handler that will receive callbacks for certain events. */
+@property(nonatomic) id<NSSecureCoding, GDTUploadPackageProtocol> handler;
+
 @end

GoogleDataTransport/GDTLibrary/Public/GDTUploadPackage.h

@@ -16,12 +16,65 @@
 
 #import <Foundation/Foundation.h>
 
+#import <GoogleDataTransport/GDTTargets.h>
+
+@class GDTClock;
 @class GDTStoredEvent;
+@class GDTUploadPackage;
+
+/** A protocol that allows a handler to respond to package lifecycle events. */
+@protocol GDTUploadPackageProtocol <NSObject>
+
+@optional
+
+/** Indicates that the package has expired.
+ *
+ * @note Package expiration will only be checked every 5 seconds.
+ *
+ * @param package The package that has expired.
+ */
+- (void)packageExpired:(GDTUploadPackage *)package;
+
+/** Indicates that the package was successfully delivered.
+ *
+ * @param package The package that was delivered.
+ */
+- (void)packageDelivered:(GDTUploadPackage *)package successful:(BOOL)successful;
+
+@end
 
 /** This class is a container that's handed off to uploaders. */
-@interface GDTUploadPackage : NSObject
+@interface GDTUploadPackage : NSObject <NSSecureCoding>
 
 /** The set of stored events in this upload package. */
 @property(nonatomic) NSSet<GDTStoredEvent *> *events;
 
+/** The expiration time. If [[GDTClock snapshot] isAfter:deliverByTime] this package has expired.
+ *
+ * @note By default, the expiration time will be 3 minutes from creation.
+ */
+@property(nonatomic) GDTClock *deliverByTime;
+
+/** The target of this package. */
+@property(nonatomic, readonly) GDTTarget target;
+
+/** Initializes a package instance.
+ *
+ * @param target The target/destination of this package.
+ * @return An instance of this class.
+ */
+- (instancetype)initWithTarget:(GDTTarget)target NS_DESIGNATED_INITIALIZER;
+
+// Please use the designated initializer.
+- (instancetype)init NS_UNAVAILABLE;
+
+/** Completes delivery of the package.
+ *
+ * @note This *needs* to be called by an uploader for the package to not expire.
+ */
+- (void)completeDelivery;
+
+/** Sends the package back, indicating that delivery should be attempted again in the future. */
+- (void)retryDeliveryInTheFuture;
+
 @end

GoogleDataTransport/GDTLibrary/Public/GDTUploader.h

@@ -19,8 +19,7 @@
 #import <GoogleDataTransport/GDTClock.h>
 #import <GoogleDataTransport/GDTLifecycle.h>
 #import <GoogleDataTransport/GDTTargets.h>
-
-@class GDTUploadPackage;
+#import <GoogleDataTransport/GDTUploadPackage.h>
 
 NS_ASSUME_NONNULL_BEGIN
 

GoogleDataTransport/GDTTests/Integration/Helpers/GDTIntegrationTestPrioritizer.m

@@ -69,7 +69,7 @@ - (void)unprioritizeEvents:(NSSet<GDTStoredEvent *> *)events {
 
 - (GDTUploadPackage *)uploadPackageWithConditions:(GDTUploadConditions)conditions {
   __block GDTIntegrationTestUploadPackage *uploadPackage =
-      [[GDTIntegrationTestUploadPackage alloc] init];
+      [[GDTIntegrationTestUploadPackage alloc] initWithTarget:kGDTIntegrationTestTarget];
   dispatch_sync(_queue, ^{
     if ((conditions & GDTUploadConditionWifiData) == GDTUploadConditionWifiData) {
       uploadPackage.events = [self.wifiOnlyEvents setByAddingObjectsFromSet:self.nonWifiEvents];

GoogleDataTransport/GDTTests/Lifecycle/Helpers/GDTLifecycleTestPrioritizer.m

@@ -55,7 +55,8 @@ - (void)unprioritizeEvents:(NSSet<GDTStoredEvent *> *)events {
 }
 
 - (GDTUploadPackage *)uploadPackageWithConditions:(GDTUploadConditions)conditions {
-  __block GDTUploadPackage *uploadPackage = [[GDTUploadPackage alloc] init];
+  __block GDTUploadPackage *uploadPackage =
+      [[GDTUploadPackage alloc] initWithTarget:kGDTTargetTest];
   dispatch_sync(_queue, ^{
     uploadPackage.events = self.events;
   });

GoogleDataTransport/GDTTests/Unit/GDTUploadCoordinatorTest.m

@@ -40,22 +40,18 @@ @interface GDTUploadCoordinatorTest : GDTTestCase
 /** A test uploader. */
 @property(nonatomic) GDTTestUploader *uploader;
 
-/** A target for the prioritizer and uploader to use. */
-@property(nonatomic) GDTTarget target;
-
 @end
 
 @implementation GDTUploadCoordinatorTest
 
 - (void)setUp {
   [super setUp];
   self.storageFake = [[GDTStorageFake alloc] init];
-  self.target = 42;
   self.prioritizer = [[GDTTestPrioritizer alloc] init];
   self.uploader = [[GDTTestUploader alloc] init];
 
-  [[GDTRegistrar sharedInstance] registerPrioritizer:_prioritizer target:_target];
-  [[GDTRegistrar sharedInstance] registerUploader:_uploader target:_target];
+  [[GDTRegistrar sharedInstance] registerPrioritizer:_prioritizer target:kGDTTargetTest];
+  [[GDTRegistrar sharedInstance] registerUploader:_uploader target:kGDTTargetTest];
 
   GDTUploadCoordinator *uploadCoordinator = [GDTUploadCoordinator sharedInstance];
   uploadCoordinator.storage = self.storageFake;
@@ -81,15 +77,16 @@ - (void)testSharedInstance {
 
 /** Tests that forcing a event upload works. */
 - (void)testForceUploadEvents {
-  GDTTestUploadPackage *uploadPackage = [[GDTTestUploadPackage alloc] init];
+  GDTTestUploadPackage *uploadPackage =
+      [[GDTTestUploadPackage alloc] initWithTarget:kGDTTargetTest];
   uploadPackage.events = [GDTEventGenerator generate3StoredEvents];
   self.prioritizer.uploadPackage = uploadPackage;
   XCTestExpectation *expectation = [self expectationWithDescription:@"uploader will upload"];
   self.uploader.uploadEventsBlock =
       ^(GDTUploadPackage *_Nonnull package, GDTUploaderCompletionBlock _Nonnull completionBlock) {
         [expectation fulfill];
       };
-  XCTAssertNoThrow([[GDTUploadCoordinator sharedInstance] forceUploadForTarget:_target]);
+  XCTAssertNoThrow([[GDTUploadCoordinator sharedInstance] forceUploadForTarget:kGDTTargetTest]);
   [self waitForExpectations:@[ expectation ] timeout:0.1];
 }
 
@@ -102,18 +99,19 @@ - (void)testForceUploadEventsEnqueuesIftargetAlreadyHasEventsInFlight {
       ^(GDTUploadPackage *_Nonnull package, GDTUploaderCompletionBlock _Nonnull completionBlock) {
         [expectation fulfill];
       };
-  GDTTestUploadPackage *uploadPackage = [[GDTTestUploadPackage alloc] init];
+  GDTTestUploadPackage *uploadPackage =
+      [[GDTTestUploadPackage alloc] initWithTarget:kGDTTargetTest];
   uploadPackage.events = [GDTEventGenerator generate3StoredEvents];
   self.prioritizer.uploadPackage = uploadPackage;
   dispatch_sync([GDTUploadCoordinator sharedInstance].coordinationQueue, ^{
-    [GDTUploadCoordinator sharedInstance].targetToInFlightEventSet[@(self->_target)] =
+    [GDTUploadCoordinator sharedInstance].targetToInFlightEventSet[@(kGDTTargetTest)] =
         [[NSSet alloc] init];
   });
-  XCTAssertNoThrow([[GDTUploadCoordinator sharedInstance] forceUploadForTarget:_target]);
+  XCTAssertNoThrow([[GDTUploadCoordinator sharedInstance] forceUploadForTarget:kGDTTargetTest]);
   dispatch_sync([GDTUploadCoordinator sharedInstance].coordinationQueue, ^{
     XCTAssertEqual([GDTUploadCoordinator sharedInstance].forcedUploadQueue.count, 1);
     [GDTUploadCoordinator sharedInstance].onCompleteBlock(
-        self.target, [GDTClock clockSnapshotInTheFuture:1000], nil);
+        kGDTTargetTest, [GDTClock clockSnapshotInTheFuture:1000], nil);
   });
   [self waitForExpectations:@[ expectation ] timeout:1.0];
 }
@@ -144,14 +142,13 @@ - (void)testTimerIsRunningAtDesiredFrequency {
 /** Tests uploading events via the coordinator timer. */
 - (void)testUploadingEventsViaTimer {
   __block int uploadAttempts = 0;
-  __weak GDTUploadCoordinatorTest *weakSelf = self;
-  GDTTestUploadPackage *uploadPackage = [[GDTTestUploadPackage alloc] init];
+  GDTTestUploadPackage *uploadPackage =
+      [[GDTTestUploadPackage alloc] initWithTarget:kGDTTargetTest];
   uploadPackage.events = [GDTEventGenerator generate3StoredEvents];
   self.prioritizer.uploadPackage = uploadPackage;
   self.uploader.uploadEventsBlock =
       ^(GDTUploadPackage *_Nonnull package, GDTUploaderCompletionBlock _Nonnull completionBlock) {
-        GDTUploadCoordinatorTest *strongSelf = weakSelf;
-        completionBlock(strongSelf->_target, [GDTClock clockSnapshotInTheFuture:100], nil);
+        completionBlock(kGDTTargetTest, [GDTClock clockSnapshotInTheFuture:100], nil);
         uploadAttempts++;
       };
   [GDTUploadCoordinator sharedInstance].timerInterval = NSEC_PER_SEC / 10;
@@ -169,15 +166,14 @@ - (void)testUploadingEventsViaTimer {
 /** Tests the situation in which the uploader failed to upload the events for some reason. */
 - (void)testThatAFailedUploadResultsInAnEventualRetry {
   __block int uploadAttempts = 0;
-  __weak GDTUploadCoordinatorTest *weakSelf = self;
-  GDTTestUploadPackage *uploadPackage = [[GDTTestUploadPackage alloc] init];
+  GDTTestUploadPackage *uploadPackage =
+      [[GDTTestUploadPackage alloc] initWithTarget:kGDTTargetTest];
   uploadPackage.events = [GDTEventGenerator generate3StoredEvents];
   self.prioritizer.uploadPackage = uploadPackage;
   self.uploader.uploadEventsBlock =
       ^(GDTUploadPackage *_Nonnull package, GDTUploaderCompletionBlock _Nonnull completionBlock) {
-        GDTUploadCoordinatorTest *strongSelf = weakSelf;
         NSError *error = [NSError errorWithDomain:NSURLErrorDomain code:1337 userInfo:nil];
-        completionBlock(strongSelf->_target, [GDTClock clockSnapshotInTheFuture:100], error);
+        completionBlock(kGDTTargetTest, [GDTClock clockSnapshotInTheFuture:100], error);
         uploadAttempts++;
       };
   [GDTUploadCoordinator sharedInstance].timerInterval = NSEC_PER_SEC / 10;