support upload task + recieve finish event from background

ios/RNFetchBlobNetwork.m

 + (RNFetchBlobNetwork* _Nullable)sharedInstance {
     static id _sharedInstance = nil;
     static dispatch_once_t onceToken;
-
+    
     dispatch_once(&onceToken, ^{
         _sharedInstance = [[self alloc] init];
     });
 
 - (void) cancelRequest:(NSString *)taskId
 {
-    NSURLSessionDataTask * task;
-    
     @synchronized ([RNFetchBlobNetwork class]) {
-        task = [self.requestsTable objectForKey:taskId].task;
-    }
-    
-    if (task && task.state == NSURLSessionTaskStateRunning) {
-        [task cancel];
+        [[self.requestsTable objectForKey:taskId] cancelRequest:taskId];
     }
 }
 

ios/RNFetchBlobRequest.h

 @property (nullable, nonatomic) NSError * error;
 @property (nullable, nonatomic) RNFetchBlobProgress *progressConfig;
 @property (nullable, nonatomic) RNFetchBlobProgress *uploadProgressConfig;
-@property (nullable, nonatomic, weak) NSURLSessionDataTask *task;
+//@property (nullable, nonatomic, weak) NSURLSessionDataTask *task;
+@property (nonatomic, strong) __block NSURLSession * session;
 
 - (void) sendRequest:(NSDictionary  * _Nullable )options
        contentLength:(long)contentLength
   taskOperationQueue:(NSOperationQueue * _Nonnull)operationQueue
             callback:(_Nullable RCTResponseSenderBlock) callback;
 
+- (void) cancelRequest:(NSString *)taskId;
+
 @end
 
 #endif /* RNFetchBlobRequest_h */

ios/RNFetchBlobRequest.m

 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobConst.h"
 #import "RNFetchBlobReqBuilder.h"
+#if __has_include(<React/RCTLog.h>)
+#import <React/RCTLog.h>
+#else
+#import "RCTLog.h"
+#endif
 
 #import "IOS7Polyfill.h"
 #import <CommonCrypto/CommonDigest.h>
 
+NSMapTable * taskTable;
+
+__attribute__((constructor))
+static void initialize_tables() {
+    if(taskTable == nil)
+    {
+        taskTable = [[NSMapTable alloc] init];
+    }
+}
 
 typedef NS_ENUM(NSUInteger, ResponseFormat) {
     UTF8,
     ResponseFormat responseFormat;
     BOOL followRedirect;
     BOOL backgroundTask;
+    BOOL uploadTask;
 }
 
 @end
     self.options = options;
     
     backgroundTask = [[options valueForKey:@"IOSBackgroundTask"] boolValue];
+    uploadTask = [options valueForKey:@"IOSUploadTask"] == nil ? NO : [[options valueForKey:@"IOSUploadTask"] boolValue];
+    
+    NSString * filepath = [options valueForKey:@"uploadFilePath"];
+    
     // when followRedirect not set in options, defaults to TRUE
     followRedirect = [options valueForKey:@"followRedirect"] == nil ? YES : [[options valueForKey:@"followRedirect"] boolValue];
     isIncrement = [[options valueForKey:@"increment"] boolValue];
     
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
     NSString * key = [self.options valueForKey:CONFIG_KEY];
-    NSURLSession * session;
     
     bodyLength = contentLength;
     
         defaultConfigObject = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:taskId];
     }
     
+    
     // request timeout, -1 if not set in options
     float timeout = [options valueForKey:@"timeout"] == nil ? -1 : [[options valueForKey:@"timeout"] floatValue];
     
     }
     
     defaultConfigObject.HTTPMaximumConnectionsPerHost = 10;
-    session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:operationQueue];
+    _session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:operationQueue];
     
     if (path || [self.options valueForKey:CONFIG_USE_TEMP]) {
         respFile = YES;
         respFile = NO;
     }
     
-    self.task = [session dataTaskWithRequest:req];
-    [self.task resume];
+    __block NSURLSessionTask * task;
+    
+    if(uploadTask)
+    {
+        task = [_session uploadTaskWithRequest:req fromFile:[NSURL URLWithString:filepath]];
+    }
+    else
+    {
+        task = [_session dataTaskWithRequest:req];
+    }
+    
+    [taskTable setObject:task forKey:taskId];
+    [task resume];
     
     // network status indicator
     if ([[options objectForKey:CONFIG_INDICATOR] boolValue]) {
 // set expected content length on response received
 - (void) URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveResponse:(NSURLResponse *)response completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
 {
+    NSLog(@"sess didReceiveResponse");
     expectedBytes = [response expectedContentLength];
     
     NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse*)response;
             
             partBuffer = [[NSMutableData alloc] init];
             completionHandler(NSURLSessionResponseAllow);
-
+            
             return;
         } else {
             self.isServerPush = [[respCType lowercaseString] RNFBContainsString:@"multipart/x-mixed-replace;"];
         NSLog(@"oops");
     }
     
-    if (respFile)
-    {
-        @try{
-            NSFileManager * fm = [NSFileManager defaultManager];
-            NSString * folder = [destPath stringByDeletingLastPathComponent];
-            
-            if (![fm fileExistsAtPath:folder]) {
-                [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:nil];
-            }
-            
-            // if not set overwrite in options, defaults to TRUE
-            BOOL overwrite = [options valueForKey:@"overwrite"] == nil ? YES : [[options valueForKey:@"overwrite"] boolValue];
-            BOOL appendToExistingFile = [destPath RNFBContainsString:@"?append=true"];
-            
-            appendToExistingFile = !overwrite;
-            
-            // For solving #141 append response data if the file already exists
-            // base on PR#139 @kejinliang
-            if (appendToExistingFile) {
-                destPath = [destPath stringByReplacingOccurrencesOfString:@"?append=true" withString:@""];
-            }
-            
-            if (![fm fileExistsAtPath:destPath]) {
-                [fm createFileAtPath:destPath contents:[[NSData alloc] init] attributes:nil];
-            }
-            
-            writeStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:appendToExistingFile];
-            [writeStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
-            [writeStream open];
-        }
-        @catch(NSException * ex)
-        {
-            NSLog(@"write file error");
-        }
-    }
-    
     completionHandler(NSURLSessionResponseAllow);
 }
 
         chunkString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
     }
     
-    if (respFile) {
-        [writeStream write:[data bytes] maxLength:[data length]];
-    } else {
-        [respData appendData:data];
-    }
+    [respData appendData:data];
     
     if (expectedBytes == 0) {
         return;
     }
 }
 
+- (void) cancelRequest:(NSString *)taskId
+{
+    NSURLSessionDataTask * task = [taskTable objectForKey:taskId];
+    if(task != nil && task.state == NSURLSessionTaskStateRunning)
+        [task cancel];
+}
+
 - (void) URLSession:(NSURLSession *)session didBecomeInvalidWithError:(nullable NSError *)error
 {
+    RCTLog(@"[RNFetchBlobRequest] session didBecomeInvalidWithError %@", [error description]);
     if ([session isEqual:session]) {
         session = nil;
     }
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
 {
-    
+    RCTLog(@"[RNFetchBlobRequest] session didCompleteWithError %@", [error description]);
     self.error = error;
     NSString * errMsg;
     NSString * respStr;
                respStr ?: [NSNull null]
                ]);
     
+    @synchronized(taskTable)
+    {
+        if([taskTable objectForKey:taskId] == nil)
+            NSLog(@"object released by ARC.");
+        else
+            [taskTable removeObjectForKey:taskId];
+    }
+    
     respData = nil;
     receivedBytes = 0;
     [session finishTasksAndInvalidate];
-    
 }
 
 // upload progress handler
     }
     
     NSNumber * now = [NSNumber numberWithFloat:((float)totalBytesWritten/(float)totalBytesExpectedToWrite)];
-
+    
     if ([self.uploadProgressConfig shouldReport:now]) {
         [self.bridge.eventDispatcher
          sendDeviceEventWithName:EVENT_PROGRESS_UPLOAD
 
 - (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
 {
-    NSLog(@"sess done in background");
+    RCTLog(@"[RNFetchBlobRequest] session done in background");
+    dispatch_async(dispatch_get_main_queue(), ^{
+        id<UIApplicationDelegate> appDelegate = [UIApplication sharedApplication].delegate;
+        SEL selector = NSSelectorFromString(@"backgroundTransferCompletionHandler");
+        if ([appDelegate respondsToSelector:selector]) {
+            void(^completionHandler)() = [appDelegate performSelector:selector];
+            if (completionHandler != nil) {
+                completionHandler();
+                completionHandler = nil;
+            }
+        }
+        
+    });
 }
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler