fix(request): Error callbacks are handled properly in sendNow

Added LPEventCallbackManager and LPEventCallback to invoke callbacks on proper event response.

Author: Alexis Oyama

Leanplum-SDK/Classes/LPEventCallbackManager.h

@@ -0,0 +1,69 @@
+//
+//  LPEventCallbackManager.h
+//  Pods
+//
+//  Created by Alexis Oyama on 7/11/17.
+//
+//
+
+#import <Foundation/Foundation.h>
+#import "LPNetworkProtocol.h"
+
+@interface LPEventCallback : NSObject
+
+@property (nonatomic, strong) LPNetworkResponseBlock responseBlock;
+@property (nonatomic, strong) LPNetworkErrorBlock errorBlock;
+
+- (id)initWithResponseBlock:(LPNetworkResponseBlock)responseBlock
+                 errorBlock:(LPNetworkErrorBlock)errorBlock;
+
+/*
+ * Invoke response callback.
+ */
+- (void)invokeResponseWithOperation:(id<LPNetworkOperationProtocol>)operation
+                           response:(id)response;
+
+/*
+ * Invoke error callback.
+ */
+- (void)invokeError:(NSError *)error;
+
+@end
+
+@interface LPEventCallbackManager : NSObject
+
+/**
+ * Returns dictionary that maps event index to event callback object.
+ * Since requests are batched there can be a case where other LeanplumRequest
+ * can take future LeanplumRequest events. We need to ensure all callbacks are
+ * called from any instance.
+ */
++ (NSMutableDictionary *)eventCallbackMap;
+
++ (void)addEventCallbackAt:(NSInteger)index
+           onSuccess:(LPNetworkResponseBlock)responseBlock
+             onError:(LPNetworkErrorBlock)errorBlock;
+
+/** 
+ * Invoke success callbacks that within the range.
+ * Note we need to do this because Request can steal future sendNow callbacks.
+ * Callback map will either have to be updated or removed.
+ */
++ (void)invokeSuccessCallbacksOnResponses:(id)responses
+                                 requests:(NSArray *)requests
+                                operation:(id<LPNetworkOperationProtocol>)operation;
+
+/**
+ * Invoke error callbacks if responses does not contain 'success'.
+ * Called internally from invokeSuccessCallbacksOnResponses:.
+ */
++ (void)invokeErrorCallbacksOnResponses:(id)responses;
+
+/**
+ * Invoke all success callbacks. Loop through all the possible callbacks.
+ * Note we need to do this because Request can steal future sendNow callbacks.
+ * Callback map will either have to be updated or removed.
+ */
++ (void)invokeErrorCallbacksWithError:(NSError *)error;
+
+@end

Leanplum-SDK/Classes/LPEventCallbackManager.m

@@ -0,0 +1,138 @@
+//
+//  LPEventCallbackManager.m
+//  Pods
+//
+//  Created by Alexis Oyama on 7/11/17.
+//
+//
+
+#import "LPEventCallbackManager.h"
+#import "LeanplumRequest.h"
+
+@implementation LPEventCallback
+
+- (id)initWithResponseBlock:(LPNetworkResponseBlock)responseBlock
+                 errorBlock:(LPNetworkErrorBlock)errorBlock
+{
+    if (self = [super init]) {
+        self.responseBlock = [responseBlock copy];
+        self.errorBlock = [errorBlock copy];
+    }
+    return self;
+}
+
+- (void)invokeResponseWithOperation:(id<LPNetworkOperationProtocol>)operation
+                           response:(id)response
+{
+    if (self.responseBlock) {
+        self.responseBlock(operation, response);
+    }
+}
+
+- (void)invokeError:(NSError *)error
+{
+    if (self.errorBlock) {
+        self.errorBlock(error);
+    }
+}
+
+@end
+
+@implementation LPEventCallbackManager
+
++ (NSMutableDictionary *)eventCallbackMap
+{
+    static NSMutableDictionary *_eventCallbackMap;
+    static dispatch_once_t eventCallbackMapToken;
+    dispatch_once(&eventCallbackMapToken, ^{
+        _eventCallbackMap = [NSMutableDictionary new];
+    });
+    return _eventCallbackMap;
+}
+
++ (void)addEventCallbackAt:(NSInteger)index
+                 onSuccess:(LPNetworkResponseBlock)responseBlock
+                   onError:(LPNetworkErrorBlock)errorBlock
+{
+    if (!responseBlock && !errorBlock) {
+        return;
+    }
+    
+    NSMutableDictionary *callbackMap = [LPEventCallbackManager eventCallbackMap];
+    LPEventCallback *callback = [[LPEventCallback alloc] initWithResponseBlock:responseBlock
+                                                                    errorBlock:errorBlock];
+    callbackMap[@(index)] = callback;
+}
+
++ (void)invokeSuccessCallbacksOnResponses:(id)responses
+                                 requests:(NSArray *)requests
+                                operation:(id<LPNetworkOperationProtocol>)operation
+{
+    // Invoke and remove the callbacks that have errors.
+    [LPEventCallbackManager invokeErrorCallbacksOnResponses:responses];
+    
+    NSMutableDictionary *callbackMap = [LPEventCallbackManager eventCallbackMap];
+    NSMutableDictionary *updatedCallbackMap = [NSMutableDictionary new];
+    NSMutableDictionary *activeResponseMap = [NSMutableDictionary new];
+    
+    for (NSNumber *indexObject in callbackMap.allKeys) {
+        NSInteger index = [indexObject integerValue];
+        LPEventCallback *eventCallback = callbackMap[indexObject];
+        
+        // If index is in range, execute and remove it.
+        // If not, requests are in the future. Update the index.
+        [callbackMap removeObjectForKey:indexObject];
+        if (index >= requests.count) {
+            index -= requests.count;
+            updatedCallbackMap[@(index)] = eventCallback;
+        } else if (eventCallback.responseBlock) {
+            activeResponseMap[indexObject] = [eventCallback.responseBlock copy];
+        }
+    }
+    [callbackMap addEntriesFromDictionary:updatedCallbackMap];
+    
+    // Execute responses afterwards to prevent index collision.
+    [activeResponseMap enumerateKeysAndObjectsUsingBlock:^(NSNumber *indexObject, LPNetworkResponseBlock responseBlock, BOOL *stop) {
+        NSInteger index = [indexObject integerValue];
+        id response = [LPResponse getResponseAt:index fromDictionary:responses];
+        responseBlock(operation, response);
+    }];
+}
+
++ (void)invokeErrorCallbacksOnResponses:(id)responses
+{
+    // Handle errors that don't return an HTTP error code.
+    NSMutableDictionary *callbackMap = [LPEventCallbackManager eventCallbackMap];
+    for (NSUInteger i = 0; i < [LPResponse numResponsesInDictionary:responses]; i++) {
+        NSDictionary *response = [LPResponse getResponseAt:i fromDictionary:responses];
+        if ([LPResponse isResponseSuccess:response]) {
+            continue;
+        }
+        
+        NSString *errorMessage = @"API error";
+        NSString *responseError = [LPResponse getResponseError:response];
+        if (responseError) {
+            errorMessage = [NSString stringWithFormat:@"API error: %@", errorMessage];
+        }
+        NSLog(@"Leanplum: %@", errorMessage);
+        
+        LPEventCallback *callback = callbackMap[@(i)];
+        if (callback) {
+            [callbackMap removeObjectForKey:@(i)];
+            NSError *error = [NSError errorWithDomain:@"Leanplum" code:2
+                                             userInfo:@{NSLocalizedDescriptionKey: errorMessage}];
+            [callback invokeError:error];
+        }
+    }
+}
+
++ (void)invokeErrorCallbacksWithError:(NSError *)error
+{
+    NSMutableDictionary *callbackMap = [LPEventCallbackManager eventCallbackMap];
+    for (LPEventCallback *callback in callbackMap) {
+        [callback invokeError:error];
+    }
+    [callbackMap removeAllObjects];
+}
+
+@end

Leanplum-SDK/Classes/LeanplumRequest.h

@@ -34,7 +34,6 @@
     LPNetworkResponseBlock _response;
     LPNetworkErrorBlock _error;
     BOOL _sent;
-    NSInteger _eventIndex;
 }
 
 + (void)setAppId:(NSString *)appId withAccessKey:(NSString *)accessKey;