Merge branch 'master' into 0.7.0

README.md

-# react-native-fetch-blob [![npm](https://img.shields.io/npm/v/react-native-fetch-blob.svg?style=flat-square)](https://www.npmjs.com/package/react-native-fetch-blob) ![](https://img.shields.io/badge/PR-Welcome-brightgreen.svg?style=flat-square) [![npm](https://img.shields.io/npm/l/express.svg?maxAge=2592000&style=flat-square)]() [![npm](https://img.shields.io/badge/inProgress-0.7.0-yellow.svg?style=flat-square)]()
+# react-native-fetch-blob [![npm](https://img.shields.io/npm/v/react-native-fetch-blob.svg?style=flat-square)](https://www.npmjs.com/package/react-native-fetch-blob) ![](https://img.shields.io/badge/PR-Welcome-brightgreen.svg?style=flat-square) [![npm](https://img.shields.io/npm/l/express.svg?maxAge=2592000&style=flat-square)]() [![npm](https://img.shields.io/badge/inProgress-0.7.0-yellow.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/milestones)
 
 A module provides upload, download, and files access API. Supports file stream read/write for process large files.
 
 **Why do we need this**
 
-React Native does not support `Blob` object at this moment, which means if you're going to send/receive binary data via `fetch` API, that might not work as you expect. See [[fetch] Does fetch with blob() marshal data across the bridge?](https://github.com/facebook/react-native/issues/854).
+React Native does not support `Blob` object at this moment, which means if you're going to send/receive binary data via `fetch` API, that might not work as you expect. See [facebook/react-native#854](https://github.com/facebook/react-native/issues/854).
 
 For some use cases, you might get into trouble. For example, displaying an image that requires a specific field in headers (ex. "Authorization : Bearer ...") or body, so you can't just pass the image uri to `Image` component because that will probably returns a 401 response. Or you're going to upload binary data which generated from JS, the server will get an empry body due to [this issue](https://github.com/facebook/react-native/issues/854). With help of APIs provided by this module, you can send HTTP request with any headers, and decide how to handle the response/reqeust data without worry about if it is not supported by `fetch` API. The response data can be just simply converted into BASE64 string, or stored to a file directly so that you can read it by using file access APIs such as readFile, readStream.
 
 This module was designed to be a substitution of `Blob`, there's a set of APIs including basic file system CRUD method, and file stream reader/writer. Also it has a special `fetch` implementation that supports binary request/response body.
 
-**Pre v0.5.0 Users**
+**Backward Compatible**
 
-All updates are `backward-compatible` generally you don't have to change existing code unless you're going to use new APIs. In latest version (v0.5.0), new APIs can either `upload` or `download` files simply using a file path. It's much more memory efficent in some use case. We've also introduced `fs` APIs for access files, and `file stream` API that helps you read/write files (especially for **large ones**), see [Examples](#user-content-usage) bellow. This module implements native methods, supports both Android (uses awesome native library  [AsyncHttpClient](https://github.com/AsyncHttpClient/async-http-client])) and IOS.
+All updates are `backward-compatible` generally you don't have to change existing code unless you're going to use new APIs. But we recommend pre `0.5.0` users consider upgrade the package to latest version, since we have introduced new APIs can either `upload` or `download` files simply using a file path. It's much more memory efficent in some use case. We've also introduced `fs` APIs for access files, and `file stream` API that helps you read/write files (especially for **large ones**), see [Examples](#user-content-recipes) bellow. This module implements native methods, supports both Android (uses awesome native library  [AsyncHttpClient](https://github.com/AsyncHttpClient/async-http-client])) and IOS.
 
 ## TOC
 
 * [Installation](#user-content-installation)
-* [Guide](#user-content-guide)
+* [Recipes](#user-content-recipes)
  * [Download file](#user-content-download-example--fetch-files-that-needs-authorization-token)
  * [Upload file](#user-content-upload-example--dropbox-files-upload-api)
  * [Multipart/form upload](#user-content-multipartform-data-example--post-form-data-with-file-and-data)
 
 Beginning in Android 6.0 (API level 23), users grant permissions to apps while the app is running, not when they install the app. So adding permissions in `AndroidManifest.xml` won't work in Android 6.0 devices. To grant permissions in runtime, you might use modules like [react-native-android-permissions](https://github.com/lucasferreira/react-native-android-permissions).
 
-## Guide
+## Recipes
 
 ```js
 import RNFetchBlob from 'react-native-fetch-blob'
   })
 ```
 
-What if you want to upload a file in some field ? Just like [upload a file from storage](#user-content-upload-a-file-from-storage) example, wrap `data` by `wrap` API (this feature is only available for `version >= v0.5.0`)
+What if you want to upload a file in some field ? Just like [upload a file from storage](#user-content-upload-a-file-from-storage) example, wrap `data` by `wrap` API (this feature is only available for `version >= v0.5.0`). On version >= `0.6.2`, it is possible to set custom MIME type when appending file to form data.
 
 ```js
 
       // Or simply wrap the file path with RNFetchBlob.wrap().
       data: RNFetchBlob.wrap(PATH_TO_THE_FILE)
     },
+    {
+      name : 'ringtone',
+      filename : 'ring.mp3',
+      // use custom MIME type
+      type : 'application/mp3',
+      // upload a file from asset is also possible in version >= 0.6.2
+      data : RNFetchBlob.wrap(RNFetchBlob.fs.asset('default-ringtone.mp3'))
+    }
     // elements without property `filename` will be sent as plain text
     { name : 'name', data : 'user'},
     { name : 'info', data : JSON.stringify({
 
 #### Upload/Download progress
 
-In `version >= 0.4.2` it is possible to know the upload/download progress.
+In `version >= 0.4.2` it is possible to know the upload/download progress. On Anroid, only download progress is supported. See [wiki](https://github.com/wkh237/react-native-fetch-blob/wiki/Fetch-API#fetchprogresseventlistenerpromisernfetchblobresponse) for more information.
 
 ```js
   RNFetchBlob.fetch('POST', 'http://www.example.com/upload', {
 
 #### File Access
 
-File access APIs were made when developing `v0.5.0`, which helping us write tests, and was not planned to be a part of this module. However I realized that, it's hard to find a great solution to manage cached files, every one who use this moudle may need those APIs for there cases.
+File access APIs were made when developing `v0.5.0`, which helping us write tests, and was not planned to be a part of this module. However we realized that, it's hard to find a great solution to manage cached files, every one who use this moudle may need these APIs for there cases.
 
-File Access APIs
+Before get started using file APIs we recommend read [Differences between File Source](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#differences-between-file-source) first.
 
+File Access APIs
+- [asset (0.6.2)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#assetfilenamestringstring)
 - [dirs](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#dirs)
 - [createFile](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#createfilepath-data-encodingpromise)
 - [writeFile (0.6.0)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#writefilepathstring-contentstring--array-encodingstring-appendbooleanpromise)
 
 ```js
 let data = ''
-RNFetchBlob.readStream(
+RNFetchBlob.fs.readStream(
     // encoding, should be one of `base64`, `utf8`, `ascii`
     'base64',
     // file path
 When use `writeStream`, the stream is also opened immediately, but you have to `write`, and `close` by yourself.
 
 ```js
-RNFetchBlob.writeStream(
+RNFetchBlob.fs.writeStream(
     PATH_TO_FILE,
     // encoding, should be one of `base64`, `utf8`, `ascii`
     'utf8',
 
 | Version | |
 |---|---|
+| 0.6.2 | Add support of asset file and camera roll files, Support custom MIME type when sending multipart request, thanks @smartt |
 | 0.6.1 | Fix #37 progress report API issue on IOS |
 | 0.6.0 | Add readFile and writeFile API for easier file access, also added Android download manager support. |
 | 0.5.8 | Fix #33 PUT request will always be sent as POST on Android |

package.json

 {
   "name": "fetchblob",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "private": true,
   "scripts": {
     "start": "node node_modules/react-native/local-cli/cli.js start",

src/README.md

-# react-native-fetch-blob [![npm](https://img.shields.io/npm/v/react-native-fetch-blob.svg?style=flat-square)](https://www.npmjs.com/package/react-native-fetch-blob) ![](https://img.shields.io/badge/PR-Welcome-brightgreen.svg?style=flat-square) [![npm](https://img.shields.io/npm/l/express.svg?maxAge=2592000&style=flat-square)]()
+# react-native-fetch-blob [![npm](https://img.shields.io/npm/v/react-native-fetch-blob.svg?style=flat-square)](https://www.npmjs.com/package/react-native-fetch-blob) ![](https://img.shields.io/badge/PR-Welcome-brightgreen.svg?style=flat-square) [![npm](https://img.shields.io/npm/l/express.svg?maxAge=2592000&style=flat-square)]() [![npm](https://img.shields.io/badge/inProgress-0.7.0-yellow.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/milestones)
 
 A module provides upload, download, and files access API. Supports file stream read/write for process large files.
 
+## [Please check our github for updated document](https://github.com/wkh237/react-native-fetch-blob)
+
 **Why do we need this**
 
-React Native does not support `Blob` object at this moment, which means if you're going to send/receive binary data via `fetch` API, that might not work as you expect. See [[fetch] Does fetch with blob() marshal data across the bridge?](https://github.com/facebook/react-native/issues/854).
+React Native does not support `Blob` object at this moment, which means if you're going to send/receive binary data via `fetch` API, that might not work as you expect. See [facebook/react-native#854](https://github.com/facebook/react-native/issues/854).
 
 For some use cases, you might get into trouble. For example, displaying an image that requires a specific field in headers (ex. "Authorization : Bearer ...") or body, so you can't just pass the image uri to `Image` component because that will probably returns a 401 response. Or you're going to upload binary data which generated from JS, the server will get an empry body due to [this issue](https://github.com/facebook/react-native/issues/854). With help of APIs provided by this module, you can send HTTP request with any headers, and decide how to handle the response/reqeust data without worry about if it is not supported by `fetch` API. The response data can be just simply converted into BASE64 string, or stored to a file directly so that you can read it by using file access APIs such as readFile, readStream.
 
 This module was designed to be a substitution of `Blob`, there's a set of APIs including basic file system CRUD method, and file stream reader/writer. Also it has a special `fetch` implementation that supports binary request/response body.
 
-**Pre v0.5.0 Users**
+**Backward Compatible**
 
-All updates are `backward-compatible` generally you don't have to change existing code unless you're going to use new APIs. In latest version (v0.5.0), new APIs can either `upload` or `download` files simply using a file path. It's much more memory efficent in some use case. We've also introduced `fs` APIs for access files, and `file stream` API that helps you read/write files (especially for **large ones**), see [Examples](#user-content-usage) bellow. This module implements native methods, supports both Android (uses awesome native library  [AsyncHttpClient](https://github.com/AsyncHttpClient/async-http-client])) and IOS.
+All updates are `backward-compatible` generally you don't have to change existing code unless you're going to use new APIs. But we recommend pre `0.5.0` users consider upgrade the package to latest version, since we have introduced new APIs can either `upload` or `download` files simply using a file path. It's much more memory efficent in some use case. We've also introduced `fs` APIs for access files, and `file stream` API that helps you read/write files (especially for **large ones**), see [Examples](#user-content-recipes) bellow. This module implements native methods, supports both Android (uses awesome native library  [AsyncHttpClient](https://github.com/AsyncHttpClient/async-http-client])) and IOS.
 
 ## TOC
 
 * [Installation](#user-content-installation)
-* [Guide](#user-content-guide)
+* [Recipes](#user-content-recipes)
  * [Download file](#user-content-download-example--fetch-files-that-needs-authorization-token)
  * [Upload file](#user-content-upload-example--dropbox-files-upload-api)
  * [Multipart/form upload](#user-content-multipartform-data-example--post-form-data-with-file-and-data)
 
 Beginning in Android 6.0 (API level 23), users grant permissions to apps while the app is running, not when they install the app. So adding permissions in `AndroidManifest.xml` won't work in Android 6.0 devices. To grant permissions in runtime, you might use modules like [react-native-android-permissions](https://github.com/lucasferreira/react-native-android-permissions).
 
-## Guide
+## Recipes
 
 ```js
 import RNFetchBlob from 'react-native-fetch-blob'
   })
 ```
 
-What if you want to upload a file in some field ? Just like [upload a file from storage](#user-content-upload-a-file-from-storage) example, wrap `data` by `wrap` API (this feature is only available for `version >= v0.5.0`)
+What if you want to upload a file in some field ? Just like [upload a file from storage](#user-content-upload-a-file-from-storage) example, wrap `data` by `wrap` API (this feature is only available for `version >= v0.5.0`). On version >= `0.6.2`, it is possible to set custom MIME type when appending file to form data.
 
 ```js
 
       // Or simply wrap the file path with RNFetchBlob.wrap().
       data: RNFetchBlob.wrap(PATH_TO_THE_FILE)
     },
+    {
+      name : 'ringtone',
+      filename : 'ring.mp3',
+      // use custom MIME type
+      type : 'application/mp3',
+      // upload a file from asset is also possible in version >= 0.6.2
+      data : RNFetchBlob.wrap(RNFetchBlob.fs.asset('default-ringtone.mp3'))
+    }
     // elements without property `filename` will be sent as plain text
     { name : 'name', data : 'user'},
     { name : 'info', data : JSON.stringify({
 
 #### Upload/Download progress
 
-In `version >= 0.4.2` it is possible to know the upload/download progress.
+In `version >= 0.4.2` it is possible to know the upload/download progress. On Anroid, only download progress is supported. See [wiki](https://github.com/wkh237/react-native-fetch-blob/wiki/Fetch-API#fetchprogresseventlistenerpromisernfetchblobresponse) for more information.
 
 ```js
   RNFetchBlob.fetch('POST', 'http://www.example.com/upload', {
 
 #### File Access
 
-File access APIs were made when developing `v0.5.0`, which helping us write tests, and was not planned to be a part of this module. However I realized that, it's hard to find a great solution to manage cached files, every one who use this moudle may need those APIs for there cases.
+File access APIs were made when developing `v0.5.0`, which helping us write tests, and was not planned to be a part of this module. However we realized that, it's hard to find a great solution to manage cached files, every one who use this moudle may need these APIs for there cases.
 
-File Access APIs
+Before get started using file APIs we recommend read [Differences between File Source](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#differences-between-file-source) first.
 
+File Access APIs
+- [asset (0.6.2)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#assetfilenamestringstring)
 - [dirs](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#dirs)
 - [createFile](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#createfilepath-data-encodingpromise)
 - [writeFile (0.6.0)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#writefilepathstring-contentstring--array-encodingstring-appendbooleanpromise)
 
 ```js
 let data = ''
-RNFetchBlob.readStream(
+RNFetchBlob.fs.readStream(
     // encoding, should be one of `base64`, `utf8`, `ascii`
     'base64',
     // file path
 When use `writeStream`, the stream is also opened immediately, but you have to `write`, and `close` by yourself.
 
 ```js
-RNFetchBlob.writeStream(
+RNFetchBlob.fs.writeStream(
     PATH_TO_FILE,
     // encoding, should be one of `base64`, `utf8`, `ascii`
     'utf8',
 
 | Version | |
 |---|---|
+| 0.6.2 | Add support of asset file and camera roll files, Support custom MIME type when sending multipart request, thanks @smartt |
 | 0.6.1 | Fix #37 progress report API issue on IOS |
 | 0.6.0 | Add readFile and writeFile API for easier file access, also added Android download manager support. |
 | 0.5.8 | Fix #33 PUT request will always be sent as POST on Android |

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

 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
     String filePathPrefix = "RNFetchBlob-file://";
+    static ReactApplicationContext RCTContext;
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
+
         super(reactContext);
+        RCTContext = reactContext;
     }
 
     @Override

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

 package com.RNFetchBlob;
 
+import android.app.Application;
+import android.content.CursorLoader;
 import android.content.Intent;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.AssetManager;
+import android.database.Cursor;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Environment;
+import android.provider.MediaStore;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
     ReactApplicationContext mCtx;
     DeviceEventManagerModule.RCTDeviceEventEmitter emitter;
     String encoding = "base64";
+    static final String assetPrefix = "bundle-assets://";
     boolean append = false;
     OutputStream writeStreamInstance = null;
     static HashMap<String, RNFetchBlobFS> fileStreams = new HashMap<>();
      * @param promise
      */
     static public void readFile(String path, String encoding, final Promise promise ) {
+        path = normalizePath(path);
         AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
             @Override
             protected Integer doInBackground(String... strings) {
                 try {
                     String path = strings[0];
                     String encoding = strings[1];
-                    File f = new File(path);
-                    int length = (int) f.length();
-                    byte[] bytes = new byte[length];
-                    FileInputStream in = new FileInputStream(f);
-                    in.read(bytes);
-                    in.close();
+                    byte[] bytes;
+
+                    if(path.startsWith(assetPrefix)) {
+                        String assetName = path.replace(assetPrefix, "");
+                        long length = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
+                        bytes = new byte[(int) length];
+                        InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
+                        in.read(bytes, 0, (int) length);
+                        in.close();
+                    }
+                    else {
+                        File f = new File(path);
+                        int length = (int) f.length();
+                        bytes = new byte[length];
+                        FileInputStream in = new FileInputStream(f);
+                        in.read(bytes);
+                        in.close();
+                    }
+
                     switch (encoding.toLowerCase()) {
                         case "base64" :
                             promise.resolve(Base64.encodeToString(bytes, 0));
      * @param bufferSize    Buffer size of read stream, default to 4096 (4095 when encode is `base64`)
      */
     public void readStream( String path, String encoding, int bufferSize) {
+        path = normalizePath(path);
         AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
             @Override
             protected Integer doInBackground(String ... args) {
                     int chunkSize = encoding.equalsIgnoreCase("base64") ? 4095 : 4096;
                     if(bufferSize > 0)
                         chunkSize = bufferSize;
-                    FileInputStream fs = new FileInputStream(new File(path));
+
+                    InputStream fs;
+                    if(path.startsWith(assetPrefix)) {
+                        fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(assetPrefix, ""));
+                    }
+                    else {
+                        fs = new FileInputStream(new File(path));
+                    }
+
                     byte[] buffer = new byte[chunkSize];
                     int cursor = 0;
                     boolean error = false;
         try {
             stream.write(chunk);
             callback.invoke();
-            chunk = null;
         } catch (Exception e) {
             callback.invoke(e.getLocalizedMessage());
         }
     }
 
     /**
-     * Close file stream by ID
+     * Close file write stream by ID
      * @param streamId Stream ID
      * @param callback JS context callback
      */
      * @param callback  JS context callback
      */
     static void cp(String path, String dest, Callback callback) {
+        path = normalizePath(path);
         InputStream in = null;
         OutputStream out = null;
 
         try {
 
-            String destFolder = new File(dest).getPath();
-            if(!new File(path).exists()) {
+            if(!isPathExists(path)) {
                 callback.invoke("cp error: source file at path`" + path + "` not exists");
                 return;
             }
             if(!new File(dest).exists())
                 new File(dest).createNewFile();
 
-            in = new FileInputStream(path);
+            in = inputStreamFromPath(path);
             out = new FileOutputStream(dest);
 
             byte[] buf = new byte[1024];
      * @param callback  JS context callback
      */
     static void exists(String path, Callback callback) {
-        boolean exist = new File(path).exists();
-        boolean isDir = new File(path).isDirectory();;
-        callback.invoke(exist, isDir);
+        path = normalizePath(path);
+        if(isAsset(path)) {
+            try {
+                String filename = path.replace(assetPrefix, "");
+                AssetFileDescriptor fd = RNFetchBlob.RCTContext.getAssets().openFd(filename);
+                callback.invoke(true, false);
+            } catch (IOException e) {
+                callback.invoke(false, false);
+            }
+        }
+        else {
+            boolean exist = new File(path).exists();
+            boolean isDir = new File(path).isDirectory();
+            callback.invoke(exist, isDir);
+        }
+
     }
 
     /**
      * @param callback  JS context callback
      */
     static void ls(String path, Callback callback) {
+        path = normalizePath(path);
         File src = new File(path);
-        if(!src.exists() || !src.isDirectory()) {
+        if (!src.exists() || !src.isDirectory()) {
             callback.invoke("ls error: failed to list path `" + path + "` for it is not exist or it is not a folder");
             return;
         }
-        String [] files = new File(path).list();
+        String[] files = new File(path).list();
         WritableArray arg = Arguments.createArray();
-        for(String i : files) {
+        for (String i : files) {
             arg.pushString(i);
         }
         callback.invoke(null, arg);
     }
 
     static void lstat(String path, final Callback callback) {
-        File src = new File(path);
+        path = normalizePath(path);
+
         new AsyncTask<String, Integer, Integer>() {
             @Override
             protected Integer doInBackground(String ...args) {
      */
     static void stat(String path, Callback callback) {
         try {
-            File target = new File(path);
-            if (!target.exists()) {
-                callback.invoke("stat error: file " + path + " does not exists");
-                return;
-            }
-            WritableMap stat = Arguments.createMap();
-            stat.putString("filename", target.getName());
-            stat.putString("path", target.getPath());
-            stat.putString("type", target.isDirectory() ? "directory" : "file");
-            stat.putString("size", String.valueOf(target.length()));
-            String lastModified = String.valueOf(target.lastModified());
-            stat.putString("lastModified", lastModified);
-            callback.invoke(null, stat);
+            WritableMap result = statFile(path);
+            if(result == null)
+                callback.invoke("stat error: failed to list path `" + path + "` for it is not exist or it is not a folder", null);
+            else
+                callback.invoke(null, result);
         } catch(Exception err) {
             callback.invoke(err.getLocalizedMessage());
         }
     }
 
+    /**
+     * Basic stat method
+     * @param path
+     * @return Stat result of a file or path
+     */
+    static WritableMap statFile(String path) {
+        try {
+            path = normalizePath(path);
+            WritableMap stat = Arguments.createMap();
+            if(isAsset(path)) {
+                String name = path.replace(assetPrefix, "");
+                AssetFileDescriptor fd = RNFetchBlob.RCTContext.getAssets().openFd(name);
+                stat.putString("filename", name);
+                stat.putString("path", path);
+                stat.putString("type", "asset");
+                stat.putString("size", String.valueOf(fd.getLength()));
+                stat.putString("lastModified", "0");
+            }
+            else {
+                File target = new File(path);
+                if (!target.exists()) {
+                    return null;
+                }
+                stat.putString("filename", target.getName());
+                stat.putString("path", target.getPath());
+                stat.putString("type", target.isDirectory() ? "directory" : "file");
+                stat.putString("size", String.valueOf(target.length()));
+                String lastModified = String.valueOf(target.lastModified());
+                stat.putString("lastModified", lastModified);
+
+            }
+            return stat;
+        } catch(Exception err) {
+            return null;
+        }
+    }
+
+    /**
+     * Media scanner scan file
+     * @param path
+     * @param mimes
+     * @param callback
+     */
     void scanFile(String [] path, String[] mimes, final Callback callback) {
         try {
             MediaScannerConnection.scanFile(mCtx, path, mimes, new MediaScannerConnection.OnScanCompletedListener() {
         this.emitter.emit("RNFetchBlobStream" + taskId, eventData);
     }
 
-    static WritableMap statFile(String path) {
-        File target = new File(path);
-        if(!target.exists()) {
-            return null;
+    /**
+     * Get input stream of the given path, when the path is a string starts with bundle-assets://
+     * the stream is created by Assets Manager, otherwise use FileInputStream.
+     * @param path
+     * @return
+     * @throws IOException
+     */
+    static InputStream inputStreamFromPath(String path) throws IOException {
+        if (path.startsWith(assetPrefix)) {
+            return RNFetchBlob.RCTContext.getAssets().open(path.replace(assetPrefix, ""));
+        }
+        return new FileInputStream(new File(path));
+    }
+
+    /**
+     * Check if the asset or the file exists
+     * @param path
+     * @return
+     */
+    static boolean isPathExists(String path) {
+        if(path.startsWith(assetPrefix)) {
+            try {
+                RNFetchBlob.RCTContext.getAssets().open(path.replace(assetPrefix, ""));
+            } catch (IOException e) {
+                return false;
+            }
+            return true;
+        }
+        else {
+            return new File(path).exists();
+        }
+
+    }
+
+    static boolean isAsset(String path) {
+        return path.startsWith(assetPrefix);
+    }
+
+    static String normalizePath(String path) {
+        if(path.startsWith(assetPrefix)) {
+            return path;
+        }
+        else if (path.startsWith("content://")) {
+            String[] proj = { MediaStore.Images.Media.DATA };
+            Uri contentUri = Uri.parse(path);
+            CursorLoader loader = new CursorLoader(RNFetchBlob.RCTContext, contentUri, proj, null, null, null);
+            Cursor cursor = loader.loadInBackground();
+            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
+            cursor.moveToFirst();
+            String result = cursor.getString(column_index);
+            cursor.close();
+            return result;
         }
-        WritableMap stat = Arguments.createMap();
-        stat.putString("filename", target.getName());
-        stat.putString("path", target.getPath());
-        stat.putString("type", target.isDirectory() ? "directory" : "file");
-        stat.putInt("size", (int)target.length());
-        stat.putInt("lastModified", (int)target.lastModified());
-        return stat;
+        return path;
     }
 
 }

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

 import com.loopj.android.http.MySSLSocketFactory;
 
 import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.security.KeyStore;
 
 import cz.msebera.android.httpclient.HttpEntity;
 
             req = new AsyncHttpClient();
 
+            req.setLoggingEnabled(false);
+
             // use trusty SSL socket
             if(this.options.trusty) {
                 KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
                 String data = map.getString("data");
                 // file field
                 if(map.hasKey("filename")) {
+                    String mime = map.hasKey("type") ? map.getString("type") : ContentType.APPLICATION_OCTET_STREAM.getMimeType();
                     String filename = map.getString("filename");
                     // upload from storage
                     if(data.startsWith(filePathPrefix)) {
-                        File file = new File(data.substring(filePathPrefix.length()));
-                        form.addBinaryBody(name, file, ContentType.APPLICATION_OCTET_STREAM, filename);
+                        String orgPath = data.substring(filePathPrefix.length());
+                        orgPath = RNFetchBlobFS.normalizePath(orgPath);
+                        // path starts with content://
+                        if(RNFetchBlobFS.isAsset(orgPath)) {
+                            try {
+                                String assetName = orgPath.replace(RNFetchBlobFS.assetPrefix, "");
+                                InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
+                                long length = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
+                                byte [] bytes = new byte[(int) length];
+                                in.read(bytes, 0, (int) length);
+                                in.close();
+                                form.addBinaryBody(name, bytes, ContentType.create(mime), filename);
+                            } catch (IOException e) {
+//                                e.printStackTrace();
+                            }
+                        }
+                        else {
+                            File file = new File(RNFetchBlobFS.normalizePath(orgPath));
+                            form.addBinaryBody(name, file, ContentType.create(mime), filename);
+                        }
                     }
                     // base64 embedded file content
                     else {
-                        form.addBinaryBody(name, Base64.decode(data, 0), ContentType.APPLICATION_OCTET_STREAM, filename);
+                        form.addBinaryBody(name, Base64.decode(data, 0), ContentType.create(mime), filename);
                     }
                 }
                 // data field
             byte [] blob;
             // upload from storage
             if(body.startsWith(filePathPrefix)) {
-                String filePath = body.substring(filePathPrefix.length());
-                entity = new FileEntity(new File(filePath));
+                String orgPath = body.substring(filePathPrefix.length());
+                orgPath = RNFetchBlobFS.normalizePath(orgPath);
+                // handle
+                if(RNFetchBlobFS.isAsset(orgPath)) {
+                    try {
+                        String assetName = orgPath.replace(RNFetchBlobFS.assetPrefix, "");
+                        InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
+                        long length = 0;
+                        length = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
+                        byte [] bytes = new byte[(int) length];
+                        in.read(bytes, 0, (int) length);
+                        in.close();
+                        entity = new ByteArrayEntity(bytes);
+                    } catch (IOException e) {
+//                        e.printStackTrace();
+                    }
+                }
+                else
+                    entity = new FileEntity(new File(RNFetchBlobFS.normalizePath(orgPath)));
             }
             else {
                 blob = Base64.decode(body, 0);

src/fs.js

 import {
   NativeModules,
   DeviceEventEmitter,
+  Platform,
   NativeAppEventEmitter,
 } from 'react-native'
 import RNFetchBlobSession from './class/RNFetchBlobSession'
   }
 }
 
+function asset(path:string):string {
+  if(Platform.OS === 'ios') {
+    // path from camera roll
+    if(/^assets-library\:\/\//.test(path))
+      return path
+  }
+  return 'bundle-assets://' + path
+}
+
 function createFile(path:string, data:string, encoding: 'base64' | 'ascii' | 'utf8'):Promise {
   encoding = encoding || 'utf8'
   return new Promise((resolve, reject) => {
   stat,
   lstat,
   scanFile,
-  dirs
+  dirs,
+  asset
 }

src/index.js

   config,
   session,
   fs,
-  wrap,
+  wrap
 }

src/ios/RNFetchBlob.xcodeproj/project.pbxproj

 		A158F4301D0539DB006FFD38 /* RNFetchBlobNetwork.m in Sources */ = {isa = PBXBuildFile; fileRef = A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */; };
 		A15C30141CD25C330074CB35 /* RNFetchBlob.m in Sources */ = {isa = PBXBuildFile; fileRef = A15C30131CD25C330074CB35 /* RNFetchBlob.m */; };
 		A166D1AA1CE0647A00273590 /* RNFetchBlob.h in Sources */ = {isa = PBXBuildFile; fileRef = A15C30111CD25C330074CB35 /* RNFetchBlob.h */; };
+		A1AAE2991D300E4D0051D11C /* RNFetchBlobReqBuilder.m in Sources */ = {isa = PBXBuildFile; fileRef = A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
 		A15C300E1CD25C330074CB35 /* libRNFetchBlob.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRNFetchBlob.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		A15C30111CD25C330074CB35 /* RNFetchBlob.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFetchBlob.h; path = RNFetchBlob/RNFetchBlob.h; sourceTree = "<group>"; };
 		A15C30131CD25C330074CB35 /* RNFetchBlob.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFetchBlob.m; path = RNFetchBlob/RNFetchBlob.m; sourceTree = "<group>"; };
+		A1AAE2971D300E3E0051D11C /* RNFetchBlobReqBuilder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFetchBlobReqBuilder.h; sourceTree = "<group>"; };
+		A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNFetchBlobReqBuilder.m; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
 		A15C30051CD25C330074CB35 = {
 			isa = PBXGroup;
 			children = (
+				A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */,
+				A1AAE2971D300E3E0051D11C /* RNFetchBlobReqBuilder.h */,
 				A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */,
 				A158F42E1D0539CE006FFD38 /* RNFetchBlobNetwork.h */,
 				A158F42C1D0535BB006FFD38 /* RNFetchBlobConst.m */,
 				A158F42D1D0535BB006FFD38 /* RNFetchBlobConst.m in Sources */,
 				A158F4271D052E49006FFD38 /* RNFetchBlobFS.m in Sources */,
 				A158F4301D0539DB006FFD38 /* RNFetchBlobNetwork.m in Sources */,
+				A1AAE2991D300E4D0051D11C /* RNFetchBlobReqBuilder.m in Sources */,
 				A15C30141CD25C330074CB35 /* RNFetchBlob.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;

src/ios/RNFetchBlob/RNFetchBlob.m

 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
+#import "RNFetchBlobReqBuilder.h"
 
 
 ////////////////////////////////////////
                   form:(NSArray *)form
                   callback:(RCTResponseSenderBlock)callback)
 {
-    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
-    // send request
-    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];
-        // if method is POST or PUT, convert data string format
-        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
-            
-            // combine multipart/form-data body
-            for(id field in form) {
-                NSString * name = [field valueForKey:@"name"];
-                NSString * content = [field valueForKey:@"data"];
-                // field is a text field
-                if([field valueForKey:@"filename"] == nil || content == [NSNull null]) {
-                    [postData appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [postData appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"\r\n", name] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [postData appendData:[[NSString stringWithFormat:@"Content-Type: text/plain\r\n\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [postData appendData:[[NSString stringWithFormat:@"%@\r\n", content] dataUsingEncoding:NSUTF8StringEncoding]];
-                }
-                // field contains a file
-                else {
-                    NSMutableData * blobData;
-                    if(content != nil) {
-                        if([content hasPrefix:self.filePathPrefix]) {
-                            NSString * orgPath = [content substringFromIndex:[self.filePathPrefix length]];
-                            blobData = [[NSData alloc] initWithContentsOfFile:orgPath];
-                        }
-                        else
-                            blobData = [[NSData alloc] initWithBase64EncodedString:content options:0];
-                    }
-                    NSString * filename = [field valueForKey:@"filename"];
-                    [postData appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [postData appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"; filename=\"%@\"\r\n", name, filename] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [postData appendData:[[NSString stringWithFormat:@"Content-Type: application/octet-stream\r\n\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [postData appendData:blobData];
-                    [postData appendData:[[NSString stringWithFormat:@"\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                }
-                
-            }
-            
-            // close form data
-            [postData appendData: [[NSString stringWithFormat:@"--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
-            [request setHTTPBody:postData];
-            // set content-length
-            [mheaders setValue:[NSString stringWithFormat:@"%d",[postData length]] forKey:@"Content-Length"];
-            [mheaders setValue:[NSString stringWithFormat:@"100-continue",[postData length]] 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];
-        
-        
+    [RNFetchBlobReqBuilder buildMultipartRequest:options taskId:taskId method:method url:url headers:headers form:form onComplete:^(NSURLRequest *req, long bodyLength) {
         // send HTTP request
         RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-        [utils sendRequest:options bridge:self.bridge taskId:taskId withRequest:request callback:callback];
+        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
         utils = nil;
-    });
+    }];
+    
 }
 
 // Fetch blob data request
                   headers:(NSDictionary *)headers
                   body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
-    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
-    // send request
-    NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
-                                    initWithURL:[NSURL
-                                                 URLWithString: encodedUrl]];
-    
-    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 is POST or PUT, convert data string format
-        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
-            // generate octet-stream body
-            if(body != nil) {
-                
-                // when body is a string contains file path prefix, try load file from the path
-                if([body hasPrefix:self.filePathPrefix]) {
-                    NSString * orgPath = [body substringFromIndex:[self.filePathPrefix length]];
-                    [request setHTTPBodyStream: [NSInputStream inputStreamWithFileAtPath:orgPath ]];
-                }
-                // otherwise convert it as BASE64 data string
-                else {
-                    blobData = [[NSData alloc] initWithBase64EncodedString:body options:0];
-                    [request setHTTPBody:blobData];
-                }
-                
-                [mheaders setValue:@"application/octet-stream" forKey:@"content-type"];
-                
-            }
-        }
-        
-        [request setHTTPMethod: method];
-        [request setAllHTTPHeaderFields:mheaders];
-        
+    [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];
-        [utils sendRequest:options bridge:self.bridge taskId:taskId withRequest:request callback:callback];
+        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
         utils = nil;
-    });
+    }];
+    
 }
 
 RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
     
 }
 
-RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
-    RNFetchBlobFS *fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
-    if(bufferSize == nil) {
-        if([[encoding lowercaseString] isEqualToString:@"base64"])
-            bufferSize = 4095;
-        else
-            bufferSize = 4096;
-    }
-    [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
-}
+RCT_EXPORT_METHOD(writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+    [RNFetchBlobFS writeFile:path encoding:encoding data:data append:append resolver:resolve rejecter:reject];
+})
+
+RCT_EXPORT_METHOD(writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+    [RNFetchBlobFS writeFileArray:path data:data append:append resolver:resolve rejecter:reject];
+})
 
 RCT_EXPORT_METHOD(writeStream:(NSString *)path withEncoding:(NSString *)encoding appendData:(BOOL)append callback:(RCTResponseSenderBlock)callback) {
     RNFetchBlobFS * fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     BOOL exist = nil;
     BOOL isDir = nil;
     NSError * error = nil;
+    
+    path = [RNFetchBlobFS getPathOfAsset:path];
+    
     exist = [fm fileExistsAtPath:path isDirectory:&isDir];
     if(exist == NO) {
         callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not exist", path]]);
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
     BOOL isDir = nil;
+    
+    path = [RNFetchBlobFS getPathOfAsset:path];
+    
     exist = [fm fileExistsAtPath:path isDirectory:&isDir];
     if(exist == NO) {
         callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not exist", path]]);
 
 RCT_EXPORT_METHOD(cp:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
+    path = [RNFetchBlobFS getPathOfAsset:path];
     BOOL result = [[NSFileManager defaultManager] copyItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
     
     if(error == nil)
 }
 
 RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
-    [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject];
-})
-
-RCT_EXPORT_METHOD(writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
-    [RNFetchBlobFS writeFile:path encoding:encoding data:data append:append resolver:resolve rejecter:reject];
+    
+    [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject onComplete:nil];
 })
 
-RCT_EXPORT_METHOD(writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
-    [RNFetchBlobFS writeFileArray:path data:data append:append resolver:resolve rejecter:reject];
-})
+RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
+    
+    RNFetchBlobFS *fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
+    if(bufferSize == nil) {
+        if([[encoding lowercaseString] isEqualToString:@"base64"])
+            bufferSize = 4095;
+        else
+            bufferSize = 4096;
+    }
+    // read asset stream
+    [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
+}
 
 RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
     

src/ios/RNFetchBlobConst.h

 extern NSString *const MSG_EVENT_LOG;
 extern NSString *const MSG_EVENT_WARN;
 extern NSString *const MSG_EVENT_ERROR;
+
 extern NSString *const FILE_PREFIX;
+extern NSString *const ASSET_PREFIX;
+extern NSString *const AL_PREFIX;
 
 // config
 extern NSString *const CONFIG_USE_TEMP;

src/ios/RNFetchBlobConst.m

 #import "RNFetchBlobConst.h"
 
 extern NSString *const FILE_PREFIX = @"RNFetchBlob-file://";
+extern NSString *const ASSET_PREFIX = @"bundle-assets://";
+extern NSString *const AL_PREFIX = @"assets-library://";
+
+
 
 // fetch configs
 extern NSString *const CONFIG_USE_TEMP = @"fileCache";

src/ios/RNFetchBlobFS.h

 
 #import <Foundation/Foundation.h>
 #import "RCTBridgeModule.h"
+@import AssetsLibrary;
 
 @interface RNFetchBlobFS : NSObject <NSStreamDelegate>  {
     NSOutputStream * outStream;
 + (NSString *) getCacheDir;
 + (NSString *) getDocumentDir;
 + (NSString *) getTempPath:(NSString*)taskId withExtension:(NSString *)ext;
++ (NSString *) getPathOfAsset:(NSString *)assetURI;
++ (void) getPathFromUri:(NSString *)uri completionHandler:(void(^)(NSString * path, ALAssetRepresentation *asset)) onComplete;
 
 // fs methods
 + (RNFetchBlobFS *) getFileStreams;
 + (BOOL) exists:(NSString *) path;
 + (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;
++ (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject onComplete:(void (^)(NSData * content))onComplete;
++ (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
 
 // constructor
 - (id) init;
 - (void) openWithDestination;
 - (void) openWithId;
 - (NSString *)openWithPath:(NSString *)destPath encode:(nullable NSString *)encode appendData:(BOOL)append;
+- (void) startAssetReadStream:(NSData *)assetUrl;
 
 // file stream write data
 - (void)write:(NSData *) chunk;

src/ios/RNFetchBlobFS.m

 #import "RCTEventDispatcher.h"
 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobConst.h"
+@import AssetsLibrary;
+
 
 NSMutableDictionary *fileStreams = nil;
 
     [fileStreams setValue:instance forKey:uuid];
 }
 
++(NSString *) getPathOfAsset:(NSString *)assetURI
+{
+    // get file path of an app asset
+    if([assetURI hasPrefix:ASSET_PREFIX])
+    {
+        assetURI = [assetURI stringByReplacingOccurrencesOfString:ASSET_PREFIX withString:@""];
+        assetURI = [[NSBundle mainBundle] pathForResource: [assetURI stringByDeletingPathExtension]
+                                               ofType: [assetURI pathExtension]];
+    }
+    return assetURI;
+}
+
 + (NSString *) getCacheDir {
     return [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
 }
     return tempPath;
 }
 
+- (void) startAssetReadStream:(NSString *)assetUrl
+{
+    ALAssetsLibraryAssetForURLResultBlock resultblock = ^(ALAsset *myasset)
+    {
+        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
+        dispatch_async(queue, ^ {
+            NSString * streamEventCode = [NSString stringWithFormat:@"RNFetchBlobStream+%@", self.path];
+            ALAssetRepresentation *rep = [myasset defaultRepresentation];
+            Byte *buffer = (Byte*)malloc(self.bufferSize);
+            NSUInteger cursor = [rep getBytes:buffer fromOffset:0 length:self.bufferSize error:nil];
+            while(cursor > 0)
+            {
+                cursor += [rep getBytes:buffer fromOffset:cursor length:self.bufferSize error:nil];
+                NSData * chunkData = [NSData dataWithBytes:buffer length:self.bufferSize];
+                NSString * encodedChunk = @"";
+                // emit data
+                if( [[self.encoding lowercaseString] isEqualToString:@"utf8"] ) {
+                    encodedChunk = [encodedChunk initWithData:chunkData encoding:NSUTF8StringEncoding];
+                }
+                // when encoding is ASCII, send byte array data
+                else if ( [[self.encoding lowercaseString] isEqualToString:@"ascii"] ) {
+                    // RCTBridge only emits string data, so we have to create JSON byte array string
+                    NSMutableArray * asciiArray = [NSMutableArray array];
+                    unsigned char *bytePtr;
+                    if (chunkData.length > 0)
+                    {
+                        bytePtr = (unsigned char *)[chunkData bytes];
+                        NSInteger byteLen = chunkData.length/sizeof(uint8_t);
+                        for (int i = 0; i < byteLen; i++)
+                        {
+                            [asciiArray addObject:[NSNumber numberWithChar:bytePtr[i]]];
+                        }
+                    }
+                    
+                    [self.bridge.eventDispatcher
+                     sendDeviceEventWithName:streamEventCode
+                     body: @{
+                             @"event": FS_EVENT_DATA,
+                             @"detail": asciiArray
+                             }
+                     ];
+                    return;
+                }
+                // convert byte array to base64 data chunks
+                else if ( [[self.encoding lowercaseString] isEqualToString:@"base64"] ) {
+                    encodedChunk = [chunkData base64EncodedStringWithOptions:0];
+                }
+                // unknown encoding, send error event
+                else {
+                    [self.bridge.eventDispatcher
+                     sendDeviceEventWithName:streamEventCode
+                     body:@{
+                            @"event": FS_EVENT_ERROR,
+                            @"detail": @"unrecognized encoding"
+                            }
+                     ];
+                    return;
+                }
+                
+                [self.bridge.eventDispatcher
+                 sendDeviceEventWithName:streamEventCode
+                 body:@{
+                        @"event": FS_EVENT_DATA,
+                        @"detail": encodedChunk
+                        }
+                 ];
+            }
+            free(buffer);
+        });
+        
+    };
+    
+    ALAssetsLibraryAccessFailureBlock failureblock  = ^(NSError *error)
+    {
+        
+    };
+    
+    if(assetUrl && [assetUrl length])
+    {
+        NSURL *asseturl = [NSURL URLWithString:assetUrl];
+        ALAssetsLibrary* assetslibrary = [[ALAssetsLibrary alloc] init];
+        [assetslibrary assetForURL:asseturl
+                       resultBlock:resultblock
+                      failureBlock:failureblock];
+    }
+}
+
 + (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
     @try {
         NSFileManager * fm = [NSFileManager defaultManager];
     }
 }
 
-+ (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
++ (void) readFile:(NSString *)path encoding:(NSString *)encoding
+         resolver:(RCTPromiseResolveBlock)resolve
+         rejecter:(RCTPromiseRejectBlock)reject
+       onComplete:(void (^)(NSData * content))onComplete
+{
     @try
     {
-        NSFileManager * fm = [NSFileManager defaultManager];
-        NSError *err = nil;
-        BOOL exists = [fm fileExistsAtPath:path];
-        if(!exists) {
-            @throw @"RNFetchBlobFS readFile error", @"file not exists", path;
-            return;
-        }
-        if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
-            NSString * utf8Result = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:&err];
-            resolve(utf8Result);
-        }
-        else if ([[encoding lowercaseString] isEqualToString:@"base64"]) {
-            NSData * fileData = [NSData dataWithContentsOfFile:path];
-            resolve([fileData base64EncodedStringWithOptions:0]);
-        }
-        else if ([[encoding lowercaseString] isEqualToString:@"ascii"]) {
-            NSData * resultData = [NSData dataWithContentsOfFile:path];
-            NSMutableArray * resultArray = [NSMutableArray array];
-            char * bytes = [resultData bytes];
-            for(int i=0;i<[resultData length];i++) {
-                [resultArray addObject:[NSNumber numberWithChar:bytes[i]]];
+        [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+            NSData * fileContent;
+            NSError * err;
+            Byte * buffer;
+            if(asset != 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];
+                free(buffer);
             }
-            resolve(resultArray);
-        }
-
+            else
+            {
+                BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:path];
+                if(!exists) {
+                    reject(@"RNFetchBlobFS readFile error", @"file not exists", path);
+                    return;
+                }
+                fileContent = [NSData dataWithContentsOfFile:path];
+                
+            }
+            if(onComplete != nil)
+                onComplete(fileContent);
+            
+            if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
+                if(resolve != nil)
+                    resolve([[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding]);
+            }
+            else if ([[encoding lowercaseString] isEqualToString:@"base64"]) {
+                if(resolve != nil)
+                    resolve([fileContent base64EncodedStringWithOptions:0]);
+            }
+            else if ([[encoding lowercaseString] isEqualToString:@"ascii"]) {
+                NSMutableArray * resultArray = [NSMutableArray array];
+                char * bytes = [fileContent bytes];
+                for(int i=0;i<[fileContent length];i++) {
+                    [resultArray addObject:[NSNumber numberWithChar:bytes[i]]];
+                }
+                if(resolve != nil)
+                    resolve(resultArray);
+            }
+        }];
     }
     @catch(NSException * e)
     {
-        reject(@"RNFetchBlobFS readFile error", @"error", [e description]);
+        if(reject != nil)
+            reject(@"RNFetchBlobFS readFile error", @"error", [e description]);
     }
 }
 
     self.encoding = encoding;
     self.path = path;
     self.bufferSize = bufferSize;
-
+    
+    if([path hasPrefix:AL_PREFIX])
+    {
+        [self startAssetReadStream:path];
+        return;
+    }
+    
+    // normalize file path
+    path = [[self class] getPathOfAsset:path];
+    
     // NSStream needs a runloop so let's create a run loop for it
     dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
     // start NSStream is a runloop
                             forMode:NSDefaultRunLoopMode];
         [inStream open];
         [[NSRunLoop currentRunLoop] run];
-
+        
     });
 }
 
 
 }
 
-void runOnMainQueueWithoutDeadlocking(void (^block)(void))
-{
-    if ([NSThread isMainThread])
-    {
-        block();
-    }
-    else
-    {
-        dispatch_sync(dispatch_get_main_queue(), block);
-    }
-}
-
-
 #pragma mark RNFetchBlobFS read stream delegate
 
 - (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
 
 }
 
++ (void) getPathFromUri:(NSString *)uri completionHandler:(void(^)(NSString * path, ALAssetRepresentation *asset)) onComplete
+{
+    if([uri hasPrefix:AL_PREFIX])
+    {
+        NSURL *asseturl = [NSURL URLWithString:uri];
+        ALAssetsLibrary* assetslibrary = [[ALAssetsLibrary alloc] init];
+        [assetslibrary assetForURL:asseturl
+                       resultBlock:^(ALAsset *asset) {
+                           onComplete(nil, [asset defaultRepresentation]);
+                       }
+                      failureBlock:^(NSError *error) {
+                          onComplete(nil, nil);
+                      }];
+    }
+    else
+    {
+        onComplete([[self class] getPathOfAsset:uri], nil);
+    }
+}
+
 @end

src/ios/RNFetchBlobNetwork.h

 
 #import <Foundation/Foundation.h>
 #import "RCTBridgeModule.h"
+#import "RNFetchBlobFS.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);
 - (void) sendRequest;
 
 + (NSMutableDictionary  * _Nullable ) normalizeHeaders:(NSDictionary * _Nullable)headers;
-- (void) sendRequest:(NSDictionary  * _Nullable )options bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
+- (void) sendRequest:(NSDictionary  * _Nullable )options contentLength:(long)contentLength bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
 
 
 @end

src/ios/RNFetchBlobNetwork.m

 }
 
 // send HTTP request
-- (void) sendRequest:(NSDictionary  * _Nullable )options bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback
+- (void) sendRequest:(NSDictionary  * _Nullable )options
+       contentLength:(long) contentLength
+              bridge:(RCTBridge * _Nullable)bridgeRef
+              taskId:(NSString * _Nullable)taskId
+         withRequest:(NSURLRequest * _Nullable)req
+            callback:(_Nullable RCTResponseSenderBlock) callback
 {
     self.taskId = taskId;
     self.respData = [[NSMutableData alloc] initWithLength:0];
     NSString * ext = [self.options valueForKey:CONFIG_FILE_EXT];
     NSURLSession * session;
     
-    bodyLength = [[req HTTPBody] length];
+    bodyLength = contentLength;
     
     // the session trust any SSL certification
 
         respFile = NO;
     }
     NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
+    
     [task resume];
     
     // network status indicator
      body:@{
             @"taskId": taskId,
             @"written": [NSString stringWithFormat:@"%d", totalBytesWritten],
-            @"total": [NSString stringWithFormat:@"%d", totalBytesExpectedToWrite]
+            @"total": [NSString stringWithFormat:@"%d", bodyLength]
             }
      ];
 }

src/ios/RNFetchBlobReqBuilder.h

+//
+//  RNFetchBlobReqBuilder.h
+//  RNFetchBlob
+//
+//  Created by Ben Hsieh on 2016/7/9.
+//  Copyright © 2016年 wkh237. All rights reserved.
+//
+
+#ifndef RNFetchBlobReqBuilder_h
+#define RNFetchBlobReqBuilder_h
+
+#import <Foundation/Foundation.h>
+
+@interface RNFetchBlobReqBuilder : NSObject;
+
++(void) buildMultipartRequest:(NSDictionary *)options
+                       taskId:(NSString *)taskId
+                       method:(NSString *)method
+                          url:(NSString *)url
+                      headers:(NSDictionary *)headers
+                         form:(NSArray *)form
+                   onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
+
++(void) buildOctetRequest:(NSDictionary *)options
+                   taskId:(NSString *)taskId
+                   method:(NSString *)method
+                      url:(NSString *)url
+                  headers:(NSDictionary *)headers
+                     body:(NSString *)body
+               onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
+
+@end
+
+#endif /* RNFetchBlobReqBuilder_h */

src/ios/RNFetchBlobReqBuilder.m

+//
+//  RNFetchBlobReqBuilder.m
+//  RNFetchBlob
+//
+//  Created by Ben Hsieh on 2016/7/9.
+//  Copyright © 2016年 wkh237. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNFetchBlobReqBuilder.h"
+#import "RNFetchBlobNetwork.h"
+#import "RNFetchBlobConst.h"
+#import "RNFetchBlobFS.h"
+
+@interface RNFetchBlobReqBuilder()
+{
+    
+}
+@end
+
+@implementation RNFetchBlobReqBuilder
+
+
+// Fetch blob data request
++(void) buildMultipartRequest:(NSDictionary *)options
+                       taskId:(NSString *)taskId
+                       method:(NSString *)method
+                          url:(NSString *)url
+                      headers:(NSDictionary *)headers
+                         form:(NSArray *)form
+                   onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
+{
+    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+    // send request
+    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];
+        // 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];
+            }
+            // set content-length
+            [mheaders setValue:[NSString stringWithFormat:@"%d",[postData length]] forKey:@"Content-Length"];
+            [mheaders setValue:[NSString stringWithFormat:@"100-continue",[postData length]] 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]);
+        }];
+        
+    });
+}
+
+// Fetch blob data request
++(void) buildOctetRequest:(NSDictionary *)options
+                   taskId:(NSString *)taskId
+                   method:(NSString *)method
+                      url:(NSString *)url
+                  headers:(NSDictionary *)headers
+                     body:(NSString *)body
+               onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
+{
+    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+    // send request
+    NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
+                                    initWithURL:[NSURL
+                                                 URLWithString: encodedUrl]];
+    
+    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;
+        long size = -1;
+        // if method is POST or PUT, convert data string format
+        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
+            // generate octet-stream body
+            if(body != 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]];
+                    orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
+                    if([orgPath hasPrefix:AL_PREFIX])
+                    {
+                        [RNFetchBlobFS readFile:orgPath encoding:@"utf8" resolver:nil rejecter:nil onComplete:^(NSData *content) {
+                            [request setHTTPBody:content];
+                            [mheaders setValue:@"application/octet-stream" forKey:@"content-type"];
+                            [request setHTTPMethod: method];
+                            [request setAllHTTPHeaderFields:mheaders];
+                            onComplete(request, [content length]);
+                        }];
+                        return;
+                    }
+                    size = [[[NSFileManager defaultManager] attributesOfItemAtPath:orgPath error:nil] fileSize];
+                    [request setHTTPBodyStream: [NSInputStream inputStreamWithFileAtPath:orgPath ]];
+                }
+                // otherwise convert it as BASE64 data string
+                else {
+                    blobData = [[NSData alloc] initWithBase64EncodedString:body options:0];
+                    [request setHTTPBody:blobData];
+                }
+                
+                [mheaders setValue:@"application/octet-stream" forKey:@"content-type"];
+                
+            }
+        }
+        
+        [request setHTTPMethod: method];
+        [request setAllHTTPHeaderFields:mheaders];
+        
+        onComplete(request, size);
+    });
+}
+
++(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData))onComplete
+{
+    NSMutableData * formData = [[NSMutableData alloc] init];
+    if(form == nil)
+        onComplete(nil);
+    else
+    {
+        __block int i = 0;
+        __block int count = [form count];
+        void __block (^getFieldData)(id field) = ^(id field)
+        {
+            NSString * name = [field valueForKey:@"name"];
+            NSString * content = [field valueForKey:@"data"];
+            NSString * contentType = [field valueForKey:@"type"];
+            contentType = contentType == nil ? @"application/octet-stream" : contentType;
+            // field is a text field
+            if([field valueForKey:@"filename"] == nil || content == [NSNull null]) {
+                [formData appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
+                [formData appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"\r\n", name] dataUsingEncoding:NSUTF8StringEncoding]];
+                [formData appendData:[[NSString stringWithFormat:@"Content-Type: text/plain\r\n\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
+                [formData appendData:[[NSString stringWithFormat:@"%@\r\n", content] dataUsingEncoding:NSUTF8StringEncoding]];
+            }
+            // field contains a file
+            else {
+                NSMutableData * blobData;
+                if(content != nil)
+                {
+                    // append data from file asynchronously
+                    if([content hasPrefix:FILE_PREFIX])
+                    {
+                        NSString * orgPath = [content substringFromIndex:[FILE_PREFIX length]];
+                        orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
+                        [RNFetchBlobFS readFile:orgPath encoding:@"utf8" resolver:nil rejecter:nil onComplete:^(NSData *content) {
+                            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]];
+                            [formData appendData:[[NSString stringWithFormat:@"Content-Type: %@\r\n\r\n", contentType] dataUsingEncoding:NSUTF8StringEncoding]];
+                            [formData appendData:content];
+                            [formData appendData:[[NSString stringWithFormat:@"\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
+                            i++;
+                            if(i < count)
+                            {
+                                getFieldData([form objectAtIndex:i]);
+                            }
+                            else
+                                onComplete(formData);
+                        }];
+                        return ;
+                    }
+                    else
+                        blobData = [[NSData alloc] initWithBase64EncodedString:content options:0];
+                }
+                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]];
+                [formData appendData:[[NSString stringWithFormat:@"Content-Type: %@\r\n\r\n", contentType] dataUsingEncoding:NSUTF8StringEncoding]];
+                [formData appendData:blobData];
+                [formData appendData:[[NSString stringWithFormat:@"\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
+            }
+            i++;
+            if(i < count)
+            {
+                getFieldData([form objectAtIndex:i]);
+            }
+            else
+                onComplete(formData);
+            
+        };
+        getFieldData([form objectAtIndex:i]);
+    }
+}
+
+
+@end

src/package.json

 {
   "name": "react-native-fetch-blob",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "A module provides upload, download, and files access API. Supports file stream read/write for process large files.",
   "main": "index.js",
   "scripts": {

test-server/server.js

   res.send('man')
 })
 
+app.post('/mime', mimeCheck)
+app.put('/mime', mimeCheck)
+
+function mimeCheck(req, res) {
+  console.log(req.files)
+  var mimes = []
+  for(var i in req.files) {
+    mimes.push(req.files[i].mimetype)
+  }
+  res.send(mimes)
+}
+
 // handle multipart/form-data request
 app.post('/upload-form', formUpload)
 

test.sh

 fi
 # copy js files to test app folder
 cp -R test/ "${TEST_APP_PATH}/"
+node -e "var fs=require('fs'); var pkg = JSON.parse(fs.readFileSync('./RNFetchBlobTest/package.json')); pkg.rnpm = {assets : ['assets']}; fs.writeFileSync('./RNFetchBlobTest/package.json', JSON.stringify(pkg, null, 4));"
 
 # install module
 cd "${TEST_APP_PATH}"

test/assets/test-asset1.json

+{
+  "secret" : "asset#1"
+}

test/index.test.js

   View,
   Platform,
   ScrollView,
+  CameraRoll,
   Image,
 } from 'react-native';
 

test/react-native-testkit/animate-text.js

+/**
+ * @author wkh237
+ * @version 0.1.1
+ */
+
+// @flow
+
+import React, { Component } from 'react';
+import {
+  Text,
+  View
+} from 'react-native';
+import Timer from 'react-timer-mixin';
+
+const HALF_RAD = Math.PI/2
+
+export default class AnimateNumber extends Component {
+
+  props : {
+    countBy? : ?number,
+    interval? : ?number,
+    steps? : ?number,
+    value : number,
+    timing : 'linear' | 'easeOut' | 'easeIn' | () => number,
+    formatter : () => {},
+    onProgress : () => {},
+    onFinish : () => {}
+  };
+
+  static defaultProps = {
+    interval : 14,
+    timing : 'linear',
+    steps : 45,
+    value : 0,
+    formatter : (val) => val,
+    onFinish : () => {}
+  };
+
+  static TimingFunctions = {
+
+    linear : (interval:number, progress:number):number => {
+      return interval
+    },
+
+    easeOut : (interval:number, progress:number):number => {
+      return interval * Math.sin(HALF_RAD*progress) * 5
+    },
+
+    easeIn : (interval:number, progress:number):number => {
+      return interval * Math.sin((HALF_RAD - HALF_RAD*progress)) * 5
+    },
+
+  };
+
+  state : {
+    value? : ?number,
+    displayValue? : ?number
+  };
+
+  /**
+   * Animation direction, true means positive, false means negative.
+   * @type {bool}
+   */
+  direction : bool;
+  /**
+   * Start value of last animation.
+   * @type {number}
+   */
+  startFrom : number;
+  /**
+  * End value of last animation.
+  * @type {number}
+   */
+  endWith : number;
+
+  constructor(props:any) {
+    super(props);
+    // default values of state and non-state variables
+    this.state = {
+      value : 0,
+      displayValue : 0
+    }
+    this.dirty = false;
+    this.startFrom = 0;
+    this.endWith = 0;
+  }
+
+  componentDidMount() {
+    this.startFrom = this.state.value
+    this.endWith = this.props.value
+    this.dirty = true
+    this.startAnimate()
+  }
+
+  componentWillUpdate(nextProps, nextState) {
+
+    // check if start an animation
+    if(this.props.value !== nextProps.value) {
+      this.startFrom = this.props.value
+      this.endWith = nextProps.value
+      this.dirty = true
+      this.startAnimate()
+      return
+    }
+    // Check if iterate animation frame
+    if(!this.dirty) {
+      return
+    }
+    if (this.direction === true) {
+      if(parseFloat(this.state.value) <= parseFloat(this.props.value)) {
+        this.startAnimate();
+      }
+    }
+    else if(this.direction === false){
+      if (parseFloat(this.state.value) >= parseFloat(this.props.value)) {
+        this.startAnimate();
+      }
+    }
+
+  }
+
+  render() {
+    return (
+      <Text {...this.props}>
+        {this.state.displayValue}
+      </Text>)
+  }
+
+  startAnimate() {
+
+    let progress = this.getAnimationProgress()
+
+    Timer.setTimeout(() => {
+
+      let value = (this.endWith - this.startFrom)/this.props.steps
+      if(this.props.countBy)
+        value = Math.sign(value)*Math.abs(this.props.countBy)
+      let total = parseFloat(this.state.value) + parseFloat(value)
+
+      this.direction = (value > 0)
+      // animation terminate conditions
+      if (((this.direction) ^ (total <= this.endWith)) === 1) {
+        this.dirty = false
+        total = this.endWith
+        this.props.onFinish(total, this.props.formatter(total))
+      }
+
+      if(this.props.onProgress)
+        this.props.onProgress(this.state.value, total)
+
+      this.setState({
+        value : total,
+        displayValue : this.props.formatter(total)
+      })
+
+    }, this.getTimingFunction(this.props.interval, progress))
+
+  }
+
+  getAnimationProgress():number {
+    return (this.state.value - this.startFrom) / (this.endWith - this.startFrom)
+  }
+
+  getTimingFunction(interval:number, progress:number) {
+    if(typeof this.props.timing === 'string') {
+      let fn = AnimateNumber.TimingFunctions[this.props.timing]
+      return fn(interval, progress)
+    } else if(typeof this.props.timing === 'function')
+      return this.props.timing(interval, progress)
+    else
+      return AnimateNumber.TimingFunctions['linear'](interval, progress)
+  }
+
+}

test/react-native-testkit/components/reporter.js

   ListView,
   Image,
   TouchableOpacity,
+  Dimensions,
   RecyclerViewBackedScrollView,
 } from 'react-native';
 
+import AnimateNumber from '../animate-text.js'
 import Assert from './assert.js'
 import RNTEST from '../index.js'
 
     this.tests = {
       common : []
     }
-    this.testGroups = ['common']
+    this.state = {
+      listHeight : 0
+    }
+    this.testGroups = ['summary','common']
     this.ds = null
     this.updateDataSource()
 
 
   render() {
 
+    let tests = RNTEST.TestContext.getTests()
+
+    let passed = 0
+    let executed = 0
+    let count = 0
+    for(let i in tests) {
+      if(tests[i].status !== 'skipped')
+        count++
+      if(tests[i].status !== 'waiting' && tests[i].status !== 'skipped')
+        executed++
+        passed += tests[i].status === 'pass' ? 1 : 0
+    }
+    let percent = passed / count
+    let color = `rgb(${Math.floor((1-percent) *255)},${Math.floor(percent *192)}, 0)`
+
     return (
-      <ListView
-        style={styles.container}
-        dataSource={this.ds}
-        renderRow={this.renderTest.bind(this)}
-        renderScrollComponent={props => <RecyclerViewBackedScrollView {...props} />}
-        renderSectionHeader={(data, id) => {
-          return (
-            <View style={styles.sectionHeader}>
-              <Text style={styles.sectionText}>{id}</Text>
-            </View>
-          )
-        }}
-      />)
+      <View style={{flex : 1}}>
+        <View style={{margin : 20}} onLayout={(e) => {
+          this.setState({
+            headerHeight : e.nativeEvent.layout.height,
+            listHeight : Dimensions.get('window').height - e.nativeEvent.layout.height
+          })
+        }}>
+          <Text>{`${executed} tests executed`}</Text>
+          <Text>{`${passed} test cases passed`}</Text>
+          <Text>{`${count} test cases`}</Text>
+          <View style={{flexDirection : 'row', alignSelf : 'center', alignItems : 'flex-end'}}>
+            <AnimateNumber style={{
+              color,
+              fontSize : 100,
+              textAlign : 'right'
+            }}
+              value={Math.floor(passed / count*100)}
+              countBy={1}/>
+            <Text style={{color, fontSize : 30, textAlign : 'left'}} >{`%`}</Text>
+          </View>
+        </View>
+        <ListView
+          style={[styles.container]}
+          dataSource={this.ds}
+          renderRow={this.renderTest.bind(this)}
+          renderScrollComponent={props => <RecyclerViewBackedScrollView {...props} />}
+          renderSectionHeader={(data, id) => {
+            return (
+              <View style={styles.sectionHeader}>
+                <Text style={styles.sectionText}>{id}</Text>
+              </View>
+            )
+          }}
+        />
+      </View>)
   }
 
-  renderTest(t) {
+  renderTest(t, group) {
+
     let pass = true
     let foundActions = false
     let tests = RNTEST.TestContext.getTests()
       t.status = 'waiting'
 
     return (
-      <TouchableOpacity onPress={()=>{
-          t.start(t.sn)
-        }}>
         <View key={'rn-test-' + t.desc} style={{
           borderBottomWidth : 1.5,
           borderColor : '#DDD',
           <View key={t.desc + '-result'} style={{backgroundColor : '#F4F4F4'}}>
             {t.expand ? t.result : (t.status === 'pass' ? null : t.result)}
           </View>
-        </View>
-      </TouchableOpacity>)
+        </View>)
   }
 
   updateDataSource() {

test/react-native-testkit/lib/test-context.js

 let RCTContext: ReactElement = null
 let props:any = {}
 let timeout = 30000
+let summary = {}
 
 export default class TestContext {
 
       run : run === false ? false : true,
       result : null,
       asserts : [],
-      timeout : timeout || 3000,
+      timeout : timeout || 15000,
       expired : false,
       running : false,
       executed : false,
           })
           resolve(...res)
         }
+        RCTContext.forceUpdate()
       }).catch((err) => {
         updateInternal({
           executed : true,
   static update(i, ...data) {
     let test = tests[i]
     let result = test.result || []
+    // if new element have prop `uid`, we should replace it not appending it.
+    for(let i in data) {
+      if(data[i].props.uid) {
+        for(let j in result) {
+          if(result[j].uid === data[i].props.uid)
+          result[j] = data[i]
+          result.splice(j,1)
+          break
+        }
+      }
+    }
     Object.assign(test, {result : [...result, ...data]})
     RCTContext.forceUpdate()
   }

test/test-0.5.1.js

 })
 
 describe('Upload multipart data with file from storage', (report, done) => {
+  try{
     let filename = 'test-from-storage-img-'+Date.now()+'.png'
     RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/upload-form`, {
         'Content-Type' : 'multipart/form-data',
       </Info>)
       done()
     })
+  } catch(err) {
+    console.log(err)
+  }
 })
 
 describe('Upload and download at the same time', (report, done) => {
         done()
       })
     })
-
 })
 
 RNTest.config({
   group : '0.5.1',
   run : true,
   expand : false,
-  timeout : 30000,
+  timeout : 600000,
 })('Upload and download large file', (report, done) => {
   let filename = '22mb-dummy-' + Date.now()
+  let begin = -1
+  let begin2 = -1
+  let deb = Date.now()
   RNFetchBlob.config({
     fileCache : true
   })
   .fetch('GET', `${TEST_SERVER_URL}/public/22mb-dummy`)
+  .progress((now, total) => {
+    if(begin === -1)
+      begin = Date.now()
+    if(Date.now() - deb < 1000)
+      return
+    deb = Date.now()
+    report(<Info uid="200" key="progress">
+      <Text>
+        {`download ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s)`}
+      </Text>
+    </Info>)
+  })
   .then((res) => {
-    return RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
+    deb = Date.now()
+    let promise =  RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
       Authorization : `Bearer ${DROPBOX_TOKEN}`,
       'Dropbox-API-Arg': '{\"path\": \"/rn-upload/'+filename+'\",\"mode\": \"add\",\"autorename\": true,\"mute\": false}',
       'Content-Type' : 'application/octet-stream',
     }, RNFetchBlob.wrap(res.path()))
+    if(Platform.OS === 'ios')
+      promise.progress((now, total) => {
+        if(Date.now() - deb < 1000)
+          return
+        deb = Date.now()
+        if(begin2 === -1)
+          begin2 = Date.now()
+        let speed = Math.floor(now / (Date.now() - begin2))
+        report(<Info uid="100"  key="progress">
+          <Text>
+            {`upload ${now} / ${total} bytes (${speed} kb/s)`}
+            {` ${Math.floor((total-now)/speed/1000)} seconds left`}
+          </Text>
+        </Info>)
+      })
+    return promise
   })
   .then((res) => {
     report(<Assert
-      key="upload should success withou crashing app"
+      key="upload should success without crashing app"
       expect={filename}
       actual={res.json().name}/>)
     done()
       })
 
   })
-
 })

test/test-0.6.2.js

+import RNTest from './react-native-testkit/'
+import React from 'react'
+import RNFetchBlob from 'react-native-fetch-blob'
+
+import {
+  StyleSheet,
+  Text,
+  View,
+  ScrollView,
+  CameraRoll,
+  Platform,
+  Dimensions,
+  Image,
+} from 'react-native';
+
+const fs = RNFetchBlob.fs
+const { Assert, Comparer, Info, prop } = RNTest
+const describe = RNTest.config({
+  group : '0.6.2',
+  run : true,
+  expand : false,
+  timeout : 30000,
+})
+const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, DROPBOX_TOKEN, styles } = prop()
+const  dirs = RNFetchBlob.fs.dirs
+
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
+let photo = null
+
+describe('upload asset from camera roll', (report, done) => {
+  let imgName = `image-from-camera-roll-${Platform.OS}.jpg`
+  let tick = Date.now()
+  CameraRoll.getPhotos({first : 10})
+    .then((resp) => {
+      let url = resp.edges[0].node.image.uri
+      photo = url
+      return RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
+        Authorization : `Bearer ${DROPBOX_TOKEN}`,
+        'Dropbox-API-Arg': `{\"path\": \"/rn-upload/${imgName}\",\"mode\": \"add\",\"autorename\": false,\"mute\": false}`,
+        'Content-Type' : 'application/octet-stream',
+      }, RNFetchBlob.wrap(url))
+      .progress((now, total) => {
+        if(Date.now() - tick < 1000)
+        return
+        report(<Info key="progress" uid="pg1">
+          <Text>{`upload ${now} / ${total} ${Math.floor(now/total*100)}% `}</Text>
+        </Info>)
+      })
+    })
+    .then((resp) => {
+      resp = resp.json()
+      report(
+        <Assert key="confirm the file has been uploaded" expect={imgName} actual={resp.name}/>
+      )
+      done()
+    })
+})
+//
+// describe('Upload multipart data with file from CameraRoll', (report, done) => {
+//     let filename = 'test-from-storage-img-'+Date.now()+'.png'
+//     RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/upload-form`, {
+//         'Content-Type' : 'multipart/form-data',
+//       }, [
+//         { name : 'test-img', filename : filename, data: RNFetchBlob.wrap(photo)},
+//         { name : 'test-text', filename : 'test-text.txt', data: RNFetchBlob.base64.encode('hello.txt')},
+//         { name : 'field1', data : 'hello !!'},
+//         { name : 'field2', data : 'hello2 !!'}
+//       ])
+//     .then((resp) => {
+//       resp = resp.json()
+//       report(
+//         <Assert key="check posted form data #1" expect="hello !!" actual={resp.fields.field1}/>,
+//         <Assert key="check posted form data #2" expect="hello2 !!" actual={resp.fields.field2}/>,
+//       )
+//       return RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/public/${filename}`)
+//     })
+//     .then((resp) => {
+//       report(<Info key="uploaded image">
+//         <Image
+//           style={styles.image}
+//           source={{ uri : 'data:image/png;base64, '+ resp.base64()}}/>
+//       </Info>)
+//       done()
+//     })
+// })
+//
+//
+// describe('access assets from camera roll', (report, done) => {
+//   let photo = null
+//   CameraRoll.getPhotos({first : 10})
+//     .then((resp) => {
+//       photo = resp.edges[0].node.image.uri
+//       report(<Info key="items">
+//         <Text>{photo}</Text>
+//       </Info>)
+//       return fs.readFile(photo, 'base64')
+//     })
+//     .then((data) => {
+//       report(<Info key="asset image">
+//         <Image
+//           style={styles.image}
+//           source={{uri: `data:image/png;base64, ${data}`}}/>
+//       </Info>)
+//       done()
+//     })
+// })
+//
+// describe('read asset in app bundle',(report, done) => {
+//   let target = fs.asset('test-asset2.png')
+//   fs.readFile(target, 'base64')
+//   .then((data) => {
+//     report(<Info key="asset image">
+//       <Image
+//         style={styles.image}
+//         source={{uri: `data:image/png;base64, ${data}`}}/>
+//     </Info>)
+//     return fs.readFile(fs.asset('test-asset1.json'), 'utf8')
+//   })
+//   .then((resp) => {
+//     report(
+//       <Assert key="asset content verify"
+//         expect="asset#1"
+//         actual={JSON.parse(resp).secret}/>)
+//       done()
+//   })
+// })
+//
+// describe('stat assets in app', (report, done) => {
+//   fs.stat(fs.asset('test-asset2.png'))
+//     .then((data) => {
+//       report(<Info key="list of assets">
+//         <Text>{JSON.stringify(data)}</Text>
+//       </Info>)
+//       done()
+//     })
+// })
+//
+// describe('copy asset', (report, done) => {
+//   let dest = `${dirs.DocumentDir}/test-asset-1-${Date.now()}.json`
+//   fs.cp(fs.asset('test-asset1.json'), dest)
+//     .then(() => fs.readFile(dest, 'utf8'))
+//     .then((data) => {
+//       report(<Assert key="asset copied correctly"
+//         expect={'asset#1'}
+//         actual={JSON.parse(data).secret}/>)
+//       return fs.stat(fs.asset('test-asset1.json'))
+//     })
+//     .then((stat) => {
+//       report(<Assert key="file size check"
+//         expect={27}
+//         actual={Math.floor(stat.size)}/>,
+//       <Info key="dest file info">
+//         <Text>{JSON.stringify(stat)}</Text>
+//       </Info>)
+//       done()
+//     })
+// })
+//
+//
+// describe('upload file from assets',(report, done) => {
+//   let assetName = fs.asset('test-asset1.json')
+//   RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
+//     Authorization : `Bearer ${DROPBOX_TOKEN}`,
+//     'Dropbox-API-Arg': `{\"path\": \"/rn-upload/file-from-asset-${Platform.OS}.json\",\"mode\": \"add\",\"autorename\": false,\"mute\": false}`,
+//     'Content-Type' : 'application/octet-stream',
+//   }, RNFetchBlob.wrap(assetName))
+//   .then((resp) => {
+//     resp = resp.json()
+//     report(
+//       <Assert key="file name check"
+//         expect={`file-from-asset-${Platform.OS}.json`}
+//         actual={resp.name}/>)
+//     done()
+//   })
+// })
+
+describe('Check custom MIME type correctness',(report, done) => {
+  RNFetchBlob
+  .config({fileCache : true})
+  .fetch('GET', `${TEST_SERVER_URL}/public/beethoven.mp3`)
+  .then((resp) => {
+    return RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/mime`, null, [
+      { name : 'image', filename : 'image', type : 'image/jpeg', data : RNFetchBlob.base64.encode('123456') },
+      { name : 'mp3', filename : 'mp3', type : 'application/mp3', data : RNFetchBlob.base64.encode('123456') },
+      { name : 'mp3', filename : 'mp3', data : RNFetchBlob.base64.encode('123456') },
+      { name : 'asset', filename : 'asset.json', type: 'application/json', data : RNFetchBlob.wrap(fs.asset('test-asset1.json')) },
+      { name : 'camera-roll', filename : 'cameraRoll.png', type: 'image/png', data : RNFetchBlob.wrap(photo) },
+      { name : 'storage', filename : 'storage.mp3', type: 'application/mp3', data : RNFetchBlob.wrap(resp.path()) },
+    ])
+  })
+  .then((resp) => {
+    resp = resp.json()
+    report(
+      <Assert key="check #1 mime" expect={'image/jpeg'} actual={resp[0]} />,
+      <Assert key="check #2 mime" expect={'application/mp3'} actual={resp[1]} />,
+      <Assert key="check #3 mime" expect={'application/octet-stream'} actual={resp[2]} />,
+      <Assert key="check #4 mime" expect={'application/json'} actual={resp[3]} />,
+      <Assert key="check #5 mime" expect={'image/png'} actual={resp[4]} />,
+      <Assert key="check #6 mime" expect={'application/mp3'} actual={resp[5]} />,
+    )
+    done()
+  })
+})

test/test-android.js

 const describe = RNTest.config({
   group : 'Android only functions',
   run : Platform.OS === 'android',
-  expand : true,
+  expand : false,
 })
 const { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles } = prop()
 

test/test-init.js

 // test environment variables
 
 prop('FILENAME', `${Platform.OS}-0.7.0-${Date.now()}.png`)
-prop('TEST_SERVER_URL', 'http://192.168.16.70:8123')
-prop('TEST_SERVER_URL_SSL', 'https://192.168.16.70:8124')
+prop('TEST_SERVER_URL', 'http://192.168.0.11:8123')
+prop('TEST_SERVER_URL_SSL', 'https://192.168.0.11:8124')
 prop('DROPBOX_TOKEN', 'fsXcpmKPrHgAAAAAAAAAoXZhcXYWdgLpQMan6Tb_bzJ237DXhgQSev12hA-gUXt4')
 prop('styles', {
   image : {
         done()
     })
 })
-//
+
+
 require('./test-0.1.x-0.4.x')
 require('./test-0.5.1')
 require('./test-0.5.2')
 require('./test-0.6.0')
+require('./test-0.6.2')
 require('./test-fs')
 require('./test-android')