fix (AWSRNCognitoCredentials.m) remove NSLock, added sendCallbackResponse, fixed getCredentialsAsync

Author: pentateu

Core/ios/Core/AWSRNCognitoCredentials.m

@@ -17,11 +17,11 @@
 @implementation AWSRNCognitoCredentials{
     NSMutableDictionary *options;
     AWSCognitoCredentialsProvider *credentialProvider;
-    NSLock* lock;
     AWSRNHelper *helper;
 }
 
 @synthesize bridge = _bridge;
+@synthesize methodQueue = _methodQueue;
 
 typedef void (^ Block)(id, int);
 
@@ -33,6 +33,8 @@ @implementation AWSRNCognitoCredentials{
 const NSString *EXPIRATION = @"expiration";
 const NSString *IDENTITY_ID = @"identity_id";
 
+static NSMutableDictionary* callbacks;
+
 RCT_EXPORT_MODULE(AWSRNCognitoCredentials)
 
 -(instancetype)init{
@@ -55,22 +57,35 @@ -(instancetype)init{
 }
 
 RCT_EXPORT_METHOD(getCredentialsAsync:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject){
-    [[credentialProvider credentials] continueWithBlock:^id(AWSTask *task) {
-        if (task.exception){
-            dispatch_async(dispatch_get_main_queue(), ^{
-                @throw [NSException exceptionWithName:task.exception.name reason:task.exception.reason userInfo:task.exception.userInfo];
-            });
-        }
-        if (task.error) {
-            reject([NSString stringWithFormat:@"%ld",task.error.code],task.error.description,task.error);
-        }
-        else {
-            AWSCredentials *cred = (AWSCredentials*) task.result;
-            NSDictionary *dict = @{@"AccessKey":cred.accessKey,@"SecretKey":cred.secretKey,@"SessionKey":cred.sessionKey,@"Expiration":cred.expiration};
-            resolve(dict);
-        }
-        return nil;
-    }];
+
+    //start a separate thread for this to avoid blocking the component queue, since
+    //it will have to comunicate with the javascript in the mean time while trying to get the list of logins
+
+    NSString* queueName = [NSString stringWithFormat:@"%@.getCredentialsAsyncQueue",
+                           [NSString stringWithUTF8String:dispatch_queue_get_label(self.methodQueue)]
+                           ];
+    dispatch_queue_t concurrentQueue = dispatch_queue_create([queueName UTF8String], DISPATCH_QUEUE_CONCURRENT);
+
+    dispatch_async(concurrentQueue, ^{
+
+        [[credentialProvider credentials] continueWithBlock:^id(AWSTask *task) {
+            if (task.exception){
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    @throw [NSException exceptionWithName:task.exception.name reason:task.exception.reason userInfo:task.exception.userInfo];
+                });
+            }
+            if (task.error) {
+                reject([NSString stringWithFormat:@"%ld",task.error.code],task.error.description,task.error);
+            }
+            else {
+                AWSCredentials *cred = (AWSCredentials*) task.result;
+                NSDictionary *dict = @{@"AccessKey":cred.accessKey,@"SecretKey":cred.secretKey,@"SessionKey":cred.sessionKey,@"Expiration":cred.expiration};
+                resolve(dict);
+            }
+            return nil;
+        }];
+
+    });
 }
 
 RCT_EXPORT_METHOD(getIdentityIDAsync:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject){
@@ -115,17 +130,17 @@ -(instancetype)init{
 #pragma mark - AWSIdentityProviderManager
 
 - (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins{
-    if (!lock){
-        lock = [[NSLock alloc]init];
-    }
     return [[AWSTask taskWithResult:nil] continueWithSuccessBlock:^id _Nullable(AWSTask * _Nonnull task) {
         __block NSArray* arr;
-        [self sendMessage:[[NSMutableDictionary alloc]init] toChannel:@"LoginsRequestedEvent" withCallback:^(NSArray* response){
+
+        dispatch_semaphore_t sendMessageSemaphore = dispatch_semaphore_create(0);
+
+        [self sendMessage:[[NSMutableDictionary alloc]init] toChannel:@"LoginsRequestedEvent" semaphore:sendMessageSemaphore withCallback:^(NSArray* response) {
             arr = response;
-            [lock unlock];
         }];
-        [lock lock];
-        [lock unlock];
+
+        dispatch_semaphore_wait(sendMessageSemaphore, DISPATCH_TIME_FOREVER);
+
         if (![[arr objectAtIndex:0]isKindOfClass:[NSDictionary class]]){
             return [[NSDictionary alloc]init];
         }
@@ -143,20 +158,50 @@ -(void)identityDidChange:(NSNotification*)notification {
     NSMutableDictionary *dict = [[NSMutableDictionary alloc]init];
     [dict setValue:[notification.userInfo valueForKey:AWSCognitoNotificationPreviousId] forKey:@"Previous"];
     [dict setValue:[notification.userInfo valueForKey:AWSCognitoNotificationNewId] forKey:@"Current"];
-    [self sendMessage:dict toChannel:@"IdentityChange" withCallback:nil];
+    [self sendMessage:dict toChannel:@"IdentityChange"];
 }
 
--(void)sendMessage:(NSMutableDictionary*)info toChannel:(NSString*)channel withCallback:(RCTResponseSenderBlock)callback{
-    if ([channel isEqualToString:@"LoginsRequestedEvent"]){
-        [lock lock];
-        [info setValue:callback forKey:@"ReturnInfo"];
+
+RCT_EXPORT_METHOD(sendCallbackResponse:(NSString *)callbackId response:(NSArray *)response){
+    NSDictionary* callbackInfo = [callbacks objectForKey:callbackId];
+    if(callbackInfo) {
+        RCTResponseSenderBlock callback = callbackInfo[@"callback"];
+        dispatch_semaphore_t semaphore = callbackInfo[@"semaphore"];
+        [callbacks removeObjectForKey:callbackId];
+
+        callback(response);
+        dispatch_semaphore_signal(semaphore);
+    }
+    else{
+        NSLog(@"WARN callback id not found!");
     }
+}
+
+-(NSString*) registerCallBack:(RCTResponseSenderBlock)callback semaphore:(dispatch_semaphore_t)semaphore {
+    if (!callbacks){
+        callbacks = [@{} mutableCopy];
+    }
+    NSString* callbackId = [[NSUUID UUID] UUIDString];
+    callbacks[callbackId] = @{
+                              @"callback": callback ? callback : (^(NSArray *response) { }),
+                              @"semaphore":semaphore
+                              };
+    return callbackId;
+}
+
+-(void)sendMessage:(NSMutableDictionary*)info toChannel:(NSString*)channel{
     [self.bridge.eventDispatcher
      sendAppEventWithName:channel
      body:[info copy]
      ];
 }
 
+-(void)sendMessage:(NSMutableDictionary*)info toChannel:(NSString*)channel semaphore:(dispatch_semaphore_t)semaphore withCallback:(RCTResponseSenderBlock)callback  {
+    NSString * callbackId = [self registerCallBack:callback semaphore:semaphore];
+    [info setValue:callbackId forKey:@"callbackId"];
+    [self sendMessage:info toChannel:channel];
+}
+
 -(NSMutableDictionary*)setLogins:(NSMutableDictionary*)reactLogins{
     NSMutableDictionary *logins = [[NSMutableDictionary alloc]init];
     for (NSString* key in reactLogins){
@@ -186,7 +231,4 @@ -(NSMutableDictionary*)setLogins:(NSMutableDictionary*)reactLogins{
     return logins;
 }
 
-
-
-
 @end