fix(request): Fixed when requests sent in order was blocking the main thread

Author: Alexis Oyama

Leanplum-SDK/Classes/LPNetworkOperation.m

@@ -139,6 +139,7 @@ - (void)cancel
     if (self.task) {
         [self.task suspend];
     }
+    [self.session finishTasksAndInvalidate];
 }
 
 - (void)run

Leanplum-SDK/Classes/LPVarCache.m

@@ -229,7 +229,9 @@ + (LPVar *)getVariable:(NSString *)name
 
 + (void)computeMergedDictionary
 {
-    merged = [self mergeHelper:valuesFromClient withDiffs:diffs];
+    @synchronized (diffs) {
+        merged = [self mergeHelper:valuesFromClient withDiffs:diffs];
+    }
 }
 
 + (id)mergeHelper:(id)vars withDiffs:(id)diff
@@ -422,30 +424,31 @@ + (void)saveDiffs
     RETURN_IF_NOOP;
     // Stores the variables on the device in case we don't have a connection
     // next time the app is opened.
-
-    NSMutableData *diffsData = [[NSMutableData alloc] init];
-    NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:diffsData];
-    [archiver encodeObject:diffs forKey:LEANPLUM_DEFAULTS_VARIABLES_KEY];
-    [archiver encodeObject:messages forKey:LEANPLUM_DEFAULTS_MESSAGES_KEY];
-    [archiver encodeObject:updateRulesDiffs forKey:LEANPLUM_DEFAULTS_UPDATE_RULES_KEY];
-    [archiver encodeObject:eventRulesDiffs forKey:LEANPLUM_DEFAULTS_EVENT_RULES_KEY];
-    [archiver encodeObject:variants forKey:LP_KEY_VARIANTS];
-    [archiver encodeObject:regions forKey:LP_KEY_REGIONS];
-    [archiver encodeObject:[LPConstantsState sharedState].sdkVersion forKey:LP_PARAM_SDK_VERSION];
-    [archiver encodeObject:LeanplumRequest.deviceId forKey:LP_PARAM_DEVICE_ID];
-    [archiver encodeObject:LeanplumRequest.userId forKey:LP_PARAM_USER_ID];
-    [archiver encodeBool:[LPConstantsState sharedState].loggingEnabled forKey:LP_KEY_LOGGING_ENABLED];
-    [archiver finishEncoding];
-
-    NSData *encryptedDiffs = [LPAES encryptedDataFromData:diffsData];
-
-    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
-
-    [defaults setObject:encryptedDiffs forKey:LEANPLUM_DEFAULTS_VARIABLES_KEY];
-    
-    [defaults setObject:LEANPLUM_SDK_VERSION forKey:LEANPLUM_DEFAULTS_SDK_VERSION];
-    
-    [Leanplum synchronizeDefaults];
+    @synchronized (diffs) {
+        NSMutableData *diffsData = [[NSMutableData alloc] init];
+        NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:diffsData];
+        [archiver encodeObject:diffs forKey:LEANPLUM_DEFAULTS_VARIABLES_KEY];
+        [archiver encodeObject:messages forKey:LEANPLUM_DEFAULTS_MESSAGES_KEY];
+        [archiver encodeObject:updateRulesDiffs forKey:LEANPLUM_DEFAULTS_UPDATE_RULES_KEY];
+        [archiver encodeObject:eventRulesDiffs forKey:LEANPLUM_DEFAULTS_EVENT_RULES_KEY];
+        [archiver encodeObject:variants forKey:LP_KEY_VARIANTS];
+        [archiver encodeObject:regions forKey:LP_KEY_REGIONS];
+        [archiver encodeObject:[LPConstantsState sharedState].sdkVersion forKey:LP_PARAM_SDK_VERSION];
+        [archiver encodeObject:LeanplumRequest.deviceId forKey:LP_PARAM_DEVICE_ID];
+        [archiver encodeObject:LeanplumRequest.userId forKey:LP_PARAM_USER_ID];
+        [archiver encodeBool:[LPConstantsState sharedState].loggingEnabled forKey:LP_KEY_LOGGING_ENABLED];
+        [archiver finishEncoding];
+
+        NSData *encryptedDiffs = [LPAES encryptedDataFromData:diffsData];
+
+        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+
+        [defaults setObject:encryptedDiffs forKey:LEANPLUM_DEFAULTS_VARIABLES_KEY];
+        
+        [defaults setObject:LEANPLUM_SDK_VERSION forKey:LEANPLUM_DEFAULTS_SDK_VERSION];
+        
+        [Leanplum synchronizeDefaults];
+    }
 }
 
 + (void)applyVariableDiffs:(NSDictionary *)diffs_

Leanplum-SDK/Classes/LeanplumRequest.m

@@ -308,55 +308,37 @@ - (void)sendRequests:(BOOL)async
 {
     void (^operationBlock)() = ^void() {
         [LeanplumRequest generateUUID];
+        lastSentTime = [NSDate timeIntervalSinceReferenceDate];
+        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
 
         // Simulate pop all requests.
         NSArray *requestsToSend = [LPEventDataManager eventsWithLimit:MAX_EVENTS_PER_API_CALL];
-        lastSentTime = [NSDate timeIntervalSinceReferenceDate];
-        
         if (requestsToSend.count == 0) {
             return;
         }
 
+        // Set up request operation.
         NSString *requestData = [LPJSON stringFromJSON:@{LP_PARAM_DATA:requestsToSend}];
+        NSString *timestamp = [NSString stringWithFormat:@"%f", [[NSDate date] timeIntervalSince1970]];
         LPConstantsState *constants = [LPConstantsState sharedState];
-        NSMutableDictionary *multiRequestArgs = [NSMutableDictionary dictionaryWithObjectsAndKeys:
-                                                 requestData, LP_PARAM_DATA,
-                                                 constants.sdkVersion, LP_PARAM_SDK_VERSION,
-                                                 constants.client, LP_PARAM_CLIENT,
-                                                 LP_METHOD_MULTI, LP_PARAM_ACTION,
-                                                 [NSString stringWithFormat:@"%f", [[NSDate date] timeIntervalSince1970]], LP_PARAM_TIME, nil];
+        NSMutableDictionary *multiRequestArgs = [@{
+                                                   LP_PARAM_DATA: requestData,
+                                                   LP_PARAM_SDK_VERSION: constants.sdkVersion,
+                                                   LP_PARAM_CLIENT: constants.client,
+                                                   LP_PARAM_ACTION: LP_METHOD_MULTI,
+                                                   LP_PARAM_TIME: timestamp
+                                                   } mutableCopy];
         [self attachApiKeys:multiRequestArgs];
         int timeout = async ? constants.networkTimeoutSeconds : constants.syncNetworkTimeoutSeconds;
         id<LPNetworkOperationProtocol> op = [engine operationWithPath:constants.apiServlet
                                                                params:multiRequestArgs
                                                            httpMethod:_httpMethod
                                                                   ssl:constants.apiSSL
                                                        timeoutSeconds:timeout];
-        __block BOOL finished = NO;
-        
-        // Schedule timeout.
-        [LPTimerBlocks scheduledTimerWithTimeInterval:timeout block:^() {
-            if (finished) {
-                return;
-            }
-            finished = YES;
-            LP_TRY
-            NSLog(@"Leanplum: Request %@ timed out", _apiMethod);
-            [op cancel];
-            if (_error != nil) {
-                _error([NSError errorWithDomain:@"Leanplum" code:1
-                                       userInfo:@{NSLocalizedDescriptionKey: @"Request timed out"}]);
-            }
-            LP_END_TRY
-        } repeats:NO];
 
+        // Request callbacks.
         [op addCompletionHandler:^(id<LPNetworkOperationProtocol> operation, id json) {
-            if (finished) {
-                return;
-            }
-            finished = YES;
             LP_TRY
-            
             // Handle errors that don't return an HTTP error code.
             NSUInteger numResponses = [LPResponse numResponsesInDictionary:json];
             for (NSUInteger i = 0; i < numResponses; i++) {
@@ -374,6 +356,7 @@ - (void)sendRequests:(BOOL)async
                             _error([NSError errorWithDomain:@"Leanplum" code:2
                                                    userInfo:@{NSLocalizedDescriptionKey: errorMessage}]);
                         }
+                        dispatch_semaphore_signal(semaphore);
                         return;
                     }
                 }
@@ -386,15 +369,14 @@ - (void)sendRequests:(BOOL)async
             if (requestsToSend.count == MAX_EVENTS_PER_API_CALL) {
                 [self sendRequests:async];
             }
+            dispatch_semaphore_signal(semaphore);
             LP_END_TRY
+            
             if (_response != nil) {
                 _response(operation, json);
             }
+            
         } errorHandler:^(id<LPNetworkOperationProtocol> completedOperation, NSError *err) {
-            if (finished) {
-                return;
-            }
-            finished = YES;
             LP_TRY
             NSInteger httpStatusCode = completedOperation.HTTPStatusCode;
             if (httpStatusCode == 408
@@ -430,19 +412,30 @@ - (void)sendRequests:(BOOL)async
             if (_error != nil) {
                 _error(err);
             }
+            dispatch_semaphore_signal(semaphore);
             LP_END_TRY
         }];
 
         // Execute synchronously. Don't block for more than 'timeout' seconds.
-        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-            [engine runSynchronously:op];
-        });
-        NSTimeInterval startTime = [[NSDate date] timeIntervalSince1970];
-        while (!finished && [[NSDate date] timeIntervalSince1970] - startTime < timeout) {
-            [NSThread sleepForTimeInterval:0.1];
+        [engine enqueueOperation:op];
+        dispatch_time_t dispatchTimeout = dispatch_time(DISPATCH_TIME_NOW, timeout*NSEC_PER_SEC);
+        long status = dispatch_semaphore_wait(semaphore, dispatchTimeout);
+        
+        // Request timed out.
+        if (status != 0) {
+            LP_TRY
+            NSLog(@"Leanplum: Request %@ timed out", _apiMethod);
+            [op cancel];
+            if (_error != nil) {
+                _error([NSError errorWithDomain:@"Leanplum" code:1
+                                       userInfo:@{NSLocalizedDescriptionKey: @"Request timed out"}]);
+            }
+            LP_END_TRY
         }
     };
 
+    // Send. operationBlock will run synchronously.
+    // Adding to OperationQueue puts it in the background.
     if (async) {
         [sendNowQueue addOperationWithBlock:operationBlock];
     } else {
@@ -729,6 +722,11 @@ + (void)onNoPendingDownloads:(LeanplumVariablesChangedBlock)block
     noPendingDownloadsBlock = block;
 }
 
++ (NSOperationQueue *)sendNowQueue
+{
+    return sendNowQueue;
+}
+
 @end
 
 @implementation LPResponse