Revert "Merge pull request #198 from capriza/master"

This reverts commit d69c72bb3f, reversing
changes made to c95ef1c199.

README.md

  * [Multipart/form upload](#user-content-multipartform-data-example--post-form-data-with-file-and-data)
  * [Upload/Download progress](#user-content-uploaddownload-progress)
  * [Cancel HTTP request](#user-content-cancel-request)
- * [iOS Background Uploading](#user-content-ios-background-uploading)
  * [Android Media Scanner, and Download Manager Support](#user-content-android-media-scanner-and-download-manager-support)
  * [Self-Signed SSL Server](#user-content-self-signed-ssl-server)
  * [Transfer Encoding](#user-content-transfer-encoding)
 
 [See document and examples](https://github.com/joltup/rn-fetch-blob/wiki/Fetch-API#fetch-replacement)
 
-### iOS Background Uploading
- Normally, iOS interrupts network connections when an app is moved to the background, and will throw an error 'Lost connection to background transfer service' when the app resumes. To continue the upload of large files even when the app is in the background, you will need to enable IOSUploadTask options.
-
-First add the following property to your AppDelegate.h:
-```
-@property (nonatomic, copy) void(^backgroundTransferCompletionHandler)();
-```
-Then add the following to your AppDelegate.m:
-```
-- (void)application:(UIApplication *)application
-handleEventsForBackgroundURLSession:(NSString *)identifier
-  completionHandler:(void (^)(void))completionHandler {
-  self.backgroundTransferCompletionHandler = completionHandler;
-}
-```
-The following example shows how to upload a file in the background:
- ```js
- RNFetchBlob
-    .config({
-        IOSBackgroundTask: true, // required for both upload
-        IOSUploadTask: true, // Use instead of IOSDownloadTask if uploading
-        uploadFilePath : 'file://' + filePath
-    })
-    .fetch('PUT', url, {
-            'Content-Type': mediaType
-        }, RNFetchBlob.wrap(filePath));
-```
-
 ### Android Media Scanner, and Download Manager Support
 
 If you want to make a file in `External Storage` becomes visible in Picture, Downloads, or other built-in apps, you will have to use `Media Scanner` or `Download Manager`.

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]) {
-        [[self.requestsTable objectForKey:taskId] cancelRequest:taskId];
+        task = [self.requestsTable objectForKey:taskId].task;
+    }
+    
+    if (task && task.state == NSURLSessionTaskStateRunning) {
+        [task cancel];
     }
 }
 

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 (nonatomic, strong) __block NSURLSession * session;
+@property (nullable, nonatomic, weak) NSURLSessionDataTask *task;
 
 - (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"];
-
-    if (uploadTask && ![[NSFileManager defaultManager] fileExistsAtPath:[NSURL URLWithString:filepath].path]) {
-        RCTLog(@"[RNFetchBlobRequest] sendRequest uploadTask file doesn't exist %@", filepath);
-        callback(@[@"uploadTask file doesn't exist", @"", [NSNull null]]);
-        return;
-    }
-    
     // 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;
     }
     
-    __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];
+    self.task = [session dataTaskWithRequest:req];
+    [self.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];
     }
     
-    [respData appendData:data];
+    if (respFile) {
+        [writeStream write:[data bytes] maxLength:[data length]];
+    } else {
+        [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
 {
-    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;
-            }
-        }
-        
-    });
+    NSLog(@"sess done in background");
 }
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler