Fix IOS memory leaks

src/ios/RNFetchBlob/RNFetchBlob.m

                   callback:(RCTResponseSenderBlock)callback)
 {
 
-    [RNFetchBlobReqBuilder buildMultipartRequest:options taskId:taskId method:method url:url headers:headers form:form onComplete:^(NSURLRequest *req, long bodyLength) {
+    [RNFetchBlobReqBuilder buildMultipartRequest:options taskId:taskId method:method url:url headers:headers form:form onComplete:^(__weak NSURLRequest *req, long bodyLength) {
         // send HTTP request
         RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
         [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
-        utils = nil;
     }];
 
 }
                   headers:(NSDictionary *)headers
                   body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
-    NSString *cType = [headers valueForKey:@"content-type"];
-    
     [RNFetchBlobReqBuilder buildOctetRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
         // send HTTP request
-        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+        __block RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
         [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
-        utils = nil;
     }];
 }
 

src/ios/RNFetchBlobFS.m

     @try
     {
         [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
-            NSData * fileContent;
+            __block NSData * fileContent;
             NSError * err;
-            Byte * buffer;
+            __block Byte * buffer;
             if(asset != nil)
             {
                 buffer = malloc(asset.size);
     if([uri hasPrefix:AL_PREFIX])
     {
         NSURL *asseturl = [NSURL URLWithString:uri];
-        ALAssetsLibrary* assetslibrary = [[ALAssetsLibrary alloc] init];
+        __block ALAssetsLibrary* assetslibrary = [[ALAssetsLibrary alloc] init];
         [assetslibrary assetForURL:asseturl
                        resultBlock:^(ALAsset *asset) {
-                           onComplete(nil, [asset defaultRepresentation]);
+                           __block ALAssetRepresentation * present = [asset defaultRepresentation];
+                           onComplete(nil, present);
                        }
                       failureBlock:^(NSError *error) {
                           onComplete(nil, nil);

src/ios/RNFetchBlobNetwork.m

 }
 
 // send HTTP request
-- (void) sendRequest:(NSDictionary  * _Nullable )options
+- (void) sendRequest:(__weak NSDictionary  * _Nullable )options
        contentLength:(long) contentLength
               bridge:(RCTBridge * _Nullable)bridgeRef
               taskId:(NSString * _Nullable)taskId
-         withRequest:(NSURLRequest * _Nullable)req
+         withRequest:(__weak NSURLRequest * _Nullable)req
             callback:(_Nullable RCTResponseSenderBlock) callback
 {
     self.taskId = taskId;
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
     NSString * ext = [self.options valueForKey:CONFIG_FILE_EXT];
 	NSString * key = [self.options valueForKey:CONFIG_KEY];
-    NSURLSession * session;
+    __block NSURLSession * session;
 
     bodyLength = contentLength;
 
     // the session trust any SSL certification
 
+    
     NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
     if([options valueForKey:@"timeout"] != nil)
     {
         defaultConfigObject.timeoutIntervalForRequest = [[options valueForKey:@"timeout"] floatValue];
     }
     session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:taskQueue];
-    
     if(path != nil || [self.options valueForKey:CONFIG_USE_TEMP]!= nil)
     {
         respFile = YES;
                      @"timeout" : @NO,
                      @"status": [NSString stringWithFormat:@"%d", statusCode ]
                      };
+        
         [self.bridge.eventDispatcher
          sendDeviceEventWithName: EVENT_STATE_CHANGE
          body:respInfo
-         ];
+        ];
+        headers = nil;
+        respInfo = nil;
     }
 
     if(respFile == YES)
 // download progress handler
 - (void) URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
 {
-    receivedBytes += [data length];
+    NSNumber * received = [NSNumber numberWithLong:[data length]];
+    receivedBytes += [received longValue];
     if(respFile == NO)
     {
         [respData appendData:data];
                 }
          ];
     }
+    received = nil;
 
 }
 
-- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
+- (void) URLSession:(NSURLSession *)session didBecomeInvalidWithError:(nullable NSError *)error
+{
+    if([session isEqual:session])
+        session = nil;
+}
+
+- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
     
     self.error = error;
     [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
     [taskTable removeObjectForKey:taskId];
     [uploadProgressTable removeObjectForKey:taskId];
     [progressTable removeObjectForKey:taskId];
+    respData = nil;
+    receivedBytes = 0;
+    [session finishTasksAndInvalidate];
 }
 
 // upload progress handler

src/ios/RNFetchBlobReqBuilder.h

                          url:(NSString *)url
                      headers:(NSDictionary *)headers
                         form:(NSString *)body
-                  onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
+                  onComplete:(void(^)(__weak NSURLRequest * req, long bodyLength))onComplete;
 
 +(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSMutableArray *) headers;
 

src/ios/RNFetchBlobReqBuilder.m

     NSString * encodedUrl = url;
     
     // send request
-    NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString: encodedUrl]];
+    __block NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString: encodedUrl]];
     NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
     NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
     NSNumber * timeStampObj = [NSNumber numberWithDouble: timeStamp];
     // generate boundary
     NSString * boundary = [NSString stringWithFormat:@"RNFetchBlob%d", timeStampObj];
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-        NSMutableData * postData = [[NSMutableData alloc] init];
+        __block NSMutableData * postData = [[NSMutableData alloc] init];
         // combine multipart/form-data body
         [[self class] buildFormBody:form boundary:boundary onComplete:^(NSData *formData) {
             if(formData != nil) {
                       url:(NSString *)url
                   headers:(NSDictionary *)headers
                      body:(NSString *)body
-               onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
+               onComplete:(void(^)(__weak NSURLRequest * req, long bodyLength))onComplete
 {
 //    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
     NSString * encodedUrl = url;
     // send request
-    NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
+    __block NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
                                     initWithURL:[NSURL URLWithString: encodedUrl]];
 
-    NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
+    __block NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
     // move heavy task to another thread
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         NSMutableData * blobData;
         if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
             // generate octet-stream body
             if(body != nil) {
-                NSString * cType = [[self class] getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
+                __block NSString * cType = [[self class] getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                 // when headers does not contain a key named "content-type" (case ignored), use default content type
                 if(cType == nil)
                 {
                 
                 // when body is a string contains file path prefix, try load file from the path
                 if([body hasPrefix:FILE_PREFIX]) {
-                    NSString * orgPath = [body substringFromIndex:[FILE_PREFIX length]];
+                    __block NSString * orgPath = [body substringFromIndex:[FILE_PREFIX length]];
                     orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
                     if([orgPath hasPrefix:AL_PREFIX])
                     {
                 // otherwise convert it as BASE64 data string
                 else {
                     
-                    NSString * cType = [[self class]getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
+                    __block NSString * cType = [[self class]getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                     // when content-type is application/octet* decode body string using BASE64 decoder
                     if([[cType lowercaseString] hasPrefix:@"application/octet"] || [[cType lowercaseString] containsString:@";base64"])
                     {