Remove WIP code which causes memory leaks.

src/ios/RNFetchBlob.xcodeproj/project.pbxproj

 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				GCC_INPUT_FILETYPE = automatic;
 				HEADER_SEARCH_PATHS = (
 					"$(inherited)",
 					"$(SRCROOT)/Libraries/**",
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				GCC_INPUT_FILETYPE = automatic;
 				HEADER_SEARCH_PATHS = (
 					"$(inherited)",
 					"$(SRCROOT)/Libraries/**",

src/ios/RNFetchBlob/RNFetchBlob.m

         // send HTTP request
         RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
         [utils sendRequest:options bridge:self.bridge taskId:taskId withRequest:request callback:callback];
+        utils = nil;
     });
 }
 
         // send HTTP request
         RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
         [utils sendRequest:options bridge:self.bridge taskId:taskId withRequest:request callback:callback];
+        utils = nil;
     });
 }
 

src/ios/RNFetchBlobFS.m

             // read stream incoming chunk
         case NSStreamEventHasBytesAvailable:
         {
-            NSMutableData * chunkData = [[NSMutableData data] init];
+            NSMutableData * chunkData = [[NSMutableData alloc] init];
             NSInteger chunkSize = 4096;
             if([[self.encoding lowercaseString] isEqualToString:@"base64"])
                 chunkSize = 4095;
             if(self.bufferSize > 0)
                 chunkSize = self.bufferSize;
-            uint8_t buf[chunkSize];
+            uint8_t * buf = (uint8_t *)malloc(chunkSize);
             unsigned int len = 0;
-            
             len = [(NSInputStream *)stream read:buf maxLength:chunkSize];
             // still have data in stream
             if(len) {
-                [chunkData appendBytes:(const void *)buf length:len];
+                [chunkData appendBytes:buf length:len];
                 // dispatch data event
                 NSString * encodedChunk = [NSString alloc];
                 if( [[self.encoding lowercaseString] isEqualToString:@"utf8"] ) {
                         NSInteger byteLen = chunkData.length/sizeof(uint8_t);
                         for (int i = 0; i < byteLen; i++)
                         {
-                            uint8_t * byteFromArray = chunkData.bytes;
                             NSInteger val = bytePtr[i];
                             if(i+1 < byteLen)
                                 asciiStr = [asciiStr stringByAppendingFormat:@"%d,", val];
                             else
                                 asciiStr = [asciiStr stringByAppendingFormat:@"%d", val];
                         }
-                        free(bytePtr);
                     }
                     asciiStr = [asciiStr stringByAppendingString:@"]"];
                     [self.bridge.eventDispatcher
                      sendDeviceEventWithName:streamEventCode
-                     body:@{
-                            @"event": FS_EVENT_DATA,
-                            @"detail": asciiStr
+                     body: @{
+                             @"event": FS_EVENT_DATA,
+                             @"detail": asciiStr
                             }
                      ];
+                    free(buf);
+                    asciiStr = nil;
+                    buf = nil;
+                    chunkData = nil;
                     return;
                 }
                 // convert byte array to base64 data chunks
                 else if ( [[self.encoding lowercaseString] isEqualToString:@"base64"] ) {
                     encodedChunk = [chunkData base64EncodedStringWithOptions:0];
                 }
-                // unknown encoding, send erro event
+                // unknown encoding, send error event
                 else {
                     [self.bridge.eventDispatcher
                      sendDeviceEventWithName:streamEventCode
                         @"detail": encodedChunk
                         }
                  ];
-                
+                chunkData = nil;
+                free(buf);
             }
             // end of stream
             else {
                         @"detail": @""
                         }
                  ];
+                chunkData = nil;
+                free(buf);
             }
             break;
         }

src/ios/RNFetchBlobNetwork.h

 @property (nullable, nonatomic) RCTBridge * bridge;
 @property (nullable, nonatomic) NSDictionary * options;
 @property (nullable, nonatomic) RNFetchBlobFS * fileStream;
-@property (strong, nonatomic) CompletionHander fileTaskCompletionHandler;
-@property (strong, nonatomic) DataTaskCompletionHander dataTaskCompletionHandler;
+//@property (strong, nonatomic) CompletionHander fileTaskCompletionHandler;
+//@property (strong, nonatomic) DataTaskCompletionHander dataTaskCompletionHandler;
 @property (nullable, nonatomic) NSError * error;
 
 

src/ios/RNFetchBlobNetwork.m

 @synthesize callback;
 @synthesize bridge;
 @synthesize options;
-@synthesize fileTaskCompletionHandler;
-@synthesize dataTaskCompletionHandler;
+//@synthesize fileTaskCompletionHandler;
+//@synthesize dataTaskCompletionHandler;
 @synthesize error;
 
 
     // file will be stored at a specific path
     if( path != nil) {
         
-        self.fileTaskCompletionHandler = ^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+//        self.fileTaskCompletionHandler = ;
+        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
             if(error != nil) {
                 callback(@[[error localizedDescription]]);
                 return;
                 return;
             }
             callback(@[[NSNull null], path]);
-        };
-        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:fileTaskCompletionHandler];
+            // prevent memory leaks
+            self.respData = nil;
+        }];
         [task resume];
     }
     // file will be stored at tmp path
     else if ( [self.options valueForKey:CONFIG_USE_TEMP]!= nil ) {
         
-        self.fileTaskCompletionHandler = ^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+//        self.fileTaskCompletionHandler;
+        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
             if(error != nil) {
                 callback(@[[error localizedDescription]]);
                 return;
                 return;
             }
             callback(@[[NSNull null], tmpPath]);
-        };
-        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:fileTaskCompletionHandler];
+            // prevent memory leaks
+            self.respData = nil;
+        }];
         [task resume];
     }
     // base64 response
     else {
-        self.dataTaskCompletionHandler = ^(NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+//        self.dataTaskCompletionHandler = ;
+        NSURLSessionDataTask * task = [session dataTaskWithRequest:req completionHandler:^(NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error) {
             if(error != nil) {
                 callback(@[[error localizedDescription]]);
                 return;
             else {
                 callback(@[[NSNull null], [resp base64EncodedStringWithOptions:0]]);
             }
-        };
-        NSURLSessionDataTask * task = [session dataTaskWithRequest:req completionHandler:dataTaskCompletionHandler];
+        }];
         [task resume];
     }
 }
     
 }
 
-- (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
-{
-    if(self.dataTaskCompletionHandler != nil)
-    {
-        dataTaskCompletionHandler(self.respData, nil, error);
-    }
-    else if(self.fileTaskCompletionHandler != nil)
-    {
-        fileTaskCompletionHandler(nil, nil, self.error);
-    }
-}
+//- (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
+//{
+//    if(self.dataTaskCompletionHandler != nil)
+//    {
+//        dataTaskCompletionHandler(self.respData, nil, error);
+//    }
+//    else if(self.fileTaskCompletionHandler != nil)
+//    {
+//        fileTaskCompletionHandler(nil, nil, self.error);
+//    }
+//}
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition, NSURLCredential * _Nullable))completionHandler
 {