Merge branch '0.10.5' into issue-287-wip

README.md

 
 
 A project committed to making file access and data transfer easier, efficient for React Native developers.
-
 > For Firebase Storage solution, please upgrade to latest version for best compatibility.
 
 ## Features
     :path => '../node_modules/react-native-fetch-blob'
 ```
 
+After `0.10.3` you can install this package directly from Github 
+
+```sh
+# replace <branch_name> with any one of the branches
+npm install --save github:wkh237/react-native-fetch-blob-package#<branch_name>
+```
 **Automatically Link Native Modules**
 
 For 0.29.2+ projects, simply link native packages via the following command because rnpm has been merged into react-native, you no longer need it.

android.js

     return Promise.reject('RNFetchBlob.actionViewIntent only supports Android.')
 }
 
+function getContentIntent(mime:string) {
+  if(Platform.OS === 'android')
+    return RNFetchBlob.getContentIntent(mime)
+  else
+    return Promise.reject('RNFetchBlob.getContentIntent only supports Android.')
+}
+
 
 export default {
-  actionViewIntent
+  actionViewIntent,
+  getContentIntent
 }

android/src/main/java/com/RNFetchBlob/RNFetchBlob.java

 package com.RNFetchBlob;
 
+import android.app.Activity;
 import android.content.Intent;
 import android.net.Uri;
+import android.util.Log;
 
 import com.RNFetchBlob.Utils.RNFBCookieJar;
+import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 
+import java.util.HashMap;
 import java.util.Map;
+import java.util.UUID;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
+import static android.app.Activity.RESULT_OK;
+import static com.RNFetchBlob.RNFetchBlobConst.GET_CONTENT_INTENT;
+
 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
     static ReactApplicationContext RCTContext;
     static LinkedBlockingQueue<Runnable> fsTaskQueue = new LinkedBlockingQueue<>();
     static ThreadPoolExecutor fsThreadPool = new ThreadPoolExecutor(2, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
     static public boolean ActionViewVisible = false;
+    static HashMap<Integer, Promise> promiseTable = new HashMap<>();
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
 
         super(reactContext);
 
         RCTContext = reactContext;
+        reactContext.addActivityEventListener(new ActivityEventListener() {
+            @Override
+            public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+                if(requestCode == GET_CONTENT_INTENT && resultCode == RESULT_OK) {
+                    Uri d = data.getData();
+                    promiseTable.get(GET_CONTENT_INTENT).resolve(d.toString());
+                    promiseTable.remove(GET_CONTENT_INTENT);
+                }
+            }
+
+            @Override
+            public void onNewIntent(Intent intent) {
+
+            }
+        });
     }
 
     @Override
         new RNFetchBlobReq(options, taskId, method, url, headers, null, body, callback).run();
     }
 
+    @ReactMethod
+    public void getContentIntent(String mime, Promise promise) {
+        Intent i = new Intent(Intent.ACTION_GET_CONTENT);
+        if(mime != null)
+            i.setType(mime);
+        else
+            i.setType("*/*");
+        promiseTable.put(GET_CONTENT_INTENT, promise);
+        this.getReactApplicationContext().startActivityForResult(i, GET_CONTENT_INTENT, null);
+
+    }
+
 }

android/src/main/java/com/RNFetchBlob/RNFetchBlobConst.java

     public static final String RNFB_RESPONSE_BASE64 = "base64";
     public static final String RNFB_RESPONSE_UTF8  = "utf8";
     public static final String RNFB_RESPONSE_PATH  = "path";
+    public static final Integer GET_CONTENT_INTENT = 99900;
 
 }

android/src/main/java/com/RNFetchBlob/RNFetchBlobFS.java

                 while ((cursor = fs.read(buffer)) != -1) {
                     encoder.encode(ByteBuffer.wrap(buffer).asCharBuffer());
                     String chunk = new String(buffer);
-                    if(cursor != bufferSize)
+                    if(cursor != bufferSize) {
                         chunk = chunk.substring(0, cursor);
+                    }
                     emitStreamEvent(streamId, "data", chunk);
                     if(tick > 0)
                         SystemClock.sleep(tick);
             buffer = null;
 
         } catch (Exception err) {
-            emitStreamEvent(streamId, "error", "Failed to convert data to "+encoding+" encoded string, this might due to the source data is not able to convert using this encoding.");
+            emitStreamEvent(streamId, "warn", "Failed to convert data to "+encoding+" encoded string, this might due to the source data is not able to convert using this encoding.");
+            err.printStackTrace();
         }
     }
 

android/src/main/java/com/RNFetchBlob/RNFetchBlobReq.java

                             responseFormat = ResponseFormat.UTF8;
                     }
                     else {
-                        builder.header(key, value);
-                        mheaders.put(key, value);
+                        builder.header(key.toLowerCase(), value);
+                        mheaders.put(key.toLowerCase(), value);
                     }
                 }
             }
             clientBuilder.addNetworkInterceptor(new Interceptor() {
                 @Override
                 public Response intercept(Chain chain) throws IOException {
-                        redirects.add(chain.request().url().toString());
-                        return chain.proceed(chain.request());
-                    }
+                    redirects.add(chain.request().url().toString());
+                    return chain.proceed(chain.request());
+                }
             });
             // Add request interceptor for upload progress event
             clientBuilder.addInterceptor(new Interceptor() {
                     // It uses customized response body which is able to report download progress
                     // and write response data to destination path.
                     resp.body().bytes();
-
                 } catch (Exception ignored) {
 //                    ignored.printStackTrace();
                 }
                 this.destPath = this.destPath.replace("?append=true", "");
-
-                try {
-                    long expectedLength = resp.body().contentLength();
-                    // when response contains Content-Length, check if the stream length is correct
-                    if(expectedLength > 0) {
-                        long actualLength = new File(this.destPath).length();
-                        if(actualLength != expectedLength) {
-                            callback.invoke("RNFetchBlob failed to write data to storage : expected " + expectedLength + " bytes but got " + actualLength + " bytes", null);
-                        }
-                        else {
-                            callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
-                        }
-                    }
-                    else {
-                        callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
-                    }
-                }
-                catch (Exception err) {
-                    callback.invoke(err.getMessage());
-                    err.printStackTrace();
-                }
+                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 break;
             default:
                 try {
                 break;
         }
 //        if(!resp.isSuccessful())
-            resp.body().close();
+        resp.body().close();
         releaseTaskResource();
     }
 
         }
         WritableArray redirectList = Arguments.createArray();
         for(String r : redirects) {
-                redirectList.pushString(r);
+            redirectList.pushString(r);
         }
         info.putArray("redirects", redirectList);
         info.putMap("headers", headers);
     private String getHeaderIgnoreCases(HashMap<String,String> headers, String field) {
         String val = headers.get(field);
         if(val != null) return val;
-        return headers.get(field.toLowerCase()) == null ? "" : headers.get(field.toLowerCase());
+        String lowerCasedValue = headers.get(field.toLowerCase());
+        return lowerCasedValue == null ? "" : lowerCasedValue;
     }
 
     private void emitStateEvent(WritableMap args) {

index.js

 
   // # 241 normalize null or undefined headers, in case nil or null string
   // pass to native context
-  _.each(headers, (h,i) =>  {
-    headers[i] = h || ''
-  });
+  headers = _.reduce(headers, (result, value, key) => {
+    result[key] = value || ''
+    return result
+  }, {});
 
   // fetch from file system
   if(URIUtil.isFileURI(url)) {

ios/RNFetchBlob/RNFetchBlob.m

                   callback:(RCTResponseSenderBlock)callback)
 {
 
-    [RNFetchBlobReqBuilder buildMultipartRequest:options taskId:taskId method:method url:url headers:headers form:form onComplete:^(__weak NSURLRequest *req, long bodyLength) {
+    [RNFetchBlobReqBuilder buildMultipartRequest:options
+                                          taskId:taskId
+                                          method:method
+                                             url:url
+                                         headers:headers
+                                            form:form
+                                      onComplete:^(__weak NSURLRequest *req, long bodyLength)
+    {
+        // something went wrong when building the request body
+        if(req == nil)
+        {
+            callback(@[@"RNFetchBlob.fetchBlobForm failed to create request body"]);
+        }
         // send HTTP request
-        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        else
+        {
+            RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+            [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        }
     }];
 
 }
                   headers:(NSDictionary *)headers
                   body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
-    [RNFetchBlobReqBuilder buildOctetRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
+    [RNFetchBlobReqBuilder buildOctetRequest:options
+                                      taskId:taskId
+                                      method:method
+                                         url:url
+                                     headers:headers
+                                        body:body
+                                  onComplete:^(NSURLRequest *req, long bodyLength)
+    {
+        // something went wrong when building the request body
+        if(req == nil)
+        {
+            callback(@[@"RNFetchBlob.fetchBlob failed to create request body"]);
+        }
         // send HTTP request
-        __block RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        else
+        {
+            __block RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+            [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+        }
     }];
 }
 
 }
 
 #pragma mark - fs.readFile
-RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXPORT_METHOD(readFile:(NSString *)path
+                  encoding:(NSString *)encoding
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 {
 
-    [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject onComplete:nil];
+    [RNFetchBlobFS readFile:path encoding:encoding onComplete:^(id content, NSString * err) {
+        if(err != nil)
+        {
+            reject(@"RNFetchBlob failed to read file", err, nil);
+            return;
+        }
+        if(encoding == @"ascii")
+        {
+            resolve((NSMutableArray *)content);
+        }
+        else
+        {
+            resolve((NSString *)content);
+        }
+    }];
 }
 
 #pragma mark - fs.readStream

ios/RNFetchBlobFS.h

 + (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback;
 + (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
-+ (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject onComplete:(void (^)(NSData * content))onComplete;
++ (void) readFile:(NSString *)path encoding:(NSString *)encoding onComplete:(void (^)(NSData * content, NSString * errMsg))onComplete;
 + (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
 + (void) slice:(NSString *)path
          dest:(NSString *)dest

ios/RNFetchBlobFS.m

 
 # pragma mark - read file
 
-+ (void) readFile:(NSString *)path encoding:(NSString *)encoding
-         resolver:(RCTPromiseResolveBlock)resolve
-         rejecter:(RCTPromiseRejectBlock)reject
-       onComplete:(void (^)(NSData * content))onComplete
++ (void) readFile:(NSString *)path
+         encoding:(NSString *)encoding
+       onComplete:(void (^)(id content, NSString * errMsg))onComplete
 {
-    @try
-    {
-        [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
-            __block NSData * fileContent;
-            NSError * err;
-            __block Byte * buffer;
-            if(asset != nil)
+    [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        __block NSData * fileContent;
+        NSError * err;
+        __block Byte * buffer;
+        if(asset != nil)
+        {
+            buffer = malloc(asset.size);
+            [asset getBytes:buffer fromOffset:0 length:asset.size error:&err];
+            if(err != nil)
             {
-                buffer = malloc(asset.size);
-                [asset getBytes:buffer fromOffset:0 length:asset.size error:&err];
-                if(err != nil)
-                {
-                    reject(@"RNFetchBlobFS readFile error", @"failed to read asset", [err localizedDescription]);
-                    return;
-                }
-                fileContent = [NSData dataWithBytes:buffer length:asset.size];
+                onComplete(nil, [err description]);
                 free(buffer);
+                return;
             }
-            else
-            {
-                if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
-
-                    reject(@"RNFetchBlobFS readFile error", @"file not exists", nil);
-                    return;
-                }
-                fileContent = [NSData dataWithContentsOfFile:path];
-
+            fileContent = [NSData dataWithBytes:buffer length:asset.size];
+            free(buffer);
+        }
+        else
+        {
+            if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+                onComplete(nil, @"file not exists");
+                return;
             }
-            if(onComplete != nil)
-                onComplete(fileContent);
-
-            if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
-                if(resolve != nil) {
-                    NSString * utf8 = [[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding];
-                    if(utf8 == nil)
-                        resolve([[NSString alloc] initWithData:fileContent encoding:NSISOLatin1StringEncoding]);
-                    else
-                        resolve(utf8);
-                }
+            fileContent = [NSData dataWithContentsOfFile:path];
+            
+        }
+        
+        if(encoding != nil)
+        {
+            if([[encoding lowercaseString] isEqualToString:@"utf8"])
+            {
+                NSString * utf8 = [[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding];
+                if(utf8 == nil)
+                    onComplete([[NSString alloc] initWithData:fileContent encoding:NSISOLatin1StringEncoding], nil);
+                else
+                    onComplete(utf8, nil);
             }
             else if ([[encoding lowercaseString] isEqualToString:@"base64"]) {
-                if(resolve != nil)
-                    resolve([fileContent base64EncodedStringWithOptions:0]);
+                onComplete([fileContent base64EncodedStringWithOptions:0], nil);
             }
             else if ([[encoding lowercaseString] isEqualToString:@"ascii"]) {
                 NSMutableArray * resultArray = [NSMutableArray array];
                 for(int i=0;i<[fileContent length];i++) {
                     [resultArray addObject:[NSNumber numberWithChar:bytes[i]]];
                 }
-                if(resolve != nil)
-                    resolve(resultArray);
+                onComplete(resultArray, nil);
             }
-        }];
-    }
-    @catch(NSException * e)
-    {
-        if(reject != nil)
-            reject(@"RNFetchBlobFS readFile error", @"error", [e description]);
-    }
+        }
+        else
+        {
+            onComplete(fileContent, nil);
+        }
+        
+    }];
 }
 
+
 # pragma mark - mkdir
 
 + (BOOL) mkdir:(NSString *) path {
              @"size" : size,
              @"filename" : filename,
              @"path" : path,
-             @"lastModified" : [NSString stringWithFormat:@"%@", [NSNumber numberWithLong:(time_t) [lastModified timeIntervalSince1970]*1000]],
+             @"lastModified" : [NSNumber numberWithLong:(time_t) [lastModified timeIntervalSince1970]*1000],
              @"type" : isDir ? @"directory" : @"file"
             };
 
 
 +(void) df:(RCTResponseSenderBlock)callback
 {
-    uint64_t totalSpace = 0;
-    uint64_t totalFreeSpace = 0;
     NSError *error = nil;
     NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
     NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error: &error];
     if (dictionary) {
         NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];
         NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
-        totalSpace = [fileSystemSizeInBytes unsignedLongLongValue];
-        totalFreeSpace = [freeFileSystemSizeInBytes unsignedLongLongValue];
+        
         callback(@[[NSNull null], @{
-                  @"free" : [NSString stringWithFormat:@"%d", totalFreeSpace],
-                  @"total" : [NSString stringWithFormat:@"%d", totalSpace]
+                  @"free" : freeFileSystemSizeInBytes,
+                  @"total" : fileSystemSizeInBytes,
                 }]);
     } else {
         callback(@[@"failed to get storage usage."]);

ios/RNFetchBlobNetwork.h

 
 typedef void(^CompletionHander)(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error);
 typedef void(^DataTaskCompletionHander) (NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error);
-typedef NS_ENUM(NSUInteger, ResponseFormat) {
-    UTF8,
-    BASE64,
-    AUTO
-};
 
 @interface RNFetchBlobNetwork : NSObject  <NSURLSessionDelegate, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 
 @property (strong, nonatomic) CompletionHander fileTaskCompletionHandler;
 @property (strong, nonatomic) DataTaskCompletionHander dataTaskCompletionHandler;
 @property (nullable, nonatomic) NSError * error;
-@property (nullable, nonatomic) NSMutableArray * redirects;
-
-@property (nonatomic) BOOL respFile;
-@property (nonatomic) BOOL isNewPart;
-@property (nonatomic) BOOL isIncrement;
-@property (nullable, nonatomic) NSMutableData * partBuffer;
-@property (nullable, nonatomic) NSString * destPath;
-@property (nullable, nonatomic) NSOutputStream * writeStream;
-@property (nonatomic) long bodyLength;
-@property (nullable, nonatomic) NSMutableDictionary * respInfo;
-@property (nonatomic) NSInteger respStatus;
-@property (nonatomic) ResponseFormat responseFormat;
-@property ( nonatomic) BOOL followRedirect;
 
 
 + (NSMutableDictionary  * _Nullable ) normalizeHeaders:(NSDictionary * _Nullable)headers;

ios/RNFetchBlobNetwork.m

 }
 
 
+typedef NS_ENUM(NSUInteger, ResponseFormat) {
+    UTF8,
+    BASE64,
+    AUTO
+};
+
+
+@interface RNFetchBlobNetwork ()
+{
+    BOOL * respFile;
+    BOOL isNewPart;
+    BOOL * isIncrement;
+    NSMutableData * partBuffer;
+    NSString * destPath;
+    NSOutputStream * writeStream;
+    long bodyLength;
+    NSMutableDictionary * respInfo;
+    NSInteger respStatus;
+    NSMutableArray * redirects;
+    ResponseFormat responseFormat;
+    BOOL * followRedirect;
+}
+
+@end
 
 @implementation RNFetchBlobNetwork
 
 @synthesize callback;
 @synthesize bridge;
 @synthesize options;
-@synthesize redirects;
 @synthesize fileTaskCompletionHandler;
 @synthesize dataTaskCompletionHandler;
 @synthesize error;
 
-@synthesize respFile;
-@synthesize isNewPart;
-@synthesize isIncrement;
-@synthesize partBuffer;
-@synthesize destPath;
-@synthesize writeStream;
-@synthesize bodyLength;
-@synthesize respInfo;
-@synthesize respStatus;
-@synthesize responseFormat;
-@synthesize followRedirect;
-
 
 // constructor
 - (id)init {
     UIBackgroundTaskIdentifier tid = [app beginBackgroundTaskWithName:taskId expirationHandler:^{
         NSLog([NSString stringWithFormat:@"session %@ expired", taskId ]);
         [expirationTable setObject:task forKey:taskId];
-        [app endBackgroundTask:tid];
+        // comment out this one as it might cause app crash #271
+//        [app endBackgroundTask:tid];
     }];
 
 }

ios/RNFetchBlobReqBuilder.m

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         __block NSMutableData * postData = [[NSMutableData alloc] init];
         // combine multipart/form-data body
-        [[self class] buildFormBody:form boundary:boundary onComplete:^(NSData *formData) {
-            if(formData != nil) {
-                [postData appendData:formData];
-                // close form data
-                [postData appendData: [[NSString stringWithFormat:@"--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-                [request setHTTPBody:postData];
+        [[self class] buildFormBody:form boundary:boundary onComplete:^(NSData *formData, BOOL hasError) {
+            if(hasError)
+            {
+                onComplete(nil, nil);
+            }
+            else
+            {
+                if(formData != nil)
+                {
+                    [postData appendData:formData];
+                    // close form data
+                    [postData appendData: [[NSString stringWithFormat:@"--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
+                    [request setHTTPBody:postData];
+                }
+                // set content-length
+                [mheaders setValue:[NSString stringWithFormat:@"%lu",[postData length]] forKey:@"Content-Length"];
+                [mheaders setValue:@"100-continue" forKey:@"Expect"];
+                // appaned boundary to content-type
+                [mheaders setValue:[NSString stringWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", boundary] forKey:@"content-type"];
+                [request setHTTPMethod: method];
+                [request setAllHTTPHeaderFields:mheaders];
+                onComplete(request, [formData length]);
             }
-            // set content-length
-            [mheaders setValue:[NSString stringWithFormat:@"%lu",[postData length]] forKey:@"Content-Length"];
-            [mheaders setValue:@"100-continue" forKey:@"Expect"];
-            // appaned boundary to content-type
-            [mheaders setValue:[NSString stringWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", boundary] forKey:@"content-type"];
-            [request setHTTPMethod: method];
-            [request setAllHTTPHeaderFields:mheaders];
-            onComplete(request, [formData length]);
         }];
 
     });
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         NSMutableData * blobData;
         long size = -1;
-        // if method is POST or PUT, convert data string format
-        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
+        // if method is POST, PUT or PATCH, convert data string format
+        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"] || [[method lowercaseString] isEqualToString:@"patch"]) {
             // generate octet-stream body
             if(body != nil) {
                 __block NSString * cType = [[self class] getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                     orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
                     if([orgPath hasPrefix:AL_PREFIX])
                     {
-                        [RNFetchBlobFS readFile:orgPath encoding:@"utf8" resolver:nil rejecter:nil onComplete:^(NSData *content) {
-                            [request setHTTPBody:content];
-                            [request setHTTPMethod: method];
-                            [request setAllHTTPHeaderFields:mheaders];
-                            onComplete(request, [content length]);
+                        
+                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString * err) {
+                            if(err != nil)
+                            {
+                                onComplete(nil, nil);
+                            }
+                            else
+                            {
+                                [request setHTTPBody:content];
+                                [request setHTTPMethod: method];
+                                [request setAllHTTPHeaderFields:mheaders];
+                                onComplete(request, [content length]);
+                            }
                         }];
+                        
                         return;
                     }
                     size = [[[NSFileManager defaultManager] attributesOfItemAtPath:orgPath error:nil] fileSize];
     });
 }
 
-+(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData))onComplete
++(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData, BOOL hasError))onComplete
 {
     __block NSMutableData * formData = [[NSMutableData alloc] init];
     if(form == nil)
-        onComplete(nil);
+        onComplete(nil, NO);
     else
     {
         __block int i = 0;
                     {
                         NSString * orgPath = [content substringFromIndex:[FILE_PREFIX length]];
                         orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
-                        [RNFetchBlobFS readFile:orgPath encoding:@"utf8" resolver:nil rejecter:nil onComplete:^(NSData *content) {
+
+                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString * err) {
+                            if(err != nil)
+                            {
+                                onComplete(formData, YES);
+                                return;
+                            }
                             NSString * filename = [field valueForKey:@"filename"];
                             [formData appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
                             [formData appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"; filename=\"%@\"\r\n", name, filename] dataUsingEncoding:NSUTF8StringEncoding]];
                             }
                             else
                             {
-                                onComplete(formData);
+                                onComplete(formData, NO);
                                 getFieldData = nil;
                             }
                         }];
             }
             else
             {
-                onComplete(formData);
+                onComplete(formData, NO);
                 getFieldData = nil;
             }
 

package.json

 {
   "name": "react-native-fetch-blob",
-  "version": "0.10.3-beta.1",
+  "version": "0.10.4",
   "description": "A module provides upload, download, and files access API. Supports file stream read/write for process large files.",
   "main": "index.js",
   "scripts": {
     "smartt <github@eriksmartt.com>",
     ""
   ]
-}
+}

polyfill/Blob.js

           formArray.push('\r\n--'+boundary+'\r\n')
           let part = parts[i]
           for(let j in part.headers) {
-            formArray.push(j + ': ' +part.headers[j] + ';\r\n')
+            formArray.push(j + ': ' +part.headers[j] + '\r\n')
           }
           formArray.push('\r\n')
           if(part.isRNFetchBlobPolyfill)

polyfill/Fetch.js

       options.headers['Content-Type'] = ctype || ctypeH
       options.headers['content-type'] = ctype || ctypeH
       options.method = options.method || 'GET'
-
       if(body) {
         // When the request body is an instance of FormData, create a Blob cache
         // to upload the body.
         else
           promise = Promise.resolve(body)
       }
-
       // task is a progress reportable and cancellable Promise, however,
       // task.then is not, so we have to extend task.then with progress and
       // cancel function