Merge branch '0.9.7' into 0.10.0

.github/ISSUE_TEMPLATE

 Hi ! Thank you for reporting an issue, but we would like to remind you, we have a trouble shooting page in our wiki. You may want to take a look on that page :p 
 
+* please provide the version of installed library and RN project.
+* a sample code snippet/repository is very helpful to spotting the problem.
 * issues which have been tagged as 'needs feedback', will be closed after 2 weeks if receive no feedbacks.

.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.4
+2. Bug fix request to "Bug Fix Branch" 0.9.6
 3. Correct README.md can directly to master

README.md

 
 A project committed to make file acess and data transfer easier, efficient for React Native developers.
 
+> The npm package is inside `src` folder, if you're going to install using github repository do not point to here directly
+
 ## Features
 - Transfer data directly from/to storage without BASE64 bridging
 - File API supports normal files, Asset files, and CameraRoll files
 - 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, if you're going to install via git repository do not directly poiint to this folder
-
 ## TOC
 * [About](#user-content-about)
 * [Installation](#user-content-installation)
  - 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`.
 
+> It is Worth to mentioning that the HTTP request uses cache by default, if you're going to disable it simply add a Cache Control header `'Cache-Control' : 'no-store'` 
+
 > 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
     }),
     'Content-Type' : 'application/octet-stream',
     // here's the body you're going to send, should be a BASE64 encoded string
-    // (you can use "base64" APIs to make one).
+    // (you can use "base64"(refer to the library 'mathiasbynens/base64') APIs to make one).
     // The data will be converted to "byte array"(say, blob) before request sent.  
   }, base64ImageString)
   .then((res) => {
 
 ### 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 also 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', {
     })
 ```
 
+In `0.9.6`, you can specify an optional first argument which contains `count` and `interval` to limit progress event frequency (this will be done in native context in order to reduce RCT bridge overhead). Notice that `count` argument will not work if the server does not provide response content length.
+
+
+```js
+  RNFetchBlob.fetch('POST', 'http://www.example.com/upload', {
+      ... some headers,
+      'Content-Type' : 'octet-stream'
+    }, base64DataString)
+    // listen to upload progress event, emit every 250ms
+    .uploadProgress({ interval : 250 },(written, total) => {
+        console.log('uploaded', written / total)
+    })
+    // listen to download progress event, every 10%
+    .progress({ count : 10 }, (received, total) => {
+        console.log('progress', received / total)
+    })
+    .then((resp) => {
+      // ...
+    })
+    .catch((err) => {
+      // ...
+    })
+```
+
 ### 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.
 
 ## Performance Tips
 
-**Reduce RCT Bridge and BASE64 Overheard**
+**Read Stream Event Overhead**
 
 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. 
 
+**Reduce RCT Bridge and BASE64 Overhead**
+
 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%"/>

package.json

 {
-  "name": "fetchblob-dev",
-  "version": "0.9.5-beta.2",
+  "name": "react-native-fetch-blob-dev-env",
+  "description" : "RNFB development environment, not dist package",
+  "version": "0.9.6",
   "private": true,
   "scripts": {
     "start": "node node_modules/react-native/local-cli/cli.js start",

src/README.md

-# 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) [![npm](https://img.shields.io/npm/l/react-native-fetch-blob.svg?maxAge=2592000&style=flat-square)]()
+# 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)]()
 
-# [Visit our Github for latest document](https://github.com/wkh237/react-native-fetch-blob)
 
-A project committed to make file acess and data transfer easier, effiecient for React Native developers.
+A project committed to make file acess and data transfer easier, efficient for React Native developers.
+
+# [Please visit our Github Page for latest document](https://github.com/wkh237/react-native-fetch-blob)
 
 ## Features
 - Transfer data directly from/to storage without BASE64 bridging
 - File stream support for dealing with large file
 - Blob, File, XMLHttpRequest polyfills that make browser-based library available in RN (experimental)
 
-
 ## TOC
 * [About](#user-content-about)
 * [Installation](#user-content-installation)
  * [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)
 
 ## About
 
-This project was initially for solving the issue [facebook/react-native#854](https://github.com/facebook/react-native/issues/854), because React Native lack of `Blob` implementation and it will cause some problem when transfering binary data. Now, this project is committed to make file access and transfer more easier, effiecient for React Native developers. We've implemented highly customizable filesystem and network module which plays well together. For example, upload and download data directly from/to storage which is much more efficient in some cases(especially for large ones). The file system supports file stream, so you don't have to worry about OOM problem when accessing large files.
+This project was initially for solving the issue [facebook/react-native#854](https://github.com/facebook/react-native/issues/854), because React Native lack of `Blob` implementation and it will cause some problem when transferring binary data. Now, this project is committed to make file access and transfer more easier, efficient for React Native developers. We've implemented highly customizable filesystem and network module which plays well together. For example, upload and download data directly from/to storage which is much more efficient in some cases(especially for large ones). The file system supports file stream, so you don't have to worry about OOM problem when accessing large files.
 
-In `0.8.0` we introduced experimential Web API polyfills that make it possible to use browser-based libraries in React Native, for example, [FireBase JS SDK](https://github.com/wkh237/rn-firebase-storage-upload-sample)
+In `0.8.0` we introduced experimental Web API polyfills that make it possible to use browser-based libraries in React Native, such as, [FireBase JS SDK](https://github.com/wkh237/rn-firebase-storage-upload-sample)
 
 
 ## Installation
 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
+```
+
+**Automatically Link Native Modules**
 
-### Manually link the package (Android)
+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.
 
-If rnpm link command failed to link the package automatically, you might try manually link the package.
+```
+react-native link
+```
 
-Open `android/settings.gradle`, and add these lines which will app RNFetchBlob Android project dependency to your app.
+As for projects < 0.29 you need `rnpm` to link native packages
 
-```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')                        
+```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`.
+
+> It is Worth to mentioning that the HTTP request uses cache by default, if you're going to disable it simply add a Cache Control header `'Cache-Control' : 'no-store'`
+
+> 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
 
     }),
     'Content-Type' : 'application/octet-stream',
     // here's the body you're going to send, should be a BASE64 encoded string
-    // (you can use "base64" APIs to make one).
+    // (you can use "base64"(refer to the library 'mathiasbynens/base64') APIs to make one).
     // The data will be converted to "byte array"(say, blob) before request sent.  
   }, base64ImageString)
   .then((res) => {
   })
 ```
 
-#### 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
+
+**Read Stream Event Overhead**
 
----
+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.
 
-**Reduce RCT Bridge and BASE64 Overheard**
+**Reduce RCT Bridge and BASE64 Overhead**
 
-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.
+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.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
 

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

     }
 
     @ReactMethod
-    public void enableProgressReport(String taskId) {
-        RNFetchBlobReq.progressReport.put(taskId, true);
+    public void enableProgressReport(String taskId, int interval, int count) {
+        RNFetchBlobProgressConfig config = new RNFetchBlobProgressConfig(true, interval, count, RNFetchBlobProgressConfig.ReportType.Download);
+        RNFetchBlobReq.progressReport.put(taskId, config);
     }
 
     @ReactMethod
-    public void enableUploadProgressReport(String taskId) {
-        RNFetchBlobReq.uploadProgressReport.put(taskId, true);
+    public void enableUploadProgressReport(String taskId, int interval, int count) {
+        RNFetchBlobProgressConfig config = new RNFetchBlobProgressConfig(true, interval, count, RNFetchBlobProgressConfig.ReportType.Upload);
+        RNFetchBlobReq.uploadProgressReport.put(taskId, config);
     }
 
     @ReactMethod

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

     RNFetchBlobReq.RequestType requestType;
     MediaType mime;
     File bodyCache;
+    int reported = 0;
     Boolean chunkedEncoding = false;
 
 
      * @param written
      */
     private void emitUploadProgress(int written) {
-        WritableMap args = Arguments.createMap();
-        args.putString("taskId", mTaskId);
-        args.putString("written", String.valueOf(written));
-        args.putString("total", String.valueOf(contentLength));
-
-        // emit event to js context
-        RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+        RNFetchBlobProgressConfig config = RNFetchBlobReq.getReportUploadProgress(mTaskId);
+        if(config != null && contentLength != 0 && config.shouldReport((float)written/contentLength)) {
+            WritableMap args = Arguments.createMap();
+            args.putString("taskId", mTaskId);
+            args.putString("written", String.valueOf(written));
+            args.putString("total", String.valueOf(contentLength));
+
+            // emit event to js context
+            RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+        }
     }
 
 }

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

+package com.RNFetchBlob;
+
+/**
+ * Created by wkh237 on 2016/9/24.
+ */
+public class RNFetchBlobProgressConfig {
+
+    public enum ReportType {
+        Upload,
+        Download
+    };
+
+    long lastTick = 0;
+    int tick = 0;
+    int count = -1;
+    public int interval = -1;
+    public boolean enable = false;
+    public ReportType type = ReportType.Download;
+
+    RNFetchBlobProgressConfig(boolean report, int interval, int count, ReportType type) {
+        this.enable = report;
+        this.interval = interval;
+        this.type = type;
+        this.count = count;
+    }
+
+    public boolean shouldReport(float progress) {
+        boolean checkCount = true;
+        if(count > 0 && progress > 0)
+            checkCount = Math.floor(progress*count)> tick;
+        boolean result = (System.currentTimeMillis() - lastTick> interval) && enable && checkCount;
+        if(result) {
+            tick++;
+            lastTick = System.currentTimeMillis();
+        }
+        return result;
+    }
+
+}

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

     }
 
     public static HashMap<String, Call> taskTable = new HashMap<>();
-    static HashMap<String, Boolean> progressReport = new HashMap<>();
-    static HashMap<String, Boolean> uploadProgressReport = new HashMap<>();
+    static HashMap<String, RNFetchBlobProgressConfig> progressReport = new HashMap<>();
+    static HashMap<String, RNFetchBlobProgressConfig> uploadProgressReport = new HashMap<>();
     static ConnectionPool pool = new ConnectionPool();
 
     ReactApplicationContext ctx;
     ResponseFormat responseFormat = ResponseFormat.Auto;
     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) {
                 }
             }
 
-            if(method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put")) {
+            if(method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put") || method.equalsIgnoreCase("patch")) {
                 String cType = getHeaderIgnoreCases(mheaders, "Content-Type").toLowerCase();
 
                 if(rawRequestBodyArray != null) {
                     break;
 
                 case WithoutBody:
-                    if(method.equalsIgnoreCase("POST") || method.equalsIgnoreCase("PUT"))
+                    if(method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put") || method.equalsIgnoreCase("patch"))
                     {
                         builder.method(method, RequestBody.create(null, new byte[0]));
                     }
                         DownloadManager dm = (DownloadManager)RNFetchBlob.RCTContext.getSystemService(RNFetchBlob.RCTContext.DOWNLOAD_SERVICE);
                         dm.addCompletedDownload(title, desc, scannable, mime, destPath, contentLength, notification);
                     }
+
                     done(response);
                 }
             });
                 } catch (Exception ignored) {
                     ignored.printStackTrace();
                 }
+                this.destPath = this.destPath.replace("?append=true", "");
                 callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 break;
             default:
      * @param taskId Task ID of the HTTP task.
      * @return Task ID of the target task
      */
-    public static boolean isReportProgress(String taskId) {
-        if(!progressReport.containsKey(taskId)) return false;
+    public static RNFetchBlobProgressConfig getReportProgress(String taskId) {
+        if(!progressReport.containsKey(taskId)) return null;
         return progressReport.get(taskId);
     }
 
      * @param taskId Task ID of the HTTP task.
      * @return Task ID of the target task
      */
-    public static boolean isReportUploadProgress(String taskId) {
-        if(!uploadProgressReport.containsKey(taskId)) return false;
+    public static RNFetchBlobProgressConfig getReportUploadProgress(String taskId) {
+        if(!uploadProgressReport.containsKey(taskId)) return null;
         return uploadProgressReport.get(taskId);
     }
 

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

 package com.RNFetchBlob.Response;
 
-import com.RNFetchBlob.RNFetchBlob;
 import com.RNFetchBlob.RNFetchBlobConst;
+import com.RNFetchBlob.RNFetchBlobProgressConfig;
 import com.RNFetchBlob.RNFetchBlobReq;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
 import java.io.IOException;
 import java.nio.charset.Charset;
 
-import okhttp3.Call;
-import okhttp3.Callback;
 import okhttp3.MediaType;
-import okhttp3.Response;
 import okhttp3.ResponseBody;
 import okio.Buffer;
 import okio.BufferedSource;
-import okio.ForwardingSource;
 import okio.Okio;
 import okio.Source;
 import okio.Timeout;
 
             long read =  mOriginalSource.read(sink, byteCount);
             bytesRead += read > 0 ? read : 0;
-            if(RNFetchBlobReq.isReportProgress(mTaskId)) {
+            RNFetchBlobProgressConfig reportConfig = RNFetchBlobReq.getReportProgress(mTaskId);
+            long cLen = contentLength();
+            if(reportConfig != null && cLen != 0 && reportConfig.shouldReport(bytesRead/contentLength())) {
                 WritableMap args = Arguments.createMap();
                 args.putString("taskId", mTaskId);
                 args.putString("written", String.valueOf(bytesRead));

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

 import android.util.Log;
 
 import com.RNFetchBlob.RNFetchBlobConst;
+import com.RNFetchBlob.RNFetchBlobProgressConfig;
 import com.RNFetchBlob.RNFetchBlobReq;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
         assert path != null;
         this.mPath = path;
         if (path != null) {
+            boolean appendToExistingFile = path.contains("?append=true");
+            path = path.replace("?append=true", "");
+            mPath = path;
             File f = new File(path);
             if(f.exists() == false)
                 f.createNewFile();
-            ofStream = new FileOutputStream(new File(path));
+            ofStream = new FileOutputStream(new File(path), appendToExistingFile);
         }
     }
 
     private class ProgressReportingSource implements Source {
         @Override
         public long read(Buffer sink, long byteCount) throws IOException {
-            byte [] bytes = new byte[(int) byteCount];
-            long read = originalBody.byteStream().read(bytes, 0, (int) byteCount);
-            bytesDownloaded += read > 0 ? read : 0;
-            Log.i("bytes downloaded", String.valueOf(byteCount) +"/"+ String.valueOf(read) + "=" + String.valueOf(bytesDownloaded));
-            if(read > 0 ) {
-                ofStream.write(bytes, 0, (int) read);
+            try {
+                byte[] bytes = new byte[(int) byteCount];
+                long read = originalBody.byteStream().read(bytes, 0, (int) byteCount);
+                bytesDownloaded += read > 0 ? read : 0;
+                Log.i("bytes downloaded", String.valueOf(byteCount) + "/" + String.valueOf(read) + "=" + String.valueOf(bytesDownloaded));
+                if (read > 0) {
+                    ofStream.write(bytes, 0, (int) read);
+                }
+                RNFetchBlobProgressConfig reportConfig = RNFetchBlobReq.getReportProgress(mTaskId);
+                if (reportConfig != null && contentLength() != 0 &&reportConfig.shouldReport(bytesDownloaded / contentLength())) {
+                    WritableMap args = Arguments.createMap();
+                    args.putString("taskId", mTaskId);
+                    args.putString("written", String.valueOf(bytesDownloaded));
+                    args.putString("total", String.valueOf(contentLength()));
+                    rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                            .emit(RNFetchBlobConst.EVENT_PROGRESS, args);
+                }
+                return read;
+            } catch(Exception ex) {
+                return -1;
             }
-            if(RNFetchBlobReq.isReportProgress(mTaskId)) {
-                WritableMap args = Arguments.createMap();
-                args.putString("taskId", mTaskId);
-                args.putString("written", String.valueOf(bytesDownloaded));
-                args.putString("total", String.valueOf(contentLength()));
-                rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                        .emit(RNFetchBlobConst.EVENT_PROGRESS, args);
-            }
-            return read;
         }
 
         @Override

src/fs.js

   return new Promise((resolve, reject) => {
     let handler = (err) => {
       if(err)
-      reject(err)
+        reject(new Error(err))
       else
-      resolve()
+        resolve()
     }
     if(encoding.toLowerCase() === 'ascii') {
       if(Array.isArray(data))
         RNFetchBlob.createFileASCII(path, data, handler)
       else
-        reject('`data` of ASCII file must be an array contains numbers')
+        reject(new Error('`data` of ASCII file must be an array contains numbers'))
     }
     else {
       RNFetchBlob.createFile(path, data, encoding, handler)
   return new Promise((resolve, reject) => {
     RNFetchBlob.writeStream(path, encoding || 'base64', append || false, (err, streamId:string) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve(new RNFetchBlobWriteStream(streamId, encoding))
     })
   return new Promise((resolve, reject) => {
     RNFetchBlob.mkdir(path, (err, res) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve()
     })
  */
 function readFile(path:string, encoding:string, bufferSize:?number):Promise<any> {
   if(typeof path !== 'string')
-    return Promise.reject('Invalid argument "path" ')
+    return Promise.reject(new Error('Invalid argument "path" '))
   return RNFetchBlob.readFile(path, encoding)
 }
 
     return Promise.reject('Invalid argument "path" ')
   if(encoding.toLocaleLowerCase() === 'ascii') {
     if(!Array.isArray(data))
-      Promise.reject(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`)
+      Promise.reject(new Error(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`))
     else
       return RNFetchBlob.writeFileArray(path, data, false);
   } else {
     if(typeof data !== 'string')
-      Promise.reject(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`)
+      Promise.reject(new Error(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`))
     else
       return RNFetchBlob.writeFile(path, encoding, data, false);
   }
     return Promise.reject('Invalid argument "path" ')
   if(encoding.toLocaleLowerCase() === 'ascii') {
     if(!Array.isArray(data))
-      Promise.reject(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`)
+      Promise.reject(new Error(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`))
     else
       return RNFetchBlob.writeFileArray(path, data, true);
   } else {
     if(typeof data !== 'string')
-      Promise.reject(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`)
+      Promise.reject(new Error(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`))
     else
       return RNFetchBlob.writeFile(path, encoding, data, true);
   }
   return new Promise((resolve, reject) => {
     RNFetchBlob.stat(path, (err, stat) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve(stat)
     })
   return new Promise((resolve, reject) => {
     RNFetchBlob.scanFile(pairs, (err) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve()
     })
   return new Promise((resolve, reject) => {
     RNFetchBlob.cp(path, dest, (err, res) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve(res)
     })
   return new Promise((resolve, reject) => {
     RNFetchBlob.mv(path, dest, (err, res) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve(res)
     })
   return new Promise((resolve, reject) => {
     RNFetchBlob.lstat(path, (err, stat) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve(stat)
     })
   return new Promise((resolve, reject) => {
     RNFetchBlob.ls(path, (err, res) => {
       if(err)
-        reject(err)
+        reject(new Error(err))
       else
         resolve(res)
     })
 function unlink(path:string):Promise {
   return new Promise((resolve, reject) => {
     RNFetchBlob.unlink(path, (err) => {
-      if(err)
-        reject(err)
+      if(err) {
+        reject(new Error(err))
+      }
       else
         resolve()
     })
         resolve(exist)
       })
     } catch(err) {
-      reject(err)
+      reject(new Error(err))
     }
   })
 
         resolve(isDir)
       })
     } catch(err) {
-      reject(err)
+      reject(new Error(err))
     }
   })
 

src/index.js

   // create task ID for receiving progress event
   let taskId = getUUID()
   let options = this || {}
-  let subscription, subscriptionUpload, stateEvent
+  let subscription, subscriptionUpload, stateEvent, partEvent
   let respInfo = {}
   let [method, url, headers, body] = [...args]
 
       console.log(e , 'EXPIRED!!')
       if(e.taskId === taskId && promise.onExpire) {
         promise.onExpire(e)
+
+    partEvent = emitter.addListener('RNFetchBlobServerPush', (e) => {
+      if(e.taskId === taskId && promise.onPartData) {
+        promise.onPartData(e.chunk)
       }
     })
 
       subscription.remove()
       subscriptionUpload.remove()
       stateEvent.remove()
+      partEvent.remove()
       delete promise['progress']
       delete promise['uploadProgress']
       delete promise['stateChange']
+      delete promise['part']
       delete promise['cancel']
       // delete promise['expire']
       promise.cancel = () => {}
 
   // extend Promise object, add `progress`, `uploadProgress`, and `cancel`
   // method for register progress event handler and cancel request.
-  promise.progress = (fn) => {
+  // Add second parameter for performance purpose #140
+  // When there's only one argument pass to this method, use default `interval`
+  // and `count`, otherwise use the given on.
+  // TODO : code refactor, move `uploadProgress` and `progress` to StatefulPromise
+  promise.progress = (...args) => {
+    let interval = 250
+    let count = -1
+    let fn = () => {}
+    if(args.length === 2) {
+      interval = args[0].interval || interval
+      count = args[0].count || count
+      fn = args[1]
+    }
+    else {
+      fn = args[0]
+    }
     promise.onProgress = fn
-    RNFetchBlob.enableProgressReport(taskId)
+    RNFetchBlob.enableProgressReport(taskId, interval, count)
     return promise
   }
-  promise.uploadProgress = (fn) => {
+  promise.uploadProgress = (...args) => {
+    let interval = 250
+    let count = -1
+    let fn = () => {}
+    if(args.length === 2) {
+      interval = args[0].interval || interval
+      count = args[0].count || count
+      fn = args[1]
+    }
+    else {
+      fn = args[0]
+    }
     promise.onUploadProgress = fn
-    RNFetchBlob.enableUploadProgressReport(taskId)
+    RNFetchBlob.enableUploadProgressReport(taskId, interval, count)
+    return promise
+  }
+  promise.part = (fn) => {
+    promise.onPartData = fn
     return promise
   }
   promise.stateChange = (fn) => {
     this.info = ():RNFetchBlobResponseInfo => {
       return this.respInfo
     }
+
+    this.array = ():Promise<Array> => {
+      let cType = info.headers['Content-Type'] || info.headers['content-type']
+      return new Promise((resolve, reject) => {
+        switch(this.type) {
+          case 'base64':
+            // TODO : base64 to array buffer
+          break
+          case 'path':
+            fs.readFile(this.data, 'ascii').then(resolve)
+          break
+          default:
+            // TODO : text to array buffer
+          break
+        }
+      })
+    }
+
     /**
      * Convert result to javascript RNFetchBlob object.
      * @return {Promise<Blob>} Return a promise resolves Blob object.

src/ios/RNFetchBlob.xcodeproj/project.pbxproj

 		A158F4301D0539DB006FFD38 /* RNFetchBlobNetwork.m in Sources */ = {isa = PBXBuildFile; fileRef = A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */; };
 		A15C30141CD25C330074CB35 /* RNFetchBlob.m in Sources */ = {isa = PBXBuildFile; fileRef = A15C30131CD25C330074CB35 /* RNFetchBlob.m */; };
 		A166D1AA1CE0647A00273590 /* RNFetchBlob.h in Sources */ = {isa = PBXBuildFile; fileRef = A15C30111CD25C330074CB35 /* RNFetchBlob.h */; };
+		A19B48251D98102400E6868A /* RNFetchBlobProgress.m in Sources */ = {isa = PBXBuildFile; fileRef = A19B48241D98102400E6868A /* RNFetchBlobProgress.m */; };
 		A1AAE2991D300E4D0051D11C /* RNFetchBlobReqBuilder.m in Sources */ = {isa = PBXBuildFile; fileRef = A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */; };
 /* End PBXBuildFile section */
 
 		A15C300E1CD25C330074CB35 /* libRNFetchBlob.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRNFetchBlob.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		A15C30111CD25C330074CB35 /* RNFetchBlob.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFetchBlob.h; path = RNFetchBlob/RNFetchBlob.h; sourceTree = "<group>"; };
 		A15C30131CD25C330074CB35 /* RNFetchBlob.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFetchBlob.m; path = RNFetchBlob/RNFetchBlob.m; sourceTree = "<group>"; };
+		A19B48231D98100800E6868A /* RNFetchBlobProgress.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFetchBlobProgress.h; sourceTree = "<group>"; };
+		A19B48241D98102400E6868A /* RNFetchBlobProgress.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNFetchBlobProgress.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>"; };
 		A15C30051CD25C330074CB35 = {
 			isa = PBXGroup;
 			children = (
+				A19B48241D98102400E6868A /* RNFetchBlobProgress.m */,
+				A19B48231D98100800E6868A /* RNFetchBlobProgress.h */,
 				A1F950181D7E9134002A95A6 /* IOS7Polyfill.h */,
 				A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */,
 				A1AAE2971D300E3E0051D11C /* RNFetchBlobReqBuilder.h */,
 				A158F42D1D0535BB006FFD38 /* RNFetchBlobConst.m in Sources */,
 				A158F4271D052E49006FFD38 /* RNFetchBlobFS.m in Sources */,
 				A158F4301D0539DB006FFD38 /* RNFetchBlobNetwork.m in Sources */,
+				A19B48251D98102400E6868A /* RNFetchBlobProgress.m in Sources */,
 				A1AAE2991D300E4D0051D11C /* RNFetchBlobReqBuilder.m in Sources */,
 				A15C30141CD25C330074CB35 /* RNFetchBlob.m in Sources */,
 			);

src/ios/RNFetchBlob/RNFetchBlob.m

 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
 #import "RNFetchBlobReqBuilder.h"
+#import "RNFetchBlobProgress.h"
 
 
 __strong RCTBridge * bridgeRef;
     NSError * error = nil;
     NSString * tmpPath = nil;
     [[NSFileManager defaultManager] removeItemAtPath:path error:&error];
-    if(error == nil)
+    if(error == nil || [[NSFileManager defaultManager] fileExistsAtPath:path] == NO)
         callback(@[[NSNull null]]);
     else
         callback(@[[NSString stringWithFormat:@"failed to unlink file or path at %@", path]]);
 }
 
 #pragma mark - net.enableProgressReport
-RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId {
-    [RNFetchBlobNetwork enableProgressReport:taskId];
+RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count  {
+    
+    RNFetchBlobProgress * cfg = [[RNFetchBlobProgress alloc] initWithType:Download interval:interval count:count];
+    [RNFetchBlobNetwork enableProgressReport:taskId config:cfg];
 })
 
 #pragma mark - net.enableUploadProgressReport
-RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId {
-    [RNFetchBlobNetwork enableUploadProgress:taskId];
+RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count{
+    RNFetchBlobProgress * cfg = [[RNFetchBlobProgress alloc] initWithType:Upload interval:interval count:count];
+    [RNFetchBlobNetwork enableUploadProgress:taskId config:cfg];
 })
 
 #pragma mark - fs.slice

src/ios/RNFetchBlobConst.h

 
 extern NSString *const EVENT_EXPIRE;
 extern NSString *const EVENT_PROGRESS;
+extern NSString *const EVENT_SERVER_PUSH;
 extern NSString *const EVENT_PROGRESS_UPLOAD;
 extern NSString *const EVENT_STATE_CHANGE;
 

src/ios/RNFetchBlobConst.m

 extern NSString *const CONFIG_EXTRA_BLOB_CTYPE = @"binaryContentTypes";
 
 extern NSString *const EVENT_STATE_CHANGE = @"RNFetchBlobState";
+extern NSString *const EVENT_SERVER_PUSH = @"RNFetchBlobServerPush";
 extern NSString *const EVENT_PROGRESS = @"RNFetchBlobProgress";
 extern NSString *const EVENT_PROGRESS_UPLOAD = @"RNFetchBlobProgress-upload";
 extern NSString *const EVENT_EXPIRE = @"RNFetchBlobExpire";
 // response type
 extern NSString *const RESP_TYPE_BASE64 = @"base64";
 extern NSString *const RESP_TYPE_UTF8 = @"utf8";
-extern NSString *const RESP_TYPE_PATH = @"path";
+extern NSString *const RESP_TYPE_PATH = @"path";

src/ios/RNFetchBlobNetwork.h

 
 #import <Foundation/Foundation.h>
 #import "RCTBridgeModule.h"
+#import "RNFetchBlobProgress.h"
 #import "RNFetchBlobFS.h"
 
 typedef void(^CompletionHander)(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error);
 @property (nullable, nonatomic) NSString * taskId;
 @property (nonatomic) int expectedBytes;
 @property (nonatomic) int receivedBytes;
+@property (nonatomic) BOOL isServerPush;
 @property (nullable, nonatomic) NSMutableData * respData;
 @property (strong, nonatomic) RCTResponseSenderBlock callback;
 @property (nullable, nonatomic) RCTBridge * bridge;
 - (nullable id) init;
 - (void) sendRequest;
 - (void) sendRequest:(NSDictionary  * _Nullable )options contentLength:(long)contentLength bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
++ (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config;
++ (void) enableUploadProgress:(NSString *) taskId config:(RNFetchBlobProgress *)config;
 
 
 

src/ios/RNFetchBlobNetwork.m

 #import "RNFetchBlobReqBuilder.h"
 #import "IOS7Polyfill.h"
 #import <CommonCrypto/CommonDigest.h>
+#import "RNFetchBlobProgress.h"
 
 ////////////////////////////////////////
 //
 @interface RNFetchBlobNetwork ()
 {
     BOOL * respFile;
-    BOOL * isIncrement;
+    BOOL isNewPart;
+    NSMutableData * partBuffer;
     NSString * destPath;
     NSOutputStream * writeStream;
     long bodyLength;
     return self;
 }
 
-+ (void) enableProgressReport:(NSString *) taskId
++ (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
-    [progressTable setValue:@YES forKey:taskId];
+    [progressTable setValue:config forKey:taskId];
 }
 
-+ (void) enableUploadProgress:(NSString *) taskId
++ (void) enableUploadProgress:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
-    [uploadProgressTable setValue:@YES forKey:taskId];
+    [uploadProgressTable setValue:config forKey:taskId];
 }
 
 // removing case from headers
     isIncrement = [options valueForKey:@"increment"] == nil ? NO : [[options valueForKey:@"increment"] boolValue];
     redirects = [[NSMutableArray alloc] init];
     [redirects addObject:req.URL.absoluteString];
-    
+
     // set response format
     NSString * rnfbResp = [req.allHTTPHeaderFields valueForKey:@"RNFB-Response"];
     if([[rnfbResp lowercaseString] isEqualToString:@"base64"])
     // the session trust any SSL certification
 //    NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
     NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:taskId];
-    
+
     // set request timeout
     float timeout = [options valueForKey:@"timeout"] == nil ? -1 : [[options valueForKey:@"timeout"] floatValue];
     if(timeout > 0)
         respData = [[NSMutableData alloc] init];
         respFile = NO;
     }
-    
+
     __block NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
     [taskTable setObject:task forKey:taskId];
     [task resume];
     if([[options objectForKey:CONFIG_INDICATOR] boolValue] == YES)
         [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
     __block UIApplication * app = [UIApplication sharedApplication];
-    
+
     // #115 handling task expired when application entering backgound for a long time
     [app beginBackgroundTaskWithName:taskId expirationHandler:^{
         NSLog([NSString stringWithFormat:@"session %@ expired event emit", taskId ]);
         [expirationTable setObject:task forKey:taskId];
         [app endBackgroundTask:task];
-        
+
     }];
-    
-    
+
+
 }
 
 // #115 Invoke fetch.expire event on those expired requests so that the expired event can be handled
     {
         NSDictionary *headers = [httpResponse allHeaderFields];
         NSString * respCType = [[RNFetchBlobReqBuilder getHeaderIgnoreCases:@"Content-Type" fromHeaders:headers] lowercaseString];
+        if(self.isServerPush == NO)
+        {
+            self.isServerPush = [[respCType lowercaseString] RNFBContainsString:@"multipart/x-mixed-replace;"];
+        }
+        if(self.isServerPush)
+        {
+            if(partBuffer != nil)
+            {
+                [self.bridge.eventDispatcher
+                 sendDeviceEventWithName:EVENT_SERVER_PUSH
+                 body:@{
+                        @"taskId": taskId,
+                        @"chunk": [partBuffer base64EncodedStringWithOptions:0],
+                        }
+                 ];
+            }
+            partBuffer = [[NSMutableData alloc] init];
+            completionHandler(NSURLSessionResponseAllow);
+            return;
+        }
         if(respCType != nil)
         {
             NSArray * extraBlobCTypes = [options objectForKey:CONFIG_EXTRA_BLOB_CTYPE];
         @try{
             NSFileManager * fm = [NSFileManager defaultManager];
             NSString * folder = [destPath stringByDeletingLastPathComponent];
-            if(![fm fileExistsAtPath:folder]) {
+            if(![fm fileExistsAtPath:folder])
+            {
                 [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:nil];
             }
-            [fm createFileAtPath:destPath contents:[[NSData alloc] init] attributes:nil];
+            BOOL appendToExistingFile = [destPath RNFBContainsString:@"?append=true"];
+            // For solving #141 append response data if the file already exists
+            // base on PR#139 @kejinliang
+            if(appendToExistingFile)
+            {
+                destPath = [destPath stringByReplacingOccurrencesOfString:@"?append=true" withString:@""];
+            }
+            if (![fm fileExistsAtPath:destPath])
+            {
+                [fm createFileAtPath:destPath contents:[[NSData alloc] init] attributes:nil];
+            }
             writeStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:YES];
             [writeStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
             [writeStream open];
     completionHandler(NSURLSessionResponseAllow);
 }
 
+
 // download progress handler
 - (void) URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
 {
+    // For #143 handling multipart/x-mixed-replace response
+    if(self.isServerPush)
+    {
+        [partBuffer appendData:data];
+        return ;
+    }
+
     NSNumber * received = [NSNumber numberWithLong:[data length]];
     receivedBytes += [received longValue];
     NSString * chunkString = @"";
     {
         [writeStream write:[data bytes] maxLength:[data length]];
     }
-
-    if([progressTable valueForKey:taskId] == @YES)
+    RNFetchBlobProgress * pconfig = [progressTable valueForKey:taskId];
+    if(expectedBytes == 0)
+        return;
+    NSNumber * now =[NSNumber numberWithFloat:((float)receivedBytes/(float)expectedBytes)];
+    if(pconfig != nil && [pconfig shouldReport:now])
     {
         [self.bridge.eventDispatcher
          sendDeviceEventWithName:EVENT_PROGRESS
         session = nil;
 }
 
+
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
 {
 
     {
         errMsg = [error localizedDescription];
     }
-    // Fix #72 response with status code 200 ~ 299 considered as success
-    else if(respStatus> 299 || respStatus < 200)
-    {
-        errMsg = [NSString stringWithFormat:@"Request failed, status %d", respStatus];
-    }
     else
     {
         if(respFile == YES)
             // if it turns out not to be `nil` that means the response data contains valid UTF8 string,
             // in order to properly encode the UTF8 string, use URL encoding before BASE64 encoding.
             NSString * utf8 = [[NSString alloc] initWithData:respData encoding:NSUTF8StringEncoding];
-            
+
             if(responseFormat == BASE64)
             {
                 rnfbRespType = RESP_TYPE_BASE64;
 // upload progress handler
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didSendBodyData:(int64_t)bytesSent totalBytesSent:(int64_t)totalBytesWritten totalBytesExpectedToSend:(int64_t)totalBytesExpectedToWrite
 {
-    if([uploadProgressTable valueForKey:taskId] == @YES) {
+    RNFetchBlobProgress * pconfig = [uploadProgressTable valueForKey:taskId];
+    if(totalBytesExpectedToWrite == 0)
+        return;
+    NSNumber * now = [NSNumber numberWithFloat:((float)totalBytesWritten/(float)totalBytesExpectedToWrite)];
+    if(pconfig != nil && [pconfig shouldReport:now]) {
         [self.bridge.eventDispatcher
          sendDeviceEventWithName:EVENT_PROGRESS_UPLOAD
          body:@{
                 @"taskId": taskId,
                 @"written": [NSString stringWithFormat:@"%d", totalBytesWritten],
-                @"total": [NSString stringWithFormat:@"%d", bodyLength]
+                @"total": [NSString stringWithFormat:@"%d", totalBytesExpectedToWrite]
                 }
          ];
     }

src/ios/RNFetchBlobProgress.h

+//
+//  RNFetchBlobProgress.h
+//  RNFetchBlob
+//
+//  Created by Ben Hsieh on 2016/9/25.
+//  Copyright © 2016年 wkh237.github.io. All rights reserved.
+//
+
+#ifndef RNFetchBlobProgress_h
+#define RNFetchBlobProgress_h
+
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSUInteger, ProgressType) {
+    Download,
+    Upload,
+};
+
+@interface RNFetchBlobProgress : NSObject
+{
+    NSNumber * count;
+    NSNumber * interval;
+    ProgressType type;
+    BOOL enable;
+    
+}
+
+@property (nonatomic) NSNumber * count;
+@property (nonatomic) NSNumber * interval;
+@property (nonatomic) NSInteger type;
+@property (nonatomic) BOOL enable;
+
+-(id)initWithType:(ProgressType)type interval:(NSNumber*)interval count:(NSNumber *)count;
+-(BOOL)shouldReport:(NSNumber *) nextProgress;
+
+
+@end
+
+#endif /* RNFetchBlobProgress_h */

src/ios/RNFetchBlobProgress.m

+//
+//  RNFetchBlobProgress.m
+//  RNFetchBlob
+//
+//  Created by Ben Hsieh on 2016/9/25.
+//  Copyright © 2016年 wkh237.github.io. All rights reserved.
+//
+
+#import "RNFetchBlobProgress.h"
+
+@interface RNFetchBlobProgress ()
+{
+    float progress;
+    int tick;
+    double lastTick;
+}
+@end
+
+@implementation RNFetchBlobProgress
+
+-(id)initWithType:(ProgressType)type interval:(NSNumber *)interval count:(NSNumber *)count
+{
+    self = [super init];
+    self.count = count;
+    self.interval = [NSNumber numberWithFloat:[interval floatValue] /1000];
+    self.type = type;
+    self.enable = YES;
+    lastTick = 0;
+    tick = 1;
+    return self;
+}
+
+-(BOOL)shouldReport:(NSNumber *)nextProgress
+{
+    BOOL result = YES;
+    float countF = [self.count floatValue];
+    if(countF > 0 && [nextProgress floatValue] > 0)
+    {
+        result = (int)(floorf([nextProgress floatValue]*countF)) >= tick;
+    }
+    
+    NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
+    // NSTimeInterval is defined as double
+    NSNumber *timeStampObj = [NSNumber numberWithDouble: timeStamp];
+    float delta = [timeStampObj doubleValue] - lastTick;
+    BOOL shouldReport = delta > [self.interval doubleValue] && self.enable && result;
+    if(shouldReport)
+    {
+        tick++;
+        lastTick = [timeStampObj doubleValue];
+    }
+    return shouldReport;
+    
+}
+
+
+@end

src/ios/RNFetchBlobReqBuilder.m

                     }
                     else
                     {
-                        [request setHTTPBody:[NSData dataWithContentsOfFile:orgPath ]];
+                        __block NSData * bodyBytes = [NSData dataWithContentsOfFile:orgPath ];
+                        [request setHTTPBody:bodyBytes];
                     }
                 }
                 // otherwise convert it as BASE64 data string

src/package.json

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

src/polyfill/Blob.js

   }
 
   static setLog(level:number) {
-    if(number === -1)
+    if(level === -1)
       log.disable()
     else
       log.level(level)
    * @param  {string} contentType Optional, content type of new Blob object
    * @return {Blob}
    */
-  slice(start:?number, end:?number, contentType='':?string):Blob {
+  slice(start:?number, end:?number, contentType:?string=''):Blob {
     if(this._closed)
       throw 'Blob has been released.'
     log.verbose('slice called', start, end, contentType)

src/polyfill/XMLHttpRequest.js

   _response : any = '';
   _responseText : any = '';
   _responseHeaders : any = {};
-  _responseType : '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' = '';
+  _responseType : '' | 'arraybuffer' | 'blob'  | 'json' | 'text' = '';
   // TODO : not suppoted ATM
   _responseURL : null = '';
   _responseXML : null = '';
   }
 
   static setLog(level:number) {
-    if(number === -1)
+    if(level === -1)
       log.disable()
     else
       log.level(level)
     if(e.state === "2") {
       this._responseHeaders = e.headers
       this._statusText = e.status
-      this._responseType = e.respType || ''
       this._status = Math.floor(e.status)
       this._dispatchReadStateChange(XMLHttpRequest.HEADERS_RECEIVED)
     }
     if(resp) {
       let info = resp.respInfo || {}
       log.debug(this._url, info, info.respType)
-      switch(info.respType) {
+      switch(this._responseType) {
         case 'blob' :
           resp.blob().then((b) => {
             this._responseText = resp.text()
             responseDataReady()
           })
         break;
+        case 'arraybuffer':
+          // TODO : to array buffer
+        break
+        case 'json':
+          this._response = resp.json()
+          this._responseText = resp.text()
+        break
         default :
           this._responseText = resp.text()
           this._response = this.responseText

src/react-native-fetch-blob.podspec

 Pod::Spec.new do |s|
   s.name             = "react-native-fetch-blob"
-  s.version          = "0.9.5-beta.2"
+  s.version          = "0.9.6"
   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.5-beta.2'}
+  s.source       = { :git => "https://github.com/wkh237/react-native-fetch-blob", :tag => 'v0.9.6'}
   s.source_files = 'ios/**/*.{h,m}'
   s.platform     = :ios, "7.0"
   s.dependency 'React/Core'