Merge branch 'master' into 0.10.0

.github/PULL_REQUEST_TEMPLATE

 Thank you for making a pull request ! Just a gentle reminder :)
 
 1. If the PR is offering a feature please make the request to our "Feature Branch" 0.10.0
-2. Bug fix request to "Bug Fix Branch" 0.9.2
+2. Bug fix request to "Bug Fix Branch" 0.9.4
 3. Correct README.md can directly to master

CONTRIBUTORS.md

+
 Dmitry Petukhov <dmitryvpetukhov@gmail.com>
+
 Erik Smartt <code@eriksmartt.com>
+
 Evgeniy Baraniuk <ev.baraniuk@gmail.com>
+
 Juan B. Rodriguez <jbrodriguez@gmail.com>
+
 Kaishley <kklingachetti@msn.com>
+
 Nguyen Cao Nhat Linh <nhatlinh95@gmail.com>
-Tim Suchanek <tim.suchanek@gmail.com>
+
 follower <github@rancidbacon.com>
+
 francisco-sanchez-molina <psm1984@gmail.com>
+
 smartt <github@eriksmartt.com>

README.md

-# react-native-fetch-blob 
+# react-native-fetch-blob
 [![release](https://img.shields.io/github/release/wkh237/react-native-fetch-blob.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/releases) [![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) [![](https://img.shields.io/badge/Wiki-Public-brightgreen.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/wiki) [![npm](https://img.shields.io/npm/l/react-native-fetch-blob.svg?maxAge=2592000&style=flat-square)]()
 
 
 - File stream support for dealing with large file
 - Blob, File, XMLHttpRequest polyfills that make browser-based library available in RN (experimental)
 
-> The npm package is inside `src` folder, this is development folder
+> The npm package is inside `src` folder, if you're going to install via git repository do not directly poiint to this folder
 
 ## TOC
 * [About](#user-content-about)
  * [Cancel HTTP request](#user-content-cancel-request)
  * [Android Media Scanner, and Download Manager Support](#user-content-android-media-scanner-and-download-manager-support)
  * [Self-Signed SSL Server](#user-content-self-signed-ssl-server)
+ * [Transfer Encoding](#user-content-transfer-encoding)
  * [RNFetchBlob as Fetch](#user-content-rnfetchblob-as-fetch)
 * [File System](#user-content-file-system)
  * [File access](#user-content-file-access)
 npm install --save react-native-fetch-blob
 ```
 
-Link package using [rnpm](https://github.com/rnpm/rnpm)
+Or if using CocoaPods, add the pod to your `Podfile`, for example:
 
-```sh
-rnpm link
+```
+pod 'react-native-fetch-blob,
+    :path => '../node_modules/react-native-fetch-blob
 ```
 
-### Manually link the package (Android)
+**Automatically Link Native Modules**
 
-If rnpm link command failed to link the package automatically, you might try manually link the package.
+For 0.29.2+ projects, simply link native packages via following command because rnpm has been merged into react-native, you no longer need it.
 
-Open `android/settings.gradle`, and add these lines which will app RNFetchBlob Android project dependency to your app.
+```
+react-native link
+```
 
-```diff
-include ':app'      
-+ include ':react-native-fetch-blob'                                                                                                  
-+ project(':react-native-fetch-blob').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-fetch-blob/android')                        
+As for projects < 0.29 you need `rnpm` to link native packages
+
+```sh
+rnpm link
 ```
 
-Add this line to `MainApplication.java`, so that RNFetchBlob package becomes part of react native package.
+Optionally, use the following command to add Android permissions to `AndroidManifest.xml` automatically
 
-```diff
-...
-+ import com.RNFetchBlob.RNFetchBlobPackage;                                                                                 
-...
-protected List<ReactPackage> getPackages() {
-      return Arrays.<ReactPackage>asList(
-          new MainReactPackage(),
-+          new RNFetchBlobPackage()                                                                                         
-      );
-    }
-  };
-...
+```sh
+RNFB_ANDROID_PERMISSIONS=true react-native link
 ```
-> If you still having problem on installing this package, please check the [trouble shooting page](https://github.com/wkh237/react-native-fetch-blob/wiki/Trouble-Shooting) or [file an issue](https://github.com/wkh237/react-native-fetch-blob/issues/new)
+
+pre 0.29 projects 
+
+```sh
+RNFB_ANDROID_PERMISSIONS=true rnpm link
+```
+
+The link script might not take effect if you have non-default project structure, please visit [the wiki](https://github.com/wkh237/react-native-fetch-blob/wiki/Manually-Link-Package/_edit) to manually link the pacakge.
 
 **Grant Permission to External storage for Android 5.0 or lower**
 
 var RNFetchBlob = require('react-native-fetch-blob').default
 ```
 
-### HTTP Data Transfer
+## HTTP Data Transfer
 
----
 
-#### Regular Request
+### Regular Request
 
 After `0.8.0` react-native-fetch-blob automatically decide how to send the body by checking its type and `Content-Type` in header. The rule is described in the following diagram
 
 
 To sum up :
 
-- To send a form data, the `Content-Type` header won't take effect if the body is an `Array` because we will set proper content type for you.
-- To send binary data, you have two choices, use BASE64 encoded string or a file path which points to a file contains the body. The `Content-Type` header does not matters.
- - The body is a BASE64 encoded string, the `Content-Type` header filed must containing substring`;BASE64` or `application/octet`  
- - The body is a path point to a file, it must be a string starts with `RNFetchBlob-file://`, which can simply done by `RNFetchBlob.wrap(PATH_TO_THE_FILE)`
-- To send the body as-is, set a `Content-Type` header not containing `;BASE64` or `application/octet`.
+- To send a form data, the `Content-Type` header does not matters. When the body is an `Array` we will set proper content type for you.
+- To send binary data, you have two choices, use BASE64 encoded string or path points to a file contains the body.
+ - If the `Content-Type` containing substring`;BASE64` or `application/octet` the given body will be considered as a BASE64 encoded data which will be decoded to binary data as the request body.   
+ - Otherwise, if a string starts with `RNFetchBlob-file://` (which can simply done by `RNFetchBlob.wrap(PATH_TO_THE_FILE)`), it will try to find the data from the URI string after `RNFetchBlob-file://` and use it as request body. 
+- To send the body as-is, simply use a `Content-Type` header not containing `;BASE64` or `application/octet`.
+
+> After 0.9.4, we disabled `Chunked` transfer encoding by default, if you're going to use it, you should explicitly set header `Transfer-Encoding` to `Chunked`.
 
-#### Download example : Fetch files that needs authorization token
+### Download example : Fetch files that needs authorization token
 
 Most simple way is download to memory and stored as BASE64 encoded string, this is handy when the response data is small.
 
   })
 ```
 
-#### Download to storage directly
+### Download to storage directly
 
-If the response data is large, that would be a bad idea to convert it into BASE64 string. The better solution is store the response data directly into file system. The simplest way is give a `fileCache` option to config, and set it to `true`. This will make incoming response data stored in a temporary path **without** any file extension.
+If the response data is large, that would be a bad idea to convert it into BASE64 string. A better solution is streaming the response directly into a file, simply add a `fileCache` option to config, and set it to `true`. This will make incoming response data stored in a temporary path **without** any file extension.
 
 **These files won't be removed automatically, please refer to [Cache File Management](#user-content-cache-file-management)**
 
 
 **Set Temp File Extension**
 
-Sometimes you might need a file extension for some reason. For instance, when using file path as source of `Image` component, the path should end with something like .png or .jpg, you can do this by add `appendExt` option to `config`.
+Sometimes you might need a file extension for some reason. For example, when using file path as source of `Image` component, the path should end with something like .png or .jpg, you can do this by add `appendExt` option to `config`.
 
 ```js
 RNFetchBlob
 
 **Use Specific File Path**
 
-If you prefer a specific path rather than randomly generated one, you can use `path` option. We've added a constant [dirs](#user-content-dirs) in v0.5.0 that contains several common used directories.
+If you prefer a specific path rather than randomly generated one, you can use `path` option. We've added [several  constants](#user-content-dirs) in v0.5.0 which represents commonly used directories.
 
 ```js
 let dirs = RNFetchBlob.fs.dirs
 
 ####  Upload example : Dropbox [files-upload](https://www.dropbox.com/developers/documentation/http/documentation#files-upload) API
 
-`react-native-fetch-blob` will convert the base64 string in `body` to binary format using native API, this process will be  done in a new thread, so it's async.
+`react-native-fetch-blob` will convert the base64 string in `body` to binary format using native API, this process will be  done in a separated thread, so it won't block your GUI.
 
 ```js
 
   })
 ```
 
-#### Upload a file from storage
+### Upload a file from storage
 
-If you're going to use a `file` request body, just wrap the path with `wrap` API.
+If you're going to use a `file` as request body, just wrap the path with `wrap` API.
 
 ```js
 RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
   })
 ```
 
-#### Multipart/form-data example : Post form data with file and data
+### Multipart/form-data example : Post form data with file and data
 
 In `version >= 0.3.0` you can also post files with form data, just put an array in `body`, with elements have property `name`, `data`, and `filename`(optional).
 
   })
 ```
 
-What if you want to upload a file using form data ? 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.
+What if you want to append a file to form data ? 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. But keep in mind when the file is large it's likely crash your app. Please consider use other strategy (see [#94](https://github.com/wkh237/react-native-fetch-blob/issues/94)).
 
 ```js
 
   })
 ```
 
-#### Upload/Download progress
+### Upload/Download progress
 
-In `version >= 0.4.2` it is possible to know the upload/download progress. After `0.7.0` IOS and Android upload progress are supported.
+In `version >= 0.4.2` it is possible to know the upload/download progress. After `0.7.0` IOS and Android upload progress are also supported.
 
 ```js
   RNFetchBlob.fetch('POST', 'http://www.example.com/upload', {
     })
 ```
 
-#### Cancel Request
+### Cancel Request
 
 After `0.7.0` it is possible to cancel a HTTP request. When the request cancel, it will definately throws an promise rejection, be sure to catch it.
 
       android.actionViewIntent(PATH_OF_IMG, 'image/png')
 ```
 
-### File System
+## File System
 
-#### File Access
+### 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 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.
 
 
 See [File API](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API) for more information
 
-#### File Stream
+### File Stream
 
 In `v0.5.0` we've added  `writeStream` and `readStream`, which allows your app read/write data from file path. This API creates a file stream, rather than convert whole data into BASE64 encoded string, it's handy when processing **large files**.
 
-When calling `readStream` method, you have to `open` the stream, and start to read data.
+When calling `readStream` method, you have to `open` the stream, and start to read data. When the file is large, consider use an appropriate `bufferSize` and `interval` to reduce the native event dispatching overhead (see [Performance Tips](#user-content-performance-tips))
 
 ```js
 let data = ''
 
 ```
 
-#### Cache File Management
+### Cache File Management
 
 When using `fileCache` or `path` options along with `fetch` API, response data will automatically stored into file system. The files will **NOT** removed unless you `unlink` it. There're several ways to remove the files
 
 
 ```
 
-#### Self-Signed SSL Server
+### Transfer Encoding
+
+After `0.9.4`, the `Chunked` transfer encoding is disabled by default due to some service provoder may not support chunked transfer. To enable it, set `Transfer-Encoding` header to `Chunked`.
+
+```js
+RNFetchBlob.fetch('POST', 'http://example.com/upload', { 'Transfer-Encoding' : 'Chunked' }, bodyData)
+```
+
+### Self-Signed SSL Server
 
 By default, react-native-fetch-blob does NOT allow connection to unknown certification provider since it's dangerous. If you're going to connect a server with self-signed certification, add `trusty` to `config`. This function is available for version >= `0.5.3`
 
 })
 ```
 
-### Web API Polyfills
+## Web API Polyfills
 
 After `0.8.0` we've made some [Web API polyfills](https://github.com/wkh237/react-native-fetch-blob/wiki/Web-API-Polyfills-(experimental)) that makes some browser-based library available in RN.
 
 
 Here's a [sample app](https://github.com/wkh237/rn-firebase-storage-upload-sample) that uses polyfills to upload files to FireBase.
 
-### Performance Tips
-
----
+## Performance Tips
 
 **Reduce RCT Bridge and BASE64 Overheard**
 
-React Native connects JS and Native context by passing JSON through React bridge, therefore there will be an overhead to convert data before they sent. When data is large, this will be quite a performance impact to your app, it's recommended to use file storage instead of BASE64 if possible. The following chart shows how much faster when loading data from storage than BASE64 encoded string on iphone 6.
+When reading data via `fs.readStream` the process seems blocking JS thread when file is large, it's because the default buffer size is quite small (4kb) which result in large amount of events triggered in JS thread, try to increase the buffer size (for example 100kb = 102400) and set a larger interval (which is introduced in 0.9.4 default value is 10ms) to limit the frequency. 
+
+React Native connects JS and Native context by passing JSON around React Native bridge, and there will be an overhead to convert data before they sent to each side. When data is large, this will be quite a performance impact to your app, it's recommended to use file storage instead of BASE64 if possible.The following chart shows how much faster when loading data from storage than BASE64 encoded string on iphone 6.
 
 <img src="img/performance_1.png" style="width : 100%"/>
 
 
 ## Changes
 
-| Version | |
-|---|---|
-| 0.9.2 | Add Blob.slice() method implementation #89 |
-| 0.9.1 | Fix Android Blob constructor asynchronous issue caused by 0.9.0 fs change |
-| 0.9.0 | Fix unicode response data format issue #73. Improve Android performance by using thread pool instead of async task. Add Fetch replacement #70. Add Android only API `actionViewIntent` to open file or install APK in app |
-| 0.8.1 | Remove Web API log and fix ios progress report function. |
-| 0.8.0 | Added Web API polyfills, support regular request, added timeout option. |
-| 0.7.5 | Fix installation script that make it compatible to react-native < 0.28 |
-| 0.7.4 | Fix app crash problem in version > 0.27 |
-| 0.7.3 | Fix OkHttp dependency issue in version < 0.29 |
-| 0.7.2 | Fix cancel request bug |
-| 0.7.1 | Fix #57 ios module could not compile on ios version <= 9.3 |
-| 0.7.0 | Add support of Android upload progress, and remove AsyncHttpClient dependency from Android native implementation. |
-| 0.6.4 | Fix rnpm link script. |
-| 0.6.3 | Fix performance issue on IOS, increase max concurrent request limitation from 1. |
-| 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 |
-| 0.5.7 | Fix #31 #30 Xcode pre 7.3 build error |
-| 0.5.6 | Add support for IOS network status indicator. Fix file stream ASCII reader bug. |
-| 0.5.5 | Remove work in progress code added in 0.5.2 which may cause memory leaks. |
-| 0.5.4 | Fix #30 #31 build build error, and improve memory efficiency. |
-| 0.5.3 | Add API for access untrusted SSL server |
-| 0.5.2 | Fix improper url params bug [#26](https://github.com/wkh237/react-native-fetch-blob/issues/26) and change IOS HTTP implementation from NSURLConnection to NSURLSession |
-| 0.5.0 | Upload/download with direct access to file storage, and also added file access APIs |
-| 0.4.2 | Supports upload/download progress |
-| 0.4.1 | Fix upload form-data missing file extension problem on Android |
-| 0.4.0 | Add base-64 encode/decode library and API |
-| ~0.3.0 | Upload/Download octet-stream and form-data |
+See [release notes](https://github.com/wkh237/react-native-fetch-blob/releases)
 
 ### Development
 

scripts/test.sh

 npm install --save react-native-fetch-blob
 # libs that requires web API polyfills
 npm install --save firebase
-# libs that requires Node polyfills
-npm install --save oboe
-
-rnpm link
+react-native link
 
 # copy android assets
 cd ${CWD}

src/android.js

  * @param  {string} mime MIME type string
  * @return {Promise}
  */
-function actionViewIntent(path:string, mime = 'text/plain':string) {
+function actionViewIntent(path:string, mime:string = 'text/plain') {
   if(Platform.OS === 'android')
     return RNFetchBlob.actionViewIntent(path, mime)
   else

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

     static ReactApplicationContext RCTContext;
     static LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
     static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
+    static LinkedBlockingQueue<Runnable> fsTaskQueue = new LinkedBlockingQueue<>();
+    static ThreadPoolExecutor fsThreadPool = new ThreadPoolExecutor(2, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
 
     /**
      * @param path Stream file path
      * @param encoding Stream encoding, should be one of `base64`, `ascii`, and `utf8`
-     * @param bufferSize Stream buffer size, default to 1024 or 1026(base64).
+     * @param bufferSize Stream buffer size, default to 4096 or 4095(base64).
      */
-    public void readStream(String path, String encoding, int bufferSize) {
-        RNFetchBlobFS fs = new RNFetchBlobFS(this.getReactApplicationContext());
-        fs.readStream(path, encoding, bufferSize);
+    public void readStream(final String path, final String encoding, final int bufferSize, final int tick, final String streamId) {
+        final ReactApplicationContext ctx = this.getReactApplicationContext();
+        fsThreadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS fs = new RNFetchBlobFS(ctx);
+                fs.readStream(path, encoding, bufferSize, tick, streamId);
+            }
+        });
     }
 
     @ReactMethod

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

 import okhttp3.RequestBody;
 import okio.BufferedSink;
 
-/**
- * Created by wkh237 on 2016/7/11.
- */
 public class RNFetchBlobBody extends RequestBody{
 
     InputStream requestStream;
     RNFetchBlobReq.RequestType requestType;
     MediaType mime;
     File bodyCache;
+    Boolean chunkedEncoding = false;
 
 
-    /**
-     * Single file or raw content request constructor
-     * @param taskId
-     * @param type
-     * @param form
-     * @param contentType
-     */
-    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, ReadableArray form, MediaType contentType) {
+    public RNFetchBlobBody(String taskId) {
         this.mTaskId = taskId;
-        this.form = form;
-        requestType = type;
-        mime = contentType;
-        try {
-            bodyCache = createMultipartBodyCache();
-            requestStream = new FileInputStream(bodyCache);
-            contentLength = bodyCache.length();
-        } catch(Exception ex) {
-            ex.printStackTrace();
-            RNFetchBlobUtils.emitWarningEvent("RNFetchBlob failed to create request multipart body :" + ex.getLocalizedMessage());
-        }
+    }
+
+    RNFetchBlobBody chunkedEncoding(boolean val) {
+        this.chunkedEncoding = val;
+        return this;
+    }
+
+    RNFetchBlobBody setMIME(MediaType mime) {
+        this.mime = mime;
+        return this;
+    }
+
+    RNFetchBlobBody setRequestType( RNFetchBlobReq.RequestType type) {
+        this.requestType = type;
+        return this;
     }
 
     /**
-     * Multipart request constructor
-     * @param taskId
-     * @param type
-     * @param rawBody
-     * @param contentType
+     * Set request body
+     * @param body A string represents the request body
+     * @return object itself
      */
-    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, String rawBody, MediaType contentType) {
-        this.mTaskId = taskId;
-        requestType = type;
-        this.rawBody = rawBody;
-        mime = contentType;
+    RNFetchBlobBody setBody(String body) {
+        this.rawBody = body;
         if(rawBody == null) {
             this.rawBody = "";
             requestType = RNFetchBlobReq.RequestType.AsIs;
                     break;
                 case AsIs:
                     contentLength = this.rawBody.getBytes().length;
+                    requestStream = new ByteArrayInputStream(this.rawBody.getBytes());
                     break;
                 case Others:
                     break;
             ex.printStackTrace();
             RNFetchBlobUtils.emitWarningEvent("RNFetchBlob failed to create single content request body :" + ex.getLocalizedMessage() + "\r\n");
         }
+        return this;
+    }
 
+    /**
+     * Set request body (Array)
+     * @param body A Readable array contains form data
+     * @return object itself
+     */
+    RNFetchBlobBody setBody(ReadableArray body) {
+        this.form = body;
+        try {
+            bodyCache = createMultipartBodyCache();
+            requestStream = new FileInputStream(bodyCache);
+            contentLength = bodyCache.length();
+        } catch(Exception ex) {
+            ex.printStackTrace();
+            RNFetchBlobUtils.emitWarningEvent("RNFetchBlob failed to create request multipart body :" + ex.getLocalizedMessage());
+        }
+        return this;
     }
 
     @Override
     public long contentLength() {
-        return contentLength;
+        return chunkedEncoding ? -1 : contentLength;
     }
 
     @Override
     @Override
     public void writeTo(BufferedSink sink) {
         try {
-            if (requestType == RNFetchBlobReq.RequestType.AsIs)
-                sink.write(rawBody.getBytes());
-            else
-                pipeStreamToSink(requestStream, sink);
+            pipeStreamToSink(requestStream, sink);
         } catch(Exception ex) {
             RNFetchBlobUtils.emitWarningEvent(ex.getLocalizedMessage());
             ex.printStackTrace();

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

 
 import java.util.HashMap;
 
-/**
- * Created by wkh237 on 2016/5/29.
- */
+
 public class RNFetchBlobConfig {
 
     public Boolean fileCache;

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

 package com.RNFetchBlob;
 
-import okhttp3.MediaType;
 
-/**
- * Created by wkh237 on 2016/7/11.
- */
 public class RNFetchBlobConst {
     public static final String EVENT_UPLOAD_PROGRESS = "RNFetchBlobProgress-upload";
     public static final String EVENT_PROGRESS = "RNFetchBlobProgress";

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

 package com.RNFetchBlob;
 
-import android.app.LoaderManager;
-import android.content.ContentResolver;
-import android.content.CursorLoader;
 import android.content.res.AssetFileDescriptor;
-import android.database.Cursor;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Environment;
-import android.os.Looper;
-import android.provider.MediaStore;
+import android.os.SystemClock;
 import android.util.Base64;
 
 import com.RNFetchBlob.Utils.PathResolver;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
-import java.net.URLDecoder;
 import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
-import java.util.concurrent.BlockingDeque;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Created by wkh237 on 2016/5/26.
- */
+
 public class RNFetchBlobFS {
 
     ReactApplicationContext mCtx;
      * @param path Destination file path.
      * @param encoding Encoding of the string.
      * @param data Array passed from JS context.
-     * @param promise
+     * @param promise RCT Promise
      */
     static public void writeFile(String path, String encoding, String data, final boolean append, final Promise promise) {
         try {
             FileOutputStream fout = new FileOutputStream(f, append);
             // write data from a file
             if(encoding.equalsIgnoreCase(RNFetchBlobConst.DATA_ENCODE_URI)) {
+                data = normalizePath(data);
                 File src = new File(data);
                 if(!src.exists()) {
                     promise.reject("RNfetchBlob writeFileError", "source file : " + data + "not exists");
      * Write array of bytes into file
      * @param path Destination file path.
      * @param data Array passed from JS context.
-     * @param promise
+     * @param promise RCT Promise
      */
     static public void writeFile(String path, ReadableArray data, final boolean append, final Promise promise) {
 
      * @param encoding  File stream decoder, should be one of `base64`, `utf8`, `ascii`
      * @param bufferSize    Buffer size of read stream, default to 4096 (4095 when encode is `base64`)
      */
-    public void readStream( String path, String encoding, int bufferSize) {
+    public void readStream(String path, String encoding, int bufferSize, int tick, final String streamId) {
         path = normalizePath(path);
-        AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
-            @Override
-            protected Integer doInBackground(String ... args) {
-                String path = args[0];
-                String encoding = args[1];
-                int bufferSize = Integer.parseInt(args[2]);
-                String eventName = "RNFetchBlobStream+" + path;
-                try {
+        try {
 
-                    int chunkSize = encoding.equalsIgnoreCase("base64") ? 4095 : 4096;
-                    if(bufferSize > 0)
-                        chunkSize = bufferSize;
+            int chunkSize = encoding.equalsIgnoreCase("base64") ? 4095 : 4096;
+            if(bufferSize > 0)
+                chunkSize = bufferSize;
 
-                    InputStream fs;
-                    if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
-                        fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
-                    }
-                    else {
-                        fs = new FileInputStream(new File(path));
-                    }
+            InputStream fs;
+            if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
+                fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
+            }
+            else {
+                fs = new FileInputStream(new File(path));
+            }
 
-                    byte[] buffer = new byte[chunkSize];
-                    int cursor = 0;
-                    boolean error = false;
+            byte[] buffer = new byte[chunkSize];
+            int cursor = 0;
+            boolean error = false;
 
-                    if (encoding.equalsIgnoreCase("utf8")) {
-                        while ((cursor = fs.read(buffer)) != -1) {
-                            String chunk = new String(buffer, 0, cursor, "UTF-8");
-                            emitStreamEvent(eventName, "data", chunk);
-                        }
-                    } else if (encoding.equalsIgnoreCase("ascii")) {
-                        while ((cursor = fs.read(buffer)) != -1) {
-                            WritableArray chunk = Arguments.createArray();
-                            for(int i =0;i<cursor;i++)
-                            {
-                                chunk.pushInt((int)buffer[i]);
-                            }
-                            emitStreamEvent(eventName, "data", chunk);
-                        }
-                    } else if (encoding.equalsIgnoreCase("base64")) {
-                        while ((cursor = fs.read(buffer)) != -1) {
-                            if(cursor < chunkSize) {
-                                byte [] copy = new byte[cursor];
-                                for(int i =0;i<cursor;i++) {
-                                    copy[i] = buffer[i];
-                                }
-                                emitStreamEvent(eventName, "data", Base64.encodeToString(copy, Base64.NO_WRAP));
-                            }
-                            else
-                                emitStreamEvent(eventName, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
+            if (encoding.equalsIgnoreCase("utf8")) {
+                while ((cursor = fs.read(buffer)) != -1) {
+                    String chunk = new String(buffer, 0, cursor, "UTF-8");
+                    emitStreamEvent(streamId, "data", chunk);
+                    if(tick > 0)
+                        SystemClock.sleep(tick);
+                }
+            } else if (encoding.equalsIgnoreCase("ascii")) {
+                while ((cursor = fs.read(buffer)) != -1) {
+                    WritableArray chunk = Arguments.createArray();
+                    for(int i =0;i<cursor;i++)
+                    {
+                        chunk.pushInt((int)buffer[i]);
+                    }
+                    emitStreamEvent(streamId, "data", chunk);
+                    if(tick > 0)
+                        SystemClock.sleep(tick);
+                }
+            } else if (encoding.equalsIgnoreCase("base64")) {
+                while ((cursor = fs.read(buffer)) != -1) {
+                    if(cursor < chunkSize) {
+                        byte [] copy = new byte[cursor];
+                        for(int i =0;i<cursor;i++) {
+                            copy[i] = buffer[i];
                         }
-                    } else {
-                        String msg = "unrecognized encoding `" + encoding + "`";
-                        emitStreamEvent(eventName, "error", msg);
-                        error = true;
+                        emitStreamEvent(streamId, "data", Base64.encodeToString(copy, Base64.NO_WRAP));
                     }
-
-                    if(!error)
-                        emitStreamEvent(eventName, "end", "");
-                    fs.close();
-                    buffer = null;
-
-                } catch (Exception err) {
-                    emitStreamEvent(eventName, "error", err.getLocalizedMessage());
+                    else
+                        emitStreamEvent(streamId, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
+                    if(tick > 0)
+                        SystemClock.sleep(tick);
                 }
-                return null;
+            } else {
+                String msg = "unrecognized encoding `" + encoding + "`";
+                emitStreamEvent(streamId, "error", msg);
+                error = true;
             }
-        };
-        task.execute(path, encoding, String.valueOf(bufferSize));
+
+            if(!error)
+                emitStreamEvent(streamId, "end", "");
+            fs.close();
+            buffer = null;
+
+        } catch (Exception err) {
+            emitStreamEvent(streamId, "error", err.getLocalizedMessage());
+        }
     }
 
     /**
      * @param callback  JS context callback
      */
     static void cp(String path, String dest, Callback callback) {
+
         path = normalizePath(path);
         InputStream in = null;
         OutputStream out = null;
                 callback.invoke("cp error: source file at path`" + path + "` not exists");
                 return;
             }
-
             if(!new File(dest).exists())
                 new File(dest).createNewFile();
 
             }
 
         } catch (Exception err) {
-            if(err != null)
-                callback.invoke(err.getLocalizedMessage());
+            callback.invoke(err.getLocalizedMessage());
         } finally {
             try {
-                in.close();
-                out.close();
+                if (in != null) {
+                    in.close();
+                }
+                if (out != null) {
+                    out.close();
+                }
                 callback.invoke();
-            } catch (IOException e) {
+            } catch (Exception e) {
                 callback.invoke(e.getLocalizedMessage());
             }
         }
      * @param callback  JS context callback
      */
     static void exists(String path, Callback callback) {
-        path = normalizePath(path);
+
         if(isAsset(path)) {
             try {
                 String filename = path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
             }
         }
         else {
+            path = normalizePath(path);
             boolean exist = new File(path).exists();
             boolean isDir = new File(path).isDirectory();
             callback.invoke(exist, isDir);
         }
-
     }
 
     /**
      * @param dest  Destination of created file
      * @param start Start byte offset in source file
      * @param end   End byte offset
-     * @param encode
+     * @param encode NOT IMPLEMENTED
      */
     public static void slice(String src, String dest, int start, int end, String encode, Promise promise) {
         try {
+            src = normalizePath(src);
             File source = new File(src);
             if(!source.exists()) {
                 promise.reject("RNFetchBlob.slice error", "source file : " + src + " not exists");
+                return;
             }
             long size = source.length();
             long max = Math.min(size, end);
      */
     static void stat(String path, Callback callback) {
         try {
+            path = normalizePath(path);
             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);
 
     /**
      * Create new file at path
-     * @param path
-     * @param data
-     * @param encoding
-     * @param callback
+     * @param path The destination path of the new file.
+     * @param data Initial data of the new file.
+     * @param encoding Encoding of initial data.
+     * @param callback RCT bridge callback.
      */
     static void createFile(String path, String data, String encoding, Callback callback) {
         try {
             return data.getBytes(Charset.forName("US-ASCII"));
         }
         else if(encoding.toLowerCase().contains("base64")) {
-            byte [] b = Base64.decode(data, Base64.NO_WRAP);
-            return b;
+            return Base64.decode(data, Base64.NO_WRAP);
+
         }
         else if(encoding.equalsIgnoreCase("utf8")) {
             return data.getBytes(Charset.forName("UTF-8"));
     /**
      * 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
+     * @param path The file to open stream
+     * @return InputStream instance
      * @throws IOException
      */
     static InputStream inputStreamFromPath(String path) throws IOException {
 
     /**
      * Check if the asset or the file exists
-     * @param path
-     * @return
+     * @param path A file path URI string
+     * @return A boolean value represents if the path exists.
      */
     static boolean isPathExists(String path) {
         if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {

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

 package com.RNFetchBlob;
 
 import com.facebook.react.ReactPackage;
-import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.JavaScriptModule;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.uimanager.ViewManager;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-/**
- * Created by wkh237 on 2016/4/29.
- */
+
 public class RNFetchBlobPackage implements ReactPackage {
 
     @Override

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

 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.concurrent.TimeUnit;
 
 import okhttp3.Response;
 import okhttp3.ResponseBody;
 
-
-/**
- * Created by wkh237 on 2016/6/21.
- */
 public class RNFetchBlobReq extends BroadcastReceiver implements Runnable {
 
     enum RequestType  {
         AsIs,
         WithoutBody,
         Others
-    };
+    }
 
     enum ResponseType {
         KeepInMemory,
         FileStorage
-    };
+    }
 
     public static HashMap<String, Call> taskTable = new HashMap<>();
     static HashMap<String, Boolean> progressReport = new HashMap<>();
     ResponseType responseType;
     WritableMap respInfo;
     boolean timeout = false;
+    ArrayList<String> redirects = new ArrayList<>();
 
     public RNFetchBlobReq(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, ReadableArray arrayBody, final Callback callback) {
         this.method = method.toUpperCase();
             responseType = ResponseType.KeepInMemory;
 
 
-		if (body != null)
+        if (body != null)
             requestType = RequestType.SingleFile;
         else if (arrayBody != null)
             requestType = RequestType.Form;
 
         // find cached result if `key` property exists
         String cacheKey = this.taskId;
-		String ext = this.options.appendExt.isEmpty() ? "." + this.options.appendExt : "";
+        String ext = this.options.appendExt.isEmpty() ? "." + this.options.appendExt : "";
 
-       	if (this.options.key != null) {
-           cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
-           if (cacheKey == null) {
-               cacheKey = this.taskId;
-           }
+        if (this.options.key != null) {
+            cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
+            if (cacheKey == null) {
+                cacheKey = this.taskId;
+            }
 
-           File file = new File(RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext);
+            File file = new File(RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext);
 
-           if (file.exists()) {
-               callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, file.getAbsolutePath());
-               return;
-           }
-       }
+            if (file.exists()) {
+                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, file.getAbsolutePath());
+                return;
+            }
+        }
 
         if(this.options.path != null)
             this.destPath = this.options.path;
                 requestType = RequestType.WithoutBody;
             }
 
+            boolean isChunkedRequest = getHeaderIgnoreCases(mheaders, "Transfer-Encoding").equalsIgnoreCase("chunked");
 
             // set request body
             switch (requestType) {
                 case SingleFile:
-                    requestBody = new RNFetchBlobBody(
-                            taskId,
-                            requestType,
-                            rawRequestBody,
-                            MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type"))
-                    );
+                    requestBody = new RNFetchBlobBody(taskId)
+                            .chunkedEncoding(isChunkedRequest)
+                            .setRequestType(requestType)
+                            .setBody(rawRequestBody)
+                            .setMIME(MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type")));
                     builder.method(method, requestBody);
                     break;
                 case AsIs:
-                    requestBody = new RNFetchBlobBody(
-                            taskId,
-                            requestType,
-                            rawRequestBody,
-                            MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type"))
-                    );
+                    requestBody = new RNFetchBlobBody(taskId)
+                            .chunkedEncoding(isChunkedRequest)
+                            .setRequestType(requestType)
+                            .setBody(rawRequestBody)
+                            .setMIME(MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type")));
                     builder.method(method, requestBody);
                     break;
                 case Form:
                     String boundary = "RNFetchBlob-" + taskId;
-                    requestBody = new RNFetchBlobBody(
-                            taskId,
-                            requestType,
-                            rawRequestBodyArray,
-                            MediaType.parse("multipart/form-data; boundary="+ boundary)
-                    );
+                    requestBody = new RNFetchBlobBody(taskId)
+                            .chunkedEncoding(isChunkedRequest)
+                            .setRequestType(requestType)
+                            .setBody(rawRequestBodyArray)
+                            .setMIME(MediaType.parse("multipart/form-data; boundary="+ boundary));
                     builder.method(method, requestBody);
                     break;
 
             }
 
             final Request req = builder.build();
-
+            clientBuilder.addNetworkInterceptor(new Interceptor() {
+                @Override
+                public Response intercept(Chain chain) throws IOException {
+                        redirects.add(chain.request().url().toString());
+                        return chain.proceed(chain.request());
+                    }
+            });
             // Add request interceptor for upload progress event
             clientBuilder.addInterceptor(new Interceptor() {
                 @Override
             clientBuilder.retryOnConnectionFailure(false);
             clientBuilder.followRedirects(true);
 
+
             OkHttpClient client = clientBuilder.retryOnConnectionFailure(true).build();
             Call call =  client.newCall(req);
             taskTable.put(taskId, call);
                 try {
                     // For XMLHttpRequest, automatic response data storing strategy, when response
                     // data is considered as binary data, write it to file system
-                    if(isBlobResp && options.auto == true) {
+                    if(isBlobResp && options.auto) {
                         String dest = RNFetchBlobFS.getTmpPath(ctx, taskId);
                         InputStream ins = resp.body().byteStream();
                         FileOutputStream os = new FileOutputStream(new File(dest));
                     // It uses customized response body which is able to report download progress
                     // and write response data to destination path.
                     resp.body().bytes();
-                } catch (Exception ignored) {  }
+                } catch (Exception ignored) {
+                    ignored.printStackTrace();
+                }
                 callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 break;
             default:
                 }
                 break;
         }
-//        if(!resp.isSuccessful())
-//            resp.body().close();
-        resp.body().close();
+        if(!resp.isSuccessful())
+            resp.body().close();
         releaseTaskResource();
     }
 
     }
 
     /**
-     * Create response information object, conatins status code, headers, etc.
-     * @param resp
-     * @param isBlobResp
-     * @return
+     * Create response information object, contains status code, headers, etc.
+     * @param resp Response object
+     * @param isBlobResp If the response is binary data
+     * @return Get RCT bridge object contains response information.
      */
     private WritableMap getResponseInfo(Response resp, boolean isBlobResp) {
         WritableMap info = Arguments.createMap();
         for(int i =0;i< resp.headers().size();i++) {
             headers.putString(resp.headers().name(i), resp.headers().value(i));
         }
+        WritableArray redirectList = Arguments.createArray();
+        for(String r : redirects) {
+                redirectList.pushString(r);
+        }
+        info.putArray("redirects", redirectList);
         info.putMap("headers", headers);
         Headers h = resp.headers();
         if(isBlobResp) {
     /**
      * Check if response data is binary data.
      * @param resp OkHttp response.
-     * @return
+     * @return If the response data contains binary bytes
      */
     private boolean isBlobResponse(Response resp) {
         Headers h = resp.headers();

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

 
 import okhttp3.OkHttpClient;
 
-/**
- * Created by wkh237 on 2016/7/11.
- */
+
 public class RNFetchBlobUtils {
 
     public static String getMD5(String input) {

src/class/RNFetchBlobReadStream.js

   DeviceEventEmitter,
   NativeAppEventEmitter,
 } from 'react-native'
+import UUID from '../utils/uuid'
 
 const RNFetchBlob = NativeModules.RNFetchBlob
 const emitter = DeviceEventEmitter
   encoding : 'utf8' | 'ascii' | 'base64';
   bufferSize : ?number;
   closed : boolean;
+  tick : number = 10;
 
-  constructor(path:string, encoding:string, bufferSize?:?number) {
+  constructor(path:string, encoding:string, bufferSize?:?number, tick:number) {
     if(!path)
       throw Error('RNFetchBlob could not open file stream with empty `path`')
     this.encoding = encoding || 'utf8'
     this.bufferSize = bufferSize
     this.path = path
     this.closed = false
+    this.tick = tick
     this._onData = () => {}
     this._onEnd = () => {}
     this._onError = () => {}
+    this.streamId = 'RNFBRS'+ UUID()
 
     // register for file stream event
-    let subscription = emitter.addListener(`RNFetchBlobStream+${this.path}`, (e) => {
-
+    let subscription = emitter.addListener(this.streamId, (e) => {
       let {event, detail} = e
-      if(this._onData && event === 'data')
+      if(this._onData && event === 'data') {
         this._onData(detail)
+        return
+      }
       else if (this._onEnd && event === 'end') {
         this._onEnd(detail)
       }
 
   open() {
     if(!this.closed)
-      RNFetchBlob.readStream(this.path, this.encoding, this.bufferSize || 0)
+      RNFetchBlob.readStream(this.path, this.encoding, this.bufferSize || 10240 , this.tick || -1, this.streamId)
     else
       throw new Error('Stream closed')
   }
 
-  onData(fn) {
-    if(this.encoding.toLowerCase() === 'ascii')
-      this._onData = (data) => {
-        fn(data)
-      }
-    else
-      this._onData = fn
+  onData(fn:() => void) {
+    this._onData = fn
   }
 
   onError(fn) {

src/fs.js

 function readStream(
   path : string,
   encoding : 'utf8' | 'ascii' | 'base64',
-  bufferSize? : ?number
+  bufferSize? : ?number,
+  tick : ?number = 10
 ):Promise<RNFetchBlobReadStream> {
-  return Promise.resolve(new RNFetchBlobReadStream(path, encoding, bufferSize))
+  return Promise.resolve(new RNFetchBlobReadStream(path, encoding, bufferSize, tick))
 }
 
 /**

src/index.js

       delete promise['uploadProgress']
       delete promise['stateChange']
       delete promise['cancel']
-      promise.cancel = () => {
-        console.warn('finished request could not be canceled')
-      }
+      promise.cancel = () => {}
 
       if(err)
         reject(new Error(err, respInfo))
   path : () => string | null;
   type : 'base64' | 'path' | 'utf8';
   data : any;
-  blob : (contentType:string, sliceSize:number) => null;
-  text : () => string;
+  blob : (contentType:string, sliceSize:number) => Promise<Blob>;
+  text : () => string | Promise<any>;
   json : () => any;
   base64 : () => any;
   flush : () => void;
   respInfo : RNFetchBlobResponseInfo;
   session : (name:string) => RNFetchBlobSession | null;
-  readFile : (encode: 'base64' | 'utf8' | 'ascii') => ?Promise;
+  readFile : (encode: 'base64' | 'utf8' | 'ascii') => ?Promise<any>;
   readStream : (
     encode: 'utf8' | 'ascii' | 'base64',
   ) => RNFetchBlobStream | null;
      * Convert result to text.
      * @return {string} Decoded base64 string.
      */
-    this.text = ():string => {
+    this.text = ():string | Promise<any> => {
       let res = this.data
       switch(this.type) {
         case 'base64':
           return base64.decode(this.data)
-        break
         case 'path':
           return fs.readFile(this.data, 'base64').then((b64) => Promise.resolve(base64.decode(b64)))
-        break
         default:
           return this.data
-        break
       }
     }
     /**
       switch(this.type) {
         case 'base64':
           return JSON.parse(base64.decode(this.data))
-        break
         case 'path':
           return fs.readFile(this.data, 'utf8')
                    .then((text) => Promise.resolve(JSON.parse(text)))
-        break
         default:
           return JSON.parse(this.data)
-        break
       }
     }
     /**
      * Return BASE64 string directly.
      * @return {string} BASE64 string of response body.
      */
-    this.base64 = ():string => {
+    this.base64 = ():string | Promise<any> => {
       switch(this.type) {
         case 'base64':
           return this.data
-        break
         case 'path':
           return fs.readFile(this.data, 'base64')
-        break
         default:
           return base64.encode(this.data)
-        break
       }
     }
     /**
     this.readFile = (encode: 'base64' | 'utf8' | 'ascii') => {
       if(this.type === 'path') {
         encode = encode || 'utf8'
-
         return readFile(this.data, encode)
       }
       else {

src/ios/IOS7Polyfill.h

+//
+//  IOS7Polyfill.h
+//  RNFetchBlob
+//
+//  Created by Ben Hsieh on 2016/9/6.
+//  Copyright © 2016年 wkh237.github.io. All rights reserved.
+//
+
+#ifndef IOS7Polyfill_h
+#define IOS7Polyfill_h
+
+@interface NSString (Contains)
+
+- (BOOL)RNFBContainsString:(NSString*)other;
+
+@end
+
+@implementation NSString (Contains)
+
+- (BOOL)RNFBContainsString:(NSString*)other {
+    NSRange range = [self rangeOfString:other];
+    return range.length != 0;
+}
+
+
+@end
+#endif /* IOS7Polyfill_h */

src/ios/RNFetchBlob.xcodeproj/project.pbxproj

 		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>"; };
+		A1F950181D7E9134002A95A6 /* IOS7Polyfill.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = IOS7Polyfill.h; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
 		A15C30051CD25C330074CB35 = {
 			isa = PBXGroup;
 			children = (
+				A1F950181D7E9134002A95A6 /* IOS7Polyfill.h */,
 				A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */,
 				A1AAE2971D300E3E0051D11C /* RNFetchBlobReqBuilder.h */,
 				A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */,
 			isa = PBXProject;
 			attributes = {
 				LastUpgradeCheck = 730;
-				ORGANIZATIONNAME = suzuri04x2;
+				ORGANIZATIONNAME = wkh237.github.io;
 				TargetAttributes = {
 					A15C300D1CD25C330074CB35 = {
 						CreatedOnToolsVersion = 7.3;

src/ios/RNFetchBlob/RNFetchBlob.h

 }
 
 @property (nonatomic) NSString * filePathPrefix;
-@property (nonatomic, strong) UIDocumentInteractionController *documentController;
+
++ (RCTBridge *)getRCTBridge;
 
 @end
 

src/ios/RNFetchBlob/RNFetchBlob.m

 //
 
 #import "RNFetchBlob.h"
-#import "RCTConvert.h"
 #import "RCTLog.h"
 #import "RCTBridge.h"
 #import "RCTEventDispatcher.h"
 #import "RNFetchBlobReqBuilder.h"
 
 
+RCTBridge * bridgeRef;
+dispatch_queue_t commonTaskQueue;
+dispatch_queue_t fsQueue;
+
 ////////////////////////////////////////
 //
 //  Exported native methods
 @synthesize bridge = _bridge;
 
 - (dispatch_queue_t) methodQueue {
-    return dispatch_queue_create("RNFetchBlob.queue", DISPATCH_QUEUE_SERIAL);
+    if(commonTaskQueue == nil)
+        commonTaskQueue = dispatch_queue_create("RNFetchBlob.queue", DISPATCH_QUEUE_SERIAL);
+    return commonTaskQueue;
+}
+
++ (RCTBridge *)getRCTBridge
+{
+    return bridgeRef;
 }
 
 RCT_EXPORT_MODULE();
 - (id) init {
     self = [super init];
     self.filePathPrefix = FILE_PREFIX;
+    if(commonTaskQueue == nil)
+        commonTaskQueue = dispatch_queue_create("RNFetchBlob.queue", DISPATCH_QUEUE_SERIAL);
+    if(fsQueue == nil)
+        fsQueue = dispatch_queue_create("RNFetchBlob.fs.queue", DISPATCH_QUEUE_SERIAL);
     BOOL isDir;
     // if temp folder not exists, create one
     if(![[NSFileManager defaultManager] fileExistsAtPath: [RNFetchBlobFS getTempPath] isDirectory:&isDir]) {
         [[NSFileManager defaultManager] createDirectoryAtPath:[RNFetchBlobFS getTempPath] withIntermediateDirectories:YES attributes:nil error:NULL];
     }
+    bridgeRef = _bridge;
     return self;
 }
 
     }];
 }
 
+#pragma mark - fs.createFile
 RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
 
     NSFileManager * fm = [NSFileManager defaultManager];
         callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
 
 }
-
+#pragma mark - fs.createFileASCII
 // method for create file with ASCII content
 RCT_EXPORT_METHOD(createFileASCII:(NSString *)path data:(NSArray *)dataArray callback:(RCTResponseSenderBlock)callback) {
 
 
 }
 
-
+#pragma mark - fs.exists
 RCT_EXPORT_METHOD(exists:(NSString *)path callback:(RCTResponseSenderBlock)callback) {
-    BOOL isDir = NO;
-    BOOL exists = NO;
-    exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
-    callback(@[@(exists), @(isDir)]);
-
+    [RNFetchBlobFS exists:path callback:callback];
 }
 
+#pragma mark - fs.writeFile
 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:[NSString stringWithString:encoding] data:data append:append resolver:resolve rejecter:reject];
 })
 
+#pragma mark - fs.writeArray
 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];
 })
 
+#pragma mark - fs.writeStream
 RCT_EXPORT_METHOD(writeStream:(NSString *)path withEncoding:(NSString *)encoding appendData:(BOOL)append callback:(RCTResponseSenderBlock)callback) {
     RNFetchBlobFS * fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     NSFileManager * fm = [NSFileManager defaultManager];
     callback(@[[NSNull null], streamId]);
 }
 
+#pragma mark - fs.writeArrayChunk
 RCT_EXPORT_METHOD(writeArrayChunk:(NSString *)streamId withArray:(NSArray *)dataArray callback:(RCTResponseSenderBlock) callback) {
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     char * bytes = (char *) malloc([dataArray count]);
     callback(@[[NSNull null]]);
 }
 
+#pragma mark - fs.writeChunk
 RCT_EXPORT_METHOD(writeChunk:(NSString *)streamId withData:(NSString *)data callback:(RCTResponseSenderBlock) callback) {
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     [fs writeEncodeChunk:data];
     callback(@[[NSNull null]]);
 }
 
+#pragma mark - fs.closeStream
 RCT_EXPORT_METHOD(closeStream:(NSString *)streamId callback:(RCTResponseSenderBlock) callback) {
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     [fs closeOutStream];
     callback(@[[NSNull null], @YES]);
 }
 
+#pragma mark - unlink
 RCT_EXPORT_METHOD(unlink:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     NSString * tmpPath = nil;
         callback(@[[NSString stringWithFormat:@"failed to unlink file or path at %@", path]]);
 }
 
+#pragma mark - fs.removeSession
 RCT_EXPORT_METHOD(removeSession:(NSArray *)paths callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     NSString * tmpPath = nil;
 
 }
 
+#pragma mark - fs.ls
 RCT_EXPORT_METHOD(ls:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
 
 }
 
-RCT_EXPORT_METHOD(stat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
-    NSFileManager* fm = [NSFileManager defaultManager];
-    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]]);
-        return ;
-    }
-    NSData * res = [RNFetchBlobFS stat:path error:&error];
-
-    if(error == nil)
-        callback(@[[NSNull null], res]);
-    else
-        callback(@[[error localizedDescription], [NSNull null]]);
+#pragma mark - fs.stat
+RCT_EXPORT_METHOD(stat:(NSString *)target callback:(RCTResponseSenderBlock) callback) {
+    
+    [RNFetchBlobFS getPathFromUri:target completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        __block NSMutableArray * result;
+        if(path != nil)
+        {
+            NSFileManager* fm = [NSFileManager defaultManager];
+            BOOL exist = nil;
+            BOOL isDir = nil;
+            NSError * error = nil;
+            
+            exist = [fm fileExistsAtPath:path isDirectory:&isDir];
+            if(exist == NO) {
+                callback(@[[NSString stringWithFormat:@"failed to stat path `%@` for it is not exist or it is not exist", path]]);
+                return ;
+            }
+            result = [RNFetchBlobFS stat:path error:&error];
+            
+            if(error == nil)
+                callback(@[[NSNull null], result]);
+            else
+                callback(@[[error localizedDescription], [NSNull null]]);
 
+        }
+        else if(asset != nil)
+        {
+            __block NSNumber * size = [NSNumber numberWithLong:[asset size]];
+            result = [asset metadata];
+            [result setValue:size forKey:@"size"];
+            callback(@[[NSNull null], result]);
+        }
+        else
+        {
+            callback(@[@"failed to stat path, could not resolve URI", [NSNull null]]);
+        }
+    }];
 }
 
+#pragma mark - fs.lstat
 RCT_EXPORT_METHOD(lstat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
 
 }
 
-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)
-        callback(@[[NSNull null], @YES]);
-    else
-        callback(@[[error localizedDescription], @NO]);
-
+#pragma mark - fs.cp
+RCT_EXPORT_METHOD(cp:(NSString*)src toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
+    
+//    path = [RNFetchBlobFS getPathOfAsset:path];
+    [RNFetchBlobFS getPathFromUri:src completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        NSError * error = nil;
+        if(path == nil)
+        {
+            [RNFetchBlobFS writeAssetToPath:asset dest:dest];
+            callback(@[[NSNull null], @YES]);
+        }
+        else
+        {
+            BOOL result = [[NSFileManager defaultManager] copyItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
+            
+            if(error == nil)
+                callback(@[[NSNull null], @YES]);
+            else
+                callback(@[[error localizedDescription], @NO]);
+        }
+    }];
+    
 }
 
+
+#pragma mark - fs.mv
 RCT_EXPORT_METHOD(mv:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     BOOL result = [[NSFileManager defaultManager] moveItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
 
 }
 
+#pragma mark - fs.mkdir
 RCT_EXPORT_METHOD(mkdir:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
-    if([RNFetchBlobFS exists:path]) {
+    if([[NSFileManager defaultManager] fileExistsAtPath:path]) {
         callback(@[@"mkdir failed, folder already exists"]);
         return;
     }
     callback(@[[NSNull null]]);
 }
 
+#pragma mark - fs.readFile
 RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
 
     [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject onComplete:nil];
 })
 
-RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
-
-    RNFetchBlobFS *fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
+#pragma mark - fs.readStream
+RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize tick:(int)tick streamId:(NSString *)streamId
+{
     if(bufferSize == nil) {
         if([[encoding lowercaseString] isEqualToString:@"base64"])
             bufferSize = 4095;
         else
             bufferSize = 4096;
     }
-    // read asset stream
-    [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
-}
+    
+    dispatch_async(fsQueue, ^{
+        [RNFetchBlobFS readStream:path encoding:encoding bufferSize:bufferSize tick:tick streamId:streamId bridgeRef:_bridge];
+    });
+})
 
+#pragma mark - fs.getEnvionmentDirs
 RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
 
     callback(@[
                ]);
 }
 
+#pragma mark - net.cancelRequest
 RCT_EXPORT_METHOD(cancelRequest:(NSString *)taskId callback:(RCTResponseSenderBlock)callback) {
     [RNFetchBlobNetwork cancelRequest:taskId];
     callback(@[[NSNull null], taskId]);
 
 }
 
+#pragma mark - net.enableProgressReport
 RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId {
     [RNFetchBlobNetwork enableProgressReport:taskId];
 })
 
+#pragma mark - net.enableUploadProgressReport
 RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId {
     [RNFetchBlobNetwork enableUploadProgress:taskId];
 })
 
+#pragma mark - fs.slice
 RCT_EXPORT_METHOD(slice:(NSString *)src dest:(NSString *)dest start:(nonnull NSNumber *)start end:(nonnull NSNumber *)end resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
 {
     [RNFetchBlobFS slice:src dest:dest start:start end:end encode:@"" resolver:resolve rejecter:reject];

src/ios/RNFetchBlobFS.h

 + (RNFetchBlobFS *) getFileStreams;
 + (BOOL) mkdir:(NSString *) path;
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error;
-+ (BOOL) exists:(NSString *) path;
++ (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback;
 + (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject onComplete:(void (^)(NSData * content))onComplete;
 + (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
-+ (void)slice:(NSString *)path
++ (void) slice:(NSString *)path
          dest:(NSString *)dest
         start:(nonnull NSNumber *)start
           end:(nonnull NSNumber *)end
      resolver:(RCTPromiseResolveBlock)resolve
      rejecter:(RCTPromiseRejectBlock)reject;
 //+ (void) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append;
++ (void) writeAssetToPath:(ALAssetRepresentation * )rep dest:(NSString *)dest;
++ (void) readStream:(NSString *)uri encoding:(NSString * )encoding bufferSize:(int)bufferSize tick:(int)tick streamId:(NSString *)streamId bridgeRef:(RCTBridge *)bridgeRef;
 
 // constructor
 - (id) init;
 // file stream
 - (void) openWithDestination;
 - (NSString *)openWithPath:(NSString *)destPath encode:(nullable NSString *)encode appendData:(BOOL)append;
-- (void) startAssetReadStream:(NSData *)assetUrl;
 
 // file stream write data
 - (void)write:(NSData *) chunk;
 - (void)writeEncodeChunk:(NSString *) chunk;
-- (void)readWithPath:(NSString *)path useEncoding:(NSString *)encoding bufferSize:(int) bufferSize;
 
 - (void) closeInStream;
 - (void) closeOutStream;

src/ios/RNFetchBlobFS.m

-//
+
 //  RNFetchBlobFS.m
 //  RNFetchBlob
 //
 //
 
 
-#import "RCTConvert.h"
-#import "RCTLog.h"
 #import <Foundation/Foundation.h>
 #import "RCTBridge.h"
+#import "RNFetchBlob.h"
 #import "RCTEventDispatcher.h"
 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobConst.h"
+#import "IOS7Polyfill.h"
 @import AssetsLibrary;
 
 
 @synthesize appendData;
 @synthesize bufferSize;
 
+- (id)init {
+    self = [super init];
+    return self;
+}
+
+- (id)initWithCallback:(RCTResponseSenderBlock)callback {
+    self = [super init];
+    self.callback = callback;
+    return self;
+}
+
+- (id)initWithBridgeRef:(RCTBridge *)bridgeRef {
+    self = [super init];
+    self.bridge = bridgeRef;
+    return self;
+}
+
 // static member getter
 + (NSArray *) getFileStreams {
     
     return tempPath;
 }
 
-#pragma mark - read asset stream
+#pragma margk - readStream 
 
-- (void) startAssetReadStream:(NSString *)assetUrl
++ (void) readStream:(NSString *)uri
+           encoding:(NSString * )encoding
+         bufferSize:(int)bufferSize
+               tick:(int)tick
+           streamId:(NSString *)streamId
+          bridgeRef:(RCTBridge *)bridgeRef
 {
-    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)
+    [[self class] getPathFromUri:uri completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+    
+        __block RCTEventDispatcher * event = bridgeRef.eventDispatcher;
+        __block int read = 0;
+        __block int backoff = tick *1000;
+        __block int chunkSize = bufferSize;
+        // allocate buffer in heap instead of stack
+        uint8_t * buffer;
+        @try
+        {
+            buffer = (uint8_t *) malloc(bufferSize);
+            if(path != nil)
             {
-                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];
+                if([[NSFileManager defaultManager] fileExistsAtPath:path] == NO)
+                {
+                    NSString * message = [NSString stringWithFormat:@"File not exists at path %@", path];
+                    NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"detail": message };
+                    [event sendDeviceEventWithName:streamId body:payload];
+                    free(buffer);
+                    return ;
                 }
-                // 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)
+                NSInputStream * stream = [[NSInputStream alloc] initWithFileAtPath:path];
+                [stream open];
+                while((read = [stream read:buffer maxLength:bufferSize]) > 0)
+                {
+                    [[self class] emitDataChunks:[NSData dataWithBytes:buffer length:read] encoding:encoding streamId:streamId event:event];
+                    if(tick > 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]]];
-                        }
+                        usleep(backoff);
                     }
-                    
-                    [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;
+                [stream close];
+            }
+            else if (asset != nil)
+            {
+                int cursor = 0;
+                NSError * err;
+                while((read = [asset getBytes:buffer fromOffset:cursor length:bufferSize error:&err]) > 0)
+                {
+                    cursor += read;
+                    [[self class] emitDataChunks:[NSData dataWithBytes:buffer length:read] encoding:encoding streamId:streamId event:event];
+                    if(tick > 0)
+                    {
+                        usleep(backoff);
+                    }
                 }
-                
-                [self.bridge.eventDispatcher
-                 sendDeviceEventWithName:streamEventCode
-                 body:@{
-                        @"event": FS_EVENT_DATA,
-                        @"detail": encodedChunk
-                        }
-                 ];
             }
-            free(buffer);
-        });
+            else
+            {
+                NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"detail": @"RNFetchBlob.readStream unable to resolve URI" };
+                [event sendDeviceEventWithName:streamId body:payload];
+            }
+            // release buffer
+            if(buffer != nil)
+                free(buffer);
+            
+        }
+        @catch (NSError * err)
+        {
+            NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"detail": [NSString stringWithFormat:@"RNFetchBlob.readStream error %@", [err description]] };
+            [event sendDeviceEventWithName:streamId body:payload];
+        }
+        @finally
+        {
+            NSDictionary * payload = @{ @"event": FS_EVENT_END, @"detail": @"" };
+            [event sendDeviceEventWithName:streamId body:payload];
+        }
         
-    };
+    }];
     
-    ALAssetsLibraryAccessFailureBlock failureblock  = ^(NSError *error)
+}
+
+// send read stream chunks via native event emitter
++ (void) emitDataChunks:(NSData *)data encoding:(NSString *) encoding streamId:(NSString *)streamId event:(RCTEventDispatcher *)event
+{
+    NSString * encodedChunk = @"";
+    if([[encoding lowercaseString] isEqualToString:@"utf8"])
     {
-        
-    };
-    
-    if(assetUrl && [assetUrl length])
+        NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] };
+        [event sendDeviceEventWithName:streamId body:payload];
+    }
+    else if ([[encoding lowercaseString] isEqualToString:@"base64"])
     {
-        NSURL *asseturl = [NSURL URLWithString:assetUrl];
-        ALAssetsLibrary* assetslibrary = [[ALAssetsLibrary alloc] init];
-        [assetslibrary assetForURL:asseturl
-                       resultBlock:resultblock
-                      failureBlock:failureblock];
+        NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : [data base64EncodedStringWithOptions:0] };
+        [event sendDeviceEventWithName:streamId body:payload];
+    }
+    else if([[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 (data.length > 0)
+        {
+            bytePtr = (unsigned char *)[data bytes];
+            NSInteger byteLen = data.length/sizeof(uint8_t);
+            for (int i = 0; i < byteLen; i++)
+            {
+                [asciiArray addObject:[NSNumber numberWithChar:bytePtr[i]]];
+            }
+        }
+
+        NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : asciiArray };
+        [event sendDeviceEventWithName:streamId body:payload];
     }
+    
+    
 }
 
 # pragma write file from file
 
-+ (NSNumber *) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append
++ (NSNumber *) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append callback:(void(^)(NSString * errMsg, NSNumber *size))callback
 {
-    NSInputStream * is = [[NSInputStream alloc] initWithFileAtPath:src];
-    NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
-    [is open];
-    [os open];
-    uint8_t buffer[10240];
-    long written = 0;
-    int read = [is read:buffer maxLength:10240];
-    written += read;
-    while(read > 0) {
-        [os write:buffer maxLength:read];
-        read = [is read:buffer maxLength:10240];
-        written += read;
-    }
-    [os close];
-    [is close];
-    return [NSNumber numberWithLong:written];
+    [[self class] getPathFromUri:src completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        if(path != nil)
+        {
+            __block NSInputStream * is = [[NSInputStream alloc] initWithFileAtPath:path];
+            __block NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
+            [is open];
+            [os open];
+            uint8_t buffer[10240];
+            __block long written = 0;
+            int read = [is read:buffer maxLength:10240];
+            written += read;
+            while(read > 0) {
+                [os write:buffer maxLength:read];
+                read = [is read:buffer maxLength:10240];
+                written += read;
+            }
+            [os close];
+            [is close];
+            __block NSNumber * size = [NSNumber numberWithLong:written];
+            callback(nil, size);
+        }
+        else if(asset != nil)
+        {
+            
+            __block NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
+            int read = 0;
+            int cursor = 0;
+            __block long written = 0;
+            uint8_t buffer[10240];
+            [os open];
+            while((read = [asset getBytes:buffer fromOffset:cursor length:10240 error:nil]) > 0)
+            {
+                cursor += read;
+                [os write:buffer maxLength:read];
+            }
+            __block NSNumber * size = [NSNumber numberWithLong:written];
+            [os close];
+            callback(nil, size);
+        }
+        else
+            callback(@"failed to resolve path", nil);
+    }];
+    
+    return 0;
 }
 
 # pragma mark - write file
             [fm createFileAtPath:path contents:nil attributes:nil];
         }
         if(err != nil) {
-            reject(@"RNFetchBlob writeFile Error", @"could not create file at path", path);
+            reject(@"RNFetchBlob writeFile Error", @"could not create file at path", nil);
             return;
         }
         NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
         NSData * content = nil;
-        if([encoding containsString:@"base64"]) {
+        if([encoding RNFBContainsString:@"base64"]) {
             content = [[NSData alloc] initWithBase64EncodedString:data options:0];
         }
         else if([encoding isEqualToString:@"uri"]) {
-            NSNumber* size = [[self class] writeFileFromFile:data toFile:path append:append];
-            resolve(size);
+            NSNumber* size = [[self class] writeFileFromFile:data toFile:path append:append callback:^(NSString *errMsg, NSNumber *size) {
+                if(errMsg != nil)
+                    reject(@"RNFetchBlob writeFile Error", errMsg, nil);
+                else
+                    resolve(size);
+            }];
             return;
         }
         else {
             {
                 BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:path];
                 if(!exists) {
-                    reject(@"RNFetchBlobFS readFile error", @"file not exists", path);
+                    reject(@"RNFetchBlobFS readFile error", @"file not exists", [[NSError alloc]init]);
                     return;
                 }
                 fileContent = [NSData dataWithContentsOfFile:path];
 # pragma mark - stat
 
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error {
-    NSMutableDictionary *stat = [[NSMutableDictionary alloc] init];
+
+    
     BOOL isDir = NO;
     NSFileManager * fm = [NSFileManager defaultManager];
     if([fm fileExistsAtPath:path isDirectory:&isDir] == NO) {
              @"path" : path,
              @"lastModified" : [NSString stringWithFormat:@"%d", [lastModified timeIntervalSince1970]],
              @"type" : isDir ? @"directory" : @"file"
-             };
+            };
+    
 }
 
 # pragma mark - exists
 
-+ (BOOL) exists:(NSString *) path {
-    return [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:NULL];
-}
-
-- (id)init {
-    self = [super init];
-    return self;
-}
-
-- (id)initWithCallback:(RCTResponseSenderBlock)callback {
-    self = [super init];
-    self.callback = callback;
-    return self;
-}
-
-- (id)initWithBridgeRef:(RCTBridge *)bridgeRef {
-    self = [super init];
-    self.bridge = bridgeRef;
-    return self;
++ (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback
+{
+    [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        if(path != nil)
+        {
+            BOOL isDir = NO;
+            BOOL exists = NO;
+            exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
+            callback(@[@(exists), @(isDir)]);
+        }
+        else if(asset != nil)
+        {
+            callback(@[@YES, @NO]);
+        }
+        else
+        {
+            callback(@[@NO, @NO]);
+        }
+    }];
 }
 
 # pragma mark - open file stream
     
 }
 
-- (void)readWithPath:(NSString *)path useEncoding:(NSString *)encoding bufferSize:(int) bufferSize {
-    
-    self.inStream = [[NSInputStream alloc] initWithFileAtPath:path];
-    self.inStream.delegate = self;
-    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
-    dispatch_async(queue, ^ {
-        [inStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
-                            forMode:NSDefaultRunLoopMode];
-        [inStream open];
-        [[NSRunLoop currentRunLoop] run];
-        
-    });
-}
-
 // Slice a file into another file, generally for support Blob implementation.
 + (void)slice:(NSString *)path
          dest:(NSString *)dest
      resolver:(RCTPromiseResolveBlock)resolve
      rejecter:(RCTPromiseRejectBlock)reject
 {
-    long expected = [end longValue] - [start longValue];
-    long read = 0;
-    NSFileHandle * handle = [NSFileHandle fileHandleForReadingAtPath:path];
-    NSFileManager * fm = [NSFileManager defaultManager];
-    NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
-    [os open];
-    // abort for the source file not exists
-    if([fm fileExistsAtPath:path] == NO)
-    {
-        reject(@"RNFetchBlob slice failed : the file does not exists", path, nil);
-        return;
-    }
-    long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
-    long max = MIN(size, [end longValue]);
-    
-    if(![fm fileExistsAtPath:dest]) {
-        [fm createFileAtPath:dest contents:@"" attributes:nil];
-    }
-    [handle seekToFileOffset:[start longValue]];
-    while(read < expected)
+    [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset)
     {
-        
-        NSData * chunk;
-        long chunkSize = 0;
-        if([start longValue] + read + 10240 > max)
+        if(path != nil)
+        {
+            long expected = [end longValue] - [start longValue];
+            long read = 0;
+            NSFileHandle * handle = [NSFileHandle fileHandleForReadingAtPath:path];
+            NSFileManager * fm = [NSFileManager defaultManager];
+            NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
+            [os open];
+            // abort for the source file not exists
+            if([fm fileExistsAtPath:path] == NO)
+            {
+                reject(@"RNFetchBlob slice failed : the file does not exists", path, nil);
+                return;
+            }
+            long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
+            long max = MIN(size, [end longValue]);
+            
+            if(![fm fileExistsAtPath:dest]) {
+                [fm createFileAtPath:dest contents:@"" attributes:nil];
+            }
+            [handle seekToFileOffset:[start longValue]];
+            while(read < expected)
+            {
+                
+                NSData * chunk;
+                long chunkSize = 0;
+                if([start longValue] + read + 10240 > max)
+                {
+                    NSLog(@"read chunk %lu", max - read - [start longValue]);
+                    chunkSize = max - read - [start longValue];
+                    chunk = [handle readDataOfLength:chunkSize];
+                }
+                else
+                {
+                    NSLog(@"read chunk %lu", 10240);
+                    chunkSize = 10240;
+                    chunk = [handle readDataOfLength:10240];
+                }
+                if([chunk length] <= 0)
+                    break;
+                long remain = expected - read;
+                
+                [os write:[chunk bytes] maxLength:chunkSize];
+                read += [chunk length];
+            }
+            [handle closeFile];
+            [os close];
+            resolve(dest);
+        }
+        else if (asset != nil)
         {
-            NSLog(@"read chunk %lu", max - read - [start longValue]);
-            chunkSize = max - read - [start longValue];
-            chunk = [handle readDataOfLength:chunkSize];
+            long expected = [end longValue] - [start longValue];
+            long read = 0;
+            long chunkRead = 0;
+            NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
+            [os open];
+            long size = asset.size;
+            long max = MIN(size, [end longValue]);
+            
+            while(read < expected)
+            {
+                
+                uint8_t * chunk[10240];
+                long chunkSize = 0;
+                if([start longValue] + read + 10240 > max)
+                {
+                    NSLog(@"read chunk %lu", max - read - [start longValue]);
+                    chunkSize = max - read - [start longValue];
+                    chunkRead = [asset getBytes:chunk fromOffset:[start longValue] + read length:chunkSize error:nil];
+                }
+                else
+                {
+                    NSLog(@"read chunk %lu", 10240);
+                    chunkSize = 10240;
+                    chunkRead = [asset getBytes:chunk fromOffset:[start longValue] + read length:chunkSize error:nil];
+                }
+                if( chunkRead <= 0)
+                    break;
+                long remain = expected - read;
+                
+                [os write:chunk maxLength:chunkSize];
+                read += chunkRead;
+            }
+            [os close];
+            resolve(dest);
         }
         else
         {
-            NSLog(@"read chunk %lu", 10240);
-            chunkSize = 10240;
-            chunk = [handle readDataOfLength:10240];
+            reject(@"slice error",  [NSString stringWithFormat: @"could not resolve URI %@", path ], nil);
         }
-        if([chunk length] <= 0)
-            break;
-        long remain = expected - read;
-    
-        [os write:[chunk bytes] maxLength:chunkSize];
-        read += [chunk length];
-    }
-    [handle closeFile];
-    [os close];
-    resolve(dest);
-    
+        
+    }];
 }
 
 // close file read stream
     
 }
 
-#pragma mark RNFetchBlobFS read stream delegate
-
-- (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
-    
-    NSString * streamEventCode = [NSString stringWithFormat:@"RNFetchBlobStream+%@", self.path];
-    
-    switch(eventCode) {
-            
-            // write stream event
-        case NSStreamEventHasSpaceAvailable:
-        {
-            
-            
-        }
-            
-            // read stream incoming chunk
-        case NSStreamEventHasBytesAvailable:
-        {
-            NSMutableData * chunkData = [[NSMutableData alloc] init];
-            NSInteger chunkSize = 4096;
-            if([[self.encoding lowercaseString] isEqualToString:@"base64"])
-                chunkSize = 4095;
-            if(self.bufferSize > 0)
-                chunkSize = self.bufferSize;
-            uint8_t buf[chunkSize];
-            unsigned int len = 0;
-            len = [(NSInputStream *)stream read:buf maxLength:chunkSize];
-            // still have data in stream
-            if(len) {
-                [chunkData appendBytes:buf length:len];
-                // dispatch data event
-                NSString * encodedChunk = [NSString alloc];
-                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
-                        }
-                 ];
-            }
-            // end of stream
-            else {
-                [self.bridge.eventDispatcher
-                 sendDeviceEventWithName:streamEventCode
-                 body:@{
-                        @"event": FS_EVENT_END,
-                        @"detail": @""
-                        }
-                 ];
-            }
-            break;
-        }
-            
-            // stream error
-        case NSStreamEventErrorOccurred:
-        {
-            [self.bridge.eventDispatcher
-             sendDeviceEventWithName:streamEventCode
-             body:@{
-                    @"event": FS_EVENT_ERROR,
-                    @"detail": @"RNFetchBlob error when read file with stream, file may not exists"
-                    }
-             ];
-            break;
-        }
-            
-    }
-    
-}
 
 # pragma mark - get absolute path of resource
 
     }
 }
 
++ (void) writeAssetToPath:(ALAssetRepresentation * )rep dest:(NSString *)dest
+{
+    int read = 0;
+    int cursor = 0;
+    Byte * buffer = (Byte *)malloc(10240);
+    NSOutputStream * ostream = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
+    [ostream open];
+    while((read = [rep getBytes:buffer fromOffset:cursor length:10240 error:nil]) > 0)
+    {
+        cursor+=10240;
+        [ostream write:buffer maxLength:read];
+    }
+    [ostream close];
+    free(buffer);
+    return;
+}
+
 @end

src/ios/RNFetchBlobNetwork.m

 //  Copyright © 2016 wkh237. All rights reserved.
 //
 
-#import "RCTConvert.h"
 #import "RCTLog.h"
 #import <Foundation/Foundation.h>
 #import "RCTBridge.h"
 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
 #import "RNFetchBlobReqBuilder.h"
+#import "IOS7Polyfill.h"
 #import <CommonCrypto/CommonDigest.h>
 
 ////////////////////////////////////////
     long bodyLength;
     NSMutableDictionary * respInfo;
     NSInteger respStatus;
-    BOOL isInrement;
+    NSMutableArray * redirects;
 }
 
 @end
     self.expectedBytes = 0;
     self.receivedBytes = 0;
     self.options = options;
-    isInrement = [options valueForKey:@"increment"] == nil ? NO : [[options valueForKey:@"increment"] boolValue];
+    redirects = [[NSMutableArray alloc] init];
+    [redirects addObject:req.URL.absoluteString];
 
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
     NSString * ext = [self.options valueForKey:CONFIG_FILE_EXT];
         if(respCType != nil)
         {
             NSArray * extraBlobCTypes = [options objectForKey:CONFIG_EXTRA_BLOB_CTYPE];
-            if([respCType containsString:@"text/"])
+            if([respCType RNFBContainsString:@"text/"])
             {
                 respType = @"text";
             }
-            else if([respCType containsString:@"application/json"])
+            else if([respCType RNFBContainsString:@"application/json"])
             {
                 respType = @"json";
             }
             else if( extraBlobCTypes !=  nil) {
                 for(NSString * substr in extraBlobCTypes)
                 {
-                    if([respCType containsString:[substr lowercaseString]])
+                    if([respCType RNFBContainsString:[substr lowercaseString]])
                     {
                         respType = @"blob";
                         respFile = YES;
                      @"taskId": taskId,
                      @"state": @"2",
                      @"headers": headers,
+                     @"redirects": redirects,
                      @"respType" : respType,
                      @"timeout" : @NO,
                      @"status": [NSString stringWithFormat:@"%d", statusCode ]
     NSNumber * received = [NSNumber numberWithLong:[data length]];
     receivedBytes += [received longValue];
     NSString * chunkString = @"";
-    
+
     if(isInrement == YES)
     {
         chunkString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
     }
-    
+
     if(respFile == NO)
     {
         [respData appendData:data];
     }
 }
 
+- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
+{
+    [redirects addObject:[request.URL absoluteString]];
+    completionHandler(request);
+}
 
 @end

src/ios/RNFetchBlobReqBuilder.m

 #import "RNFetchBlobConst.h"
 #import "RNFetchBlobFS.h"
 #import "RCTLog.h"
+#import "IOS7Polyfill.h"
 
 @interface RNFetchBlobReqBuilder()
 {
     
     // send request
     __block NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString: encodedUrl]];
-    NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
+    __block NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
     NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
     NSNumber * timeStampObj = [NSNumber numberWithDouble: timeStamp];
 
     // generate boundary
-    NSString * boundary = [NSString stringWithFormat:@"RNFetchBlob%d", timeStampObj];
+    __block NSString * boundary = [NSString stringWithFormat:@"RNFetchBlob%d", timeStampObj];
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         __block NSMutableData * postData = [[NSMutableData alloc] init];
         // combine multipart/form-data body
             // generate octet-stream body
             if(body != nil) {
                 __block NSString * cType = [[self class] getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
+                __block NSString * transferEncoding = [[self class] getHeaderIgnoreCases:@"transfer-encoding" fromHeaders:mheaders];
                 // when headers does not contain a key named "content-type" (case ignored), use default content type
                 if(cType == nil)
                 {
                         return;
                     }
                     size = [[[NSFileManager defaultManager] attributesOfItemAtPath:orgPath error:nil] fileSize];
-                    [request setHTTPBodyStream: [NSInputStream inputStreamWithFileAtPath:orgPath ]];
+                    if(transferEncoding != nil && [[transferEncoding lowercaseString] isEqualToString:@"chunked"])
+                    {
+                        [request setHTTPBodyStream: [NSInputStream inputStreamWithFileAtPath:orgPath ]];
+                    }
+                    else
+                    {
+                        [request setHTTPBody:[NSData dataWithContentsOfFile:orgPath ]];
+                    }
                 }
                 // otherwise convert it as BASE64 data string
                 else {
                     
                     __block NSString * cType = [[self class]getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                     // when content-type is application/octet* decode body string using BASE64 decoder
-                    if([[cType lowercaseString] hasPrefix:@"application/octet"] || [[cType lowercaseString] containsString:@";base64"])
+                    if([[cType lowercaseString] hasPrefix:@"application/octet"] || [[cType lowercaseString] RNFBContainsString:@";base64"])
                     {
                         __block NSString * ncType = [[cType stringByReplacingOccurrencesOfString:@";base64" withString:@""]stringByReplacingOccurrencesOfString:@";BASE64" withString:@""];
                         if([mheaders valueForKey:@"content-type"] != nil)
 
 +(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData))onComplete
 {
-    NSMutableData * formData = [[NSMutableData alloc] init];
+    __block NSMutableData * formData = [[NSMutableData alloc] init];
     if(form == nil)
         onComplete(nil);
     else
         void __block (^getFieldData)(id field) = ^(id field)
         {
             NSString * name = [field valueForKey:@"name"];
-            NSString * content = [field valueForKey:@"data"];
+            __block NSString * content = [field valueForKey:@"data"];
             NSString * contentType = [field valueForKey:@"type"];
             // skip when the form field `name` or `data` is empty
             if(content == nil || name == nil)
                             i++;
                             if(i < count)
                             {
-                                getFieldData([form objectAtIndex:i]);
+                                __block NSDictionary * nextField = [form objectAtIndex:i];
+                                getFieldData(nextField);
                             }
                             else
+                            {
                                 onComplete(formData);
+                                getFieldData = nil;
+                            }
                         }];
                         return ;
                     }
                 [formData appendData:[[NSString stringWithFormat:@"Content-Type: %@\r\n\r\n", contentType] dataUsingEncoding:NSUTF8StringEncoding]];
                 [formData appendData:blobData];
                 [formData appendData:[[NSString stringWithFormat:@"\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
+                blobData = nil;
             }
             i++;
             if(i < count)
             {
-                getFieldData([form objectAtIndex:i]);
+                __block NSDictionary * nextField = [form objectAtIndex:i];
+                getFieldData(nextField);
             }
             else
+            {
                 onComplete(formData);
+                getFieldData = nil;
+            }
 
         };
-        getFieldData([form objectAtIndex:i]);
+        __block NSDictionary * nextField = [form objectAtIndex:i];
+        getFieldData(nextField);
     }
 }
 

src/package.json

 {
   "name": "react-native-fetch-blob",
-  "version": "0.9.4-beta.1",
+  "version": "0.9.4",
   "description": "A module provides upload, download, and files access API. Supports file stream read/write for process large files.",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "base-64": "0.1.0"
+    "base-64": "0.1.0",
+    "glob": "^7.0.6"
   },
   "keywords": [
     "react-native",

src/polyfill/Blob.js

     return this._ref
   }
 
+  static setLog(level:number) {
+    if(number === -1)
+      log.disable()
+    else
+      log.level(level)
+  }
+
   /**
    * RNFetchBlob Blob polyfill, create a Blob directly from file path, BASE64
    * encoded data, and string. The conversion is done implicitly according to
    * @param  {any} data Content of Blob object
    * @param  {any} mime Content type settings of Blob object, `text/plain`
    *                    by default
+   * @param  {boolean} defer When this argument set to `true`, blob constructor
+   *                         will not invoke blob created event automatically.
    */
-  constructor(data:any, cType:any) {
+  constructor(data:any, cType:any, defer:boolean) {
     super()
     cType = cType || {}
     this.cacheName = getBlobName()
       let size = 0
       this._ref = String(data.getRNFetchBlobRef())
       let orgPath = this._ref
+
       p = fs.exists(orgPath)
             .then((exist) =>  {
               if(exist)
       log.verbose('create Blob cache file from file path', data)
       this._ref = String(data).replace('RNFetchBlob-file://', '')
       let orgPath = this._ref
-      p = fs.stat(orgPath)
-            .then((stat) =>  {
+      if(defer)
+        return
+      else {
+        p = fs.stat(orgPath)
+              .then((stat) =>  {
                 return Promise.resolve(stat.size)
-            })
+              })
+      }
     }
     // content from variable need create file
     else if(typeof data === 'string') {
     let resPath = blobCacheDir + getBlobName()
     let pass = false
     log.debug('fs.slice new blob will at', resPath)
-    let result = new Blob(RNFetchBlob.wrap(resPath), { type : contentType })
+    let result = new Blob(RNFetchBlob.wrap(resPath), { type : contentType }, true)
     fs.slice(this._ref, resPath, start, end).then((dest) => {
       log.debug('fs.slice done', dest)
       result._invokeOnCreateEvent()
     if(this._closed)
       return Promise.reject('Blob has been released.')
     this._closed = true
-    return fs.unlink(this._ref)
+    return fs.unlink(this._ref).catch((err) => {
+      console.warn(err)
+    })
   }
 
   _invokeOnCreateEvent() {

src/polyfill/File.js

 
   name : string = '';
 
-  static build(name:string, data:any, cType):Promise<File> {
+  static build(name:string, data:any, cType:string):Promise<File> {
     return new Promise((resolve, reject) => {
       new File(data, cType).onCreated((f) => {
         f.name = name

src/polyfill/XMLHttpRequest.js

     return DONE
   }
 
+  static setLog(level:number) {
+    if(number === -1)
+      log.disable()
+    else
+      log.level(level)
+  }
+
   static addBinaryContentType(substr:string) {
     for(let i in XMLHttpRequest.binaryContentTypes) {
       if(new RegExp(substr,'i').test(XMLHttpRequest.binaryContentTypes[i])) {

src/react-native-fetch-blob.podspec

+Pod::Spec.new do |s|
+  s.name             = "react-native-fetch-blob"
+  s.version          = "0.9.4"
+  s.summary          = "A project committed to make file acess and data transfer easier, effiecient for React Native developers."
+  s.requires_arc = true
+  s.license      = 'MIT'
+  s.homepage     = 'n/a'
+  s.authors      = { "wkh237" => "xeiyan@gmail.com" }
+  s.source       = { :git => "https://github.com/wkh237/react-native-fetch-blob", :tag => 'v0.9.4-beta.3'}
+  s.source_files = 'ios/**/*.{h,m}'
+  s.platform     = :ios, "7.0"
+  s.dependency 'React/Core'
+end

src/scripts/prelink.js

-var fs = require('fs');
+try {
+  var fs = require('fs');
+  var glob = require('glob');
+  var addAndroidPermissions = process.env.RNFB_ANDROID_PERMISSIONS == 'true';
+  var MANIFEST_PATH = glob.sync(process.cwd() + '/android/app/src/main/**/AndroidManifest.xml')[0];
+  var PACKAGE_JSON = process.cwd() + '/package.json';
+  var package = JSON.parse(fs.readFileSync(PACKAGE_JSON));
+  var APP_NAME = package.name;
+  var PACKAGE_GRADLE = process.cwd() + '/node_modules/react-native-fetch-blob/android/build.gradle'
+  var VERSION = checkVersion();
 
-var MANIFEST_PATH = process.cwd() + '/android/app/src/main/AndroidManifest.xml';
-var PACKAGE_JSON = process.cwd() + '/package.json';
+  console.log('RNFetchBlob detected app version => ' + VERSION);
 
-var hasNecessaryFile = fs.existsSync(MANIFEST_PATH) && fs.existsSync(PACKAGE_JSON);
-
-if (!hasNecessaryFile) {
-  throw 'RNFetchBlob could not link Android automatically, some files could not be found.'
-}
-
-var package = JSON.parse(fs.readFileSync(PACKAGE_JSON));
-var APP_NAME = package.name;
-var APPLICATION_MAIN = process.cwd() + '/android/app/src/main/java/com/' + APP_NAME.toLocaleLowerCase() + '/MainApplication.java';
-var PACKAGE_GRADLE = process.cwd() + '/node_modules/react-native-fetch-blob/android/build.gradle'
-
-var VERSION = checkVersion();
-console.log('RNFetchBlob detected app version .. ' + VERSION);
-
-if(VERSION >= 0.29) {
-  console.log('RNFetchBlob patching MainApplication.java .. ');
-  if(!fs.existsSync(APPLICATION_MAIN)) {
-    throw 'RNFetchBlob could not link Android automatically, MainApplication.java not found in path : ' + APPLICATION_MAIN
-  }
-  var main = fs.readFileSync(APPLICATION_MAIN);
-  if(String(main).match('new RNFetchBlobPackage()') !== null) {
-    console.log('skipped');
-    return
+  if(VERSION < 0.28) {
+    console.log('You project version is '+ VERSION + ' which may not compatible to react-native-fetch-blob 7.0+, please consider upgrade your application template to react-native 0.27+.')
+    // add OkHttp3 dependency fo pre 0.28 project
+    var main = fs.readFileSync(PACKAGE_GRADLE);
+    console.log('adding OkHttp3 dependency to pre 0.28 project .. ')
+    main = String(main).replace('//{RNFetchBlob_PRE_0.28_DEPDENDENCY}', "compile 'com.squareup.okhttp3:okhttp:3.4.1'");
+    fs.writeFileSync(PACKAGE_GRADLE, main);
+    console.log('adding OkHttp3 dependency to pre 0.28 project .. ok')
   }
-  main = String(main).replace('new MainReactPackage()', 'new RNFetchBlobPackage(),\n           new MainReactPackage()');
-  main = String(main).replace('import com.facebook.react.ReactApplication;', 'import com.facebook.react.ReactApplication;\nimport com.RNFetchBlob.RNFetchBlobPackage;')
 
-  fs.writeFileSync(APPLICATION_MAIN, main);
-  console.log('RNFetchBlob patching MainApplication.java .. ok')
+  console.log('Add Android permissions => ' + (addAndroidPermissions == "true"))
 
-}
+  if(addAndroidPermissions) {
 
-if(VERSION < 0.28) {
-  console.log('You project version is '+ VERSION + 'which does not meet requirement of react-native-fetch-blob 7.0+, please upgrade your application template to react-native 0.27+, otherwise Android application will not working.')
-  // add OkHttp3 dependency fo 0.28- project
-  var main = fs.readFileSync(PACKAGE_GRADLE);
-  console.log('adding OkHttp3 dependency to pre 0.28 project .. ')
-  main = String(main).replace('//{RNFetchBlob_PRE_0.28_DEPDENDENCY}', "compile 'com.squareup.okhttp3:okhttp:3.4.1'");
-  fs.writeFileSync(PACKAGE_GRADLE, main);
-  console.log('adding OkHttp3 dependency to pre 0.28 project .. ok')
-}
+    // set file access permission for Android < 6.0
+    fs.readFile(MANIFEST_PATH, function(err, data) {
 
-// set file access permission for Android < 6.0
-fs.readFile(MANIFEST_PATH, function(err, data) {
+      if(err)
+        console.log('failed to locate AndroidManifest.xml file, you may have to add file access permission manually.');
+      else {
 
-  if(err)
-    console.log('failed to locate AndroidManifest.xml file, you may have to add file access permission manually.');
-  else {
+        console.log('RNFetchBlob patching AndroidManifest.xml .. ');
+        // append fs permission
+        data = String(data).replace(
+          '<uses-permission android:name="android.permission.INTERNET" />',
+          '<uses-permission android:name="android.permission.INTERNET" />\n    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> '
+        )
+        // append DOWNLOAD_COMPLETE intent permission
+        data = String(data).replace(
+          '<category android:name="android.intent.category.LAUNCHER" />',
+          '<category android:name="android.intent.category.LAUNCHER" />\n     <action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>'
+        )
+        fs.writeFileSync(MANIFEST_PATH, data);
+        console.log('RNFetchBlob patching AndroidManifest.xml .. ok');
 
-    console.log('RNFetchBlob patching AndroidManifest.xml .. ');
-    // append fs permission
-    data = String(data).replace(
-      '<uses-permission android:name="android.permission.INTERNET" />',
-      '<uses-permission android:name="android.permission.INTERNET" />\n    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> '
-    )
-    // append DOWNLOAD_COMPLETE intent permission
-    data = String(data).replace(
-      '<category android:name="android.intent.category.LAUNCHER" />',
-      '<category android:name="android.intent.category.LAUNCHER" />\n     <action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>'
-    )
-    fs.writeFileSync(MANIFEST_PATH, data);
-    console.log('RNFetchBlob patching AndroidManifest.xml .. ok');
+      }
 
+    })
+  }
+  else {
+    console.log(
+      '\033[95mreact-native-fetch-blob \033[97mwill not automatically add Android permissions after \033[92m0.9.4 '+
+      '\033[97mplease run the following command if you want to add default permissions :\n\n' +
+      '\033[96m\tRNFB_ANDROID_PERMISSION=true react-native link \n')
   }
 
-})
+  function checkVersion() {
+    console.log('RNFetchBlob checking app version ..');
+    return parseFloat(/\d\.\d+(?=\.)/.exec(package.dependencies['react-native']));
+  }
 
-function checkVersion() {
-  console.log('RNFetchBlob checking app version ..');
-  return parseFloat(/\d\.\d+(?=\.)/.exec(package.dependencies['react-native']));
+} catch(err) {
+  console.log(
+    '\033[95mreact-native-fetch-blob\033[97m link \033[91mFAILED \033[97m\nCould not automatically link package :'+
+    err.stack +
+    'please follow the instructions to manually link the library : ' +
+    '\033[4mhttps://github.com/wkh237/react-native-fetch-blob/wiki/Manually-Link-Package\n')
 }

src/utils/log.js

   }
 
   level(val:number) {
+    this._isEnable = true
     this._level = val
   }
 
   }
 
   error(...args) {
-    this._isEnable && this._level > -1 && console.log(this._name, 'error:', ...args)
+    this._isEnable && this._level > -1 && console.warn(this._name, 'error:', ...args)
   }
 
 }

test-server/server.js

   next();
 })
 
+app.all('/upload', (req, res) => {
+  console.log(req.headers)
+  res.send(req.headers)
+})
+
 app.get('/unicode', (req, res) => {
   res.send({ data:'你好!'})
 })
   res.send(req.headers)
 })
 
-app.post('/upload', bodyParser.urlencoded({ extended : true }), (req, res) => {
+app.post('/upload_urlencode', bodyParser.urlencoded({ extended : true }), (req, res) => {
   console.log(JSON.stringify(req.headers))
   console.log(JSON.stringify(req.body))
   res.status(200).send(req.body)

test/test-0.7.0.js

     if(Date.now() - deb < 1000)
       return
     deb = Date.now()
+    console.log('download', now, total)
     report(<Info uid="200" key="progress">
       <Text>
         {`download ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s) ${(100*now/total).toFixed(2)}%`}
       if(Date.now() - deb < 1000)
         return
       deb = Date.now()
+      console.log('upload', now, total)
       report(<Info uid="300" key="upload progress">
         <Text>
           {`upload ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s) ${(100*now/total).toFixed(2)}%`}

test/test-0.9.4.js

   Platform,
   Dimensions,
   Image,
+  TouchableOpacity,
 } from 'react-native';
 
 window.XMLHttpRequest = RNFetchBlob.polyfill.XMLHttpRequest
     })
 
 })
+
+describe('issue #111 get redirect destination', (report, done) => {
+  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/redirect`)
+  .then((res) => {
+    console.log(res.info())
+    report(
+      <Assert key="redirect history should tracable"
+        expect={2}
+        actual={res.info().redirects.length}/>,
+      <Assert key="redirect history verify"
+        expect={[`${TEST_SERVER_URL}/redirect`, `${TEST_SERVER_URL}/public/github.png`]}
+        comparer={Comparer.equalToArray}
+        actual={res.info().redirects}/>,
+    )
+    done()
+  })
+})
+
+describe('chunked encoding option test', (report, done) => {
+
+  let path = null
+  let base64 = null
+
+  RNFetchBlob
+    // .config({ fileCache : true })
+    .fetch('GET', `${TEST_SERVER_URL}/public/1600k-img-dummy.jpg`)
+    .then((res) => {
+      base64 = res.base64()
+      return RNFetchBlob
+        .fetch('POST', `${TEST_SERVER_URL}/upload`, {
+          'Content-Type' : 'application/octet-stream;BASE64'
+        }, base64)
+    })
+    .then((res) => {
+      let headers = res.info().headers
+      console.log(res.text())
+      report(<Assert key="request should not use chunked encoding"
+        expect={undefined}
+        actual={headers['transfer-encoding']}/>)
+      fs.unlink(path)
+      done()
+    })
+})
+
+describe('#118 readStream performance prepare the file', (report, done) => {
+  let cache = null
+  let size = 0
+  let size2 = 0
+  let tick = Date.now()
+  let tick2 = Date.now()
+  let start = -1
+  let start2 = -1
+  let count = 0
+
+  let task = RNFetchBlob.config({fileCache : true})
+    .fetch('GET', `${TEST_SERVER_URL}/public/22mb-dummy`)
+  task.progress((current, total) => {
+    report(<Info key="prepare file" uid="prepare">
+      <Text key="pg"> {Math.floor(current/total*100)}% </Text>
+    </Info>)
+  })
+  task.then((res) => {
+      report(<Info key="preparation complete"><Text>start in 3 seconds</Text></Info>)
+      cache = res.path()
+      setTimeout(readFile, 2500)
+      function readFile() {
+        fs.readStream(cache, 'utf8', 102400, 10)
+          .then((stream) => {
+            stream.open()
+            start = Date.now()
+            stream.onData((chunk) => {
+              count++
+              size += chunk.length
+              if(Date.now() - tick > 500) {
+                console.log(size, ' read')
+                tick = Date.now()
+                report(
+                  <Info key="size" uid="100">
+                    <Text key="AA">File 1 {size}/22000000 bytes read</Text>
+                    <Text key="BB">File 2 {size2}/22000000 bytes read</Text>
+                  </Info>)
+              }
+            })
+            stream.onEnd(() => {
+              report(
+                <Info key="size" uid="100"><Text>{size} bytes read</Text></Info>,
+                <Info key="elapsed"><Text>{Date.now() - start} ms</Text></Info>,
+                <Info key="events"><Text>{count} times</Text></Info>,
+                <Assert key="JS thread is not blocked" expect={true} actual={true}/>,)
+              fs.stat(cache).then((stat) => {
+                report(
+                  <Info key="info"><Text>{JSON.stringify(stat)}</Text></Info>)
+                fs.unlink(cache)
+                done()
+              })
+            })
+          })
+      }
+    })
+})
+
+describe('issue #120 upload progress should work when sending body as-is', (report, done) => {
+
+  let data = RNTest.prop('image')
+  let tick = 0
+
+  let task = 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' : 'text/plain; charset=dropbox-cors-hack',
+  }, data)
+
+  task.uploadProgress((current, total) => {
+    tick ++
+  })
+  .then((res) => {
+    let resp = res.json()
+    report(
+      <Info key="viewer"><Text>{JSON.stringify(resp)}</Text></Info>,
+      <Assert key="event should be triggered"
+        expect={tick}
+        comparer={Comparer.greater} actual={0}/>)
+    done()
+  })
+
+})

test/test-firebase.js

     <Info key="user content" uid="user data">
       <Text>{JSON.stringify(user)}</Text>
     </Info>)
-    done()
+    if(user)
+      done()
   })
 })
 
       report(<Info key="test image">
         <Image style={styles.image} source={{uri : prefix + resp.path()}}/>
       </Info>)
-      let blob = new Blob(RNFetchBlob.wrap(resp.path()), { type : 'image/jpg' })
-      blob.onCreated(() => {
-        firebase.storage().ref('rnfbtest')
-          .child(tier2FileName)
-          .put(blob, { contentType : 'image/jpg' })
-          .then(() => {
-            report(<Assert key="upload finished" />)
-            done()
-          })
-      })
+      return Blob.build(RNFetchBlob.wrap(resp.path()), { type : 'image/jpg' })
+    })
+    .then((blob) => {
+      return firebase.storage().ref('rnfbtest')
+        .child(tier2FileName)
+        .put(blob, { contentType : 'image/jpg' })
+    })
+    .then(() => {
+      report(<Assert key="upload finished" />)
+      done()
     })
 })
 
     console.log(err)
   }
 })
+
+Platform.OS === 'ios' && describe('upload from CameraRoll', (report, done) => {
+
+    CameraRoll.getPhotos({first : 10})
+    .then((resp) => {
+      let url = resp.edges[0].node.image.uri
+      console.log('CameraRoll',url)
+      return Blob.build(RNFetchBlob.wrap(url), {type:'image/jpg'})
+    })
+    .then((b) => {
+      blob = b
+      console.log('start upload ..')
+      return firebase.storage()
+        .ref('rnfbtest').child(`camra-roll-${Platform.OS}-${Date.now()}.jpg`)
+        .put(b, {contentType : 'image/jpg'})
+    })
+    .then((snapshot) => {
+      report(<Assert key="upload sucess" expect={true} actual={true}/>)
+      done()
+    })
+})
+
+
+Platform.OS === 'android' && describe('upload from CameraRoll', (report, done) => {
+
+  let blob
+  RNFetchBlob.config({
+      addAndroidDownloads : { useDownloadManager : true }
+    })
+    .fetch('GET', `${TEST_SERVER_URL}/public/1600k-img-dummy.jpg`)
+    .then((res) => CameraRoll.getPhotos({first : 10}))
+    .then((resp) => {
+      let url = resp.edges[0].node.image.uri
+      console.log('CameraRoll',url)
+      return Blob.build(RNFetchBlob.wrap(url), {type:'image/jpg'})
+    })
+    .then((b) => {
+      blob = b
+      return firebase.storage()
+        .ref('rnfbtest').child(`camra-roll-${Platform.OS}-${Date.now()}.jpg`)
+        .put(b, {contentType : 'image/jpg'})
+    })
+    .then((snapshot) => {
+      report(<Assert key="upload sucess" expect={true} actual={true}/>)
+      blob.close()
+      done()
+    })
+})

test/test-init.js

 })
 
 
-// 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-0.7.0')
-// require('./test-0.8.0')
-// require('./test-0.9.0')
-// require('./test-0.9.2')
-require('./test-0.10.0')
-// require('./test-0.9.4')
-// require('./test-fetch')
-// require('./test-fs')
-// require('./test-xmlhttp')
-// require('./test-blob')
-// require('./test-firebase')
-// require('./test-android')
+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-0.7.0')
+require('./test-0.8.0')
+require('./test-0.9.0')
+require('./test-0.9.2')
+require('./test-0.9.4')
+require('./test-fetch')
+require('./test-fs')
+require('./test-xmlhttp')
+require('./test-blob')
+require('./test-firebase')
+require('./test-android')
 // require('./test-stress')
 // require('./benchmark')

test/test-xmlhttp.js

     if(this.readyState == 4) {
       report(<Assert key="headers should be cleared by open()"
         expect={"200"}
-        actual={this.response.value}/>)
+        actual={JSON.parse(this.response).value}/>)
       done()
     }
   }
       report(
         <Assert key="reponse should correct"
           expect={time}
-          actual={Math.floor(xhr.response.time)}/>,
+          actual={Math.floor(JSON.parse(xhr.response).time)}/>,
         <Assert key="responseType should correct"
           expect={'json'}
           actual={xhr.responseType}/>)