Merge branch '0.10.0'

CONTRIBUTORS.md

-
+Andreas Amsenius <andreas@amsenius.se>
+Corentin Smith <corentin.smith@gmail.com>
 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>
-
+Mike Monteith <mike@mikemonteith.com>
 Nguyen Cao Nhat Linh <nhatlinh95@gmail.com>
-
+Tim Suchanek <tim.suchanek@gmail.com>
 follower <github@rancidbacon.com>
-
 francisco-sanchez-molina <psm1984@gmail.com>
-
+kejinliang <kejinliang@users.noreply.github.com>
 smartt <github@eriksmartt.com>

README.md

 - Native-to-native file manipulation API, reduce JS bridging performance loss
 - File stream support for dealing with large file
 - Blob, File, XMLHttpRequest polyfills that make browser-based library available in RN (experimental)
+- JSON stream supported base on [Oboe.js@jimhigson](https://github.com/jimhigson/oboe.js/)
 
 ## TOC
 * [About](#user-content-about)
 RNFB_ANDROID_PERMISSIONS=true react-native link
 ```
 
-pre 0.29 projects 
+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) to manually link the package.
+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) to manually link the pacakge.
 
 **Grant Permission to External storage for Android 5.0 or lower**
 
 - 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. 
+ - 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'` 
+> 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`.
 
 
 ### 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', {
 
 **Read Stream and Progress 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. 
+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**
 
 
 ## Caveats
 
-* This library does not urlencode unicode characters in URL automatically, see [#146](https://github.com/wkh237/react-native-fetch-blob/issues/146). 
+* This library does not urlencode unicode characters in URL automatically, see [#146](https://github.com/wkh237/react-native-fetch-blob/issues/146).
 * When a `Blob` is created from existing file, the file **WILL BE REMOVE** if you `close` the blob.
 * If you replaced `window.XMLHttpRequest` for some reason (e.g. make Firebase SDK work), it will also effect how official `fetch` works (basically it should work just fine).
 * When file stream and upload/download progress event slow down your app, consider upgrade to `0.9.6+`, use [additional arguments](https://github.com/wkh237/react-native-fetch-blob/wiki/Fetch-API#fetchprogressconfig-eventlistenerpromisernfetchblobresponse) to limit its frequency.

package.json

 {
   "name": "react-native-fetch-blob-dev-env",
-  "description" : "RNFB development environment, not dist package",
-  "version": "0.9.6",
+  "description": "RNFB development environment, not dist package",
+  "version": "0.10.0-dev",
   "private": true,
   "scripts": {
     "start": "node node_modules/react-native/local-cli/cli.js start",
+    "update-info": "sh scripts/contributors.sh",
     "test": "sh test.sh"
   },
   "devDependencies": {
     "chokidar": "^1.5.1",
     "express": "^4.13.4",
     "multer": "^1.1.0"
-  }
-}
+  },
+  "contributors": [
+    "Andreas Amsenius <andreas@amsenius.se>",
+    "Corentin Smith <corentin.smith@gmail.com>",
+    "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>",
+    "Mike Monteith <mike@mikemonteith.com>",
+    "Nguyen Cao Nhat Linh <nhatlinh95@gmail.com>",
+    "Tim Suchanek <tim.suchanek@gmail.com>",
+    "follower <github@rancidbacon.com>",
+    "francisco-sanchez-molina <psm1984@gmail.com>",
+    "kejinliang <kejinliang@users.noreply.github.com>",
+    "smartt <github@eriksmartt.com>",
+    ""
+  ]
+}

scripts/README.md

+Always execute these scripts from root folder, not here.

scripts/contributors.sh

+
+git log --pretty="%an <%ae>" | sort |uniq > CONTRIBUTORS.md
+sed -i.bak '/xeiyan@gmail.com/d' ./CONTRIBUTORS.md
+rm CONTRIBUTORS.md.bak
+
+echo "list contributors .."
+
+cat CONTRIBUTORS.md
+
+echo "update package.json .."
+
+node -e "var fs = require('fs');\
+        var json = JSON.parse(fs.readFileSync('./package.json'));\
+        var contributors = String(fs.readFileSync('./CONTRIBUTORS.md')).split(/[\r\n]/);\
+        json.contributors = contributors;\
+        var distJSON = JSON.parse(fs.readFileSync('./src/package.json'));\
+        distJSON.contributors = contributors;\
+        fs.writeFileSync('./src/package.json', JSON.stringify(distJSON, null, 2));\
+        fs.writeFileSync('./package.json', JSON.stringify(json, null, 2));"
+
+echo "done"

test.sh → scripts/test.sh

 cd "${TEST_APP_PATH}"
 # npm install --save "${CWD}/src"
 npm install --save react-native-fetch-blob
+# libs that requires web API polyfills
 npm install --save firebase
 react-native link
 

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) [![](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)]()
 
-
 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 API supports normal files, Asset files, and CameraRoll files
 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.
+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) to manually link the pacakge.
 
 **Grant Permission to External storage for Android 5.0 or lower**
 
     })
 ```
 
+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.

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

 import android.content.Intent;
 import android.net.Uri;
 
+import com.RNFetchBlob.Utils.RNFBCookieJar;
 import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 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.WritableArray;
 
 import java.util.Map;
 import java.util.concurrent.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);
+    static public boolean ActionViewVisible = false;
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
 
         super(reactContext);
+
         RCTContext = reactContext;
     }
 
     }
 
     @ReactMethod
-    public void actionViewIntent(String path, String mime, Promise promise) {
+    public void actionViewIntent(String path, String mime, final Promise promise) {
         try {
             Intent intent= new Intent(Intent.ACTION_VIEW)
                     .setDataAndType(Uri.parse("file://" + path), mime);
             intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-
             this.getReactApplicationContext().startActivity(intent);
-            promise.resolve(null);
+            ActionViewVisible = true;
+
+            final LifecycleEventListener listener = new LifecycleEventListener() {
+                @Override
+                public void onHostResume() {
+                    if(ActionViewVisible)
+                        promise.resolve(null);
+                    RCTContext.removeLifecycleEventListener(this);
+                }
+
+                @Override
+                public void onHostPause() {
+
+                }
+
+                @Override
+                public void onHostDestroy() {
+
+                }
+            };
+            RCTContext.addLifecycleEventListener(listener);
         } catch(Exception ex) {
             promise.reject(ex.getLocalizedMessage());
         }
 
     }
 
+    @ReactMethod
+    /**
+     * Get cookies belongs specific host.
+     * @param host String host name.
+     */
+    public void getCookies(String host, Promise promise) {
+        try {
+            WritableArray cookies = RNFBCookieJar.getCookies(host);
+            promise.resolve(cookies);
+        } catch(Exception err) {
+            promise.reject("RNFetchBlob.getCookies", err.getMessage());
+        }
+    }
+
     @ReactMethod
     /**
      * @param path Stream file path
         RNFetchBlobReq.progressReport.put(taskId, config);
     }
 
+    @ReactMethod
+    public void df(final Callback callback) {
+        fsThreadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.df(callback);
+            }
+        });
+    }
+
+
     @ReactMethod
     public void enableUploadProgressReport(String taskId, int interval, int count) {
         RNFetchBlobProgressConfig config = new RNFetchBlobProgressConfig(true, interval, count, RNFetchBlobProgressConfig.ReportType.Upload);

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

     public String key;
     public String mime;
     public Boolean auto;
+    public Boolean overwrite = true;
     public long timeout = 60000;
+    public Boolean increment = false;
     public ReadableArray binaryContentTypes = null;
 
     RNFetchBlobConfig(ReadableMap options) {
         }
         if(options.hasKey("binaryContentTypes"))
             this.binaryContentTypes = options.getArray("binaryContentTypes");
+        if(this.path != null && path.toLowerCase().contains("?append=true")) {
+            this.overwrite = false;
+        }
+
+        if(options.hasKey("overwrite"))
+            this.overwrite = options.getBoolean("overwrite");
         this.key = options.hasKey("key") ? options.getString("key") : null;
         this.mime = options.hasKey("contentType") ? options.getString("contentType") : null;
+        this.increment = options.hasKey("increment") ? options.getBoolean("increment") : false;
         this.auto = options.hasKey("auto") ? options.getBoolean("auto") : false;
         if(options.hasKey("timeout")) {
             this.timeout = options.getInt("timeout");

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

 package com.RNFetchBlob;
 
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
 import android.content.res.AssetFileDescriptor;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
 import android.os.AsyncTask;
+import android.os.Build;
 import android.os.Environment;
+import android.os.StatFs;
 import android.os.SystemClock;
 import android.util.Base64;
 
      */
     static public Map<String, Object> getSystemfolders(ReactApplicationContext ctx) {
         Map<String, Object> res = new HashMap<>();
+
         res.put("DocumentDir", ctx.getFilesDir().getAbsolutePath());
         res.put("CacheDir", ctx.getCacheDir().getAbsolutePath());
         res.put("DCIMDir", Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath());
         res.put("DownloadDir", Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getAbsolutePath());
         res.put("MovieDir", Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES).getAbsolutePath());
         res.put("RingtoneDir", Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_RINGTONES).getAbsolutePath());
-        res.put("SDCard", Environment.getExternalStorageDirectory().getAbsolutePath());
+        String state;
+        state = Environment.getExternalStorageState();
+        if (state.equals(Environment.MEDIA_MOUNTED)) {
+            res.put("SDCard", Environment.getExternalStorageDirectory().getAbsolutePath());
+        }
+        res.put("MainBundleDir", ctx.getApplicationInfo().dataDir);
         return res;
     }
 
             }
             else {
                 if (!created) {
-                    callback.invoke("create file error: failed to create file at path `" + path + "` for its parent path may not exists");
+                    callback.invoke("create file error: failed to create file at path `" + path + "` for its parent path may not exists, or the file already exists. If you intended to overwrite the existing file use fs.writeFile instead.");
                     return;
                 }
                 OutputStream ostream = new FileOutputStream(dest);
         }
     }
 
+    static void df(Callback callback) {
+        StatFs stat = new StatFs(Environment.getDataDirectory().getPath());
+        WritableMap args = Arguments.createMap();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            args.putString("internal_free", String.valueOf(stat.getFreeBytes()));
+            args.putString("internal_total", String.valueOf(stat.getTotalBytes()));
+            StatFs statEx = new StatFs(Environment.getExternalStorageDirectory().getPath());
+            args.putString("external_free", String.valueOf(statEx.getFreeBytes()));
+            args.putString("external_total", String.valueOf(statEx.getTotalBytes()));
+
+        }
+        callback.invoke(null ,args);
+    }
+
     /**
      * Remove files in session.
      * @param paths An array of file paths.
      * @param event Event name, `data`, `end`, `error`, etc.
      * @param data  Event data
      */
-    void emitStreamEvent(String streamName, String event, String data) {
+    private void emitStreamEvent(String streamName, String event, String data) {
         WritableMap eventData = Arguments.createMap();
         eventData.putString("event", event);
         eventData.putString("detail", data);
         this.emitter.emit(streamName, eventData);
     }
 
-    void emitStreamEvent(String streamName, String event, WritableArray  data) {
+    private void emitStreamEvent(String streamName, String event, WritableArray data) {
         WritableMap eventData = Arguments.createMap();
         eventData.putString("event", event);
         eventData.putArray("detail", data);
 
     }
 
-    public static boolean isAsset(String path) {
+    static boolean isAsset(String path) {
         if(path != null)
             return path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET);
         return false;
     }
 
-    public static String normalizePath(String path) {
+    static String normalizePath(String path) {
         if(path == null)
             return null;
         Uri uri = Uri.parse(path);

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

 
 import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
 import com.RNFetchBlob.Response.RNFetchBlobFileResp;
+import com.RNFetchBlob.Utils.RNFBCookieJar;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.CookieHandler;
+import java.net.CookieManager;
+import java.net.CookiePolicy;
 import java.net.MalformedURLException;
 import java.net.SocketException;
 import java.net.SocketTimeoutException;
 
 import okhttp3.Call;
 import okhttp3.ConnectionPool;
+import okhttp3.CookieJar;
 import okhttp3.Headers;
 import okhttp3.Interceptor;
 import okhttp3.MediaType;
 
         // 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);
         else if(this.options.fileCache)
             this.destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext;
 
+
         OkHttpClient.Builder clientBuilder;
 
         try {
                 }
             }
 
-            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]));
                     }
                     break;
             }
 
+            // #156 fix cookie issue
+
+
             final Request req = builder.build();
+            clientBuilder.cookieJar(new RNFBCookieJar());
             clientBuilder.addNetworkInterceptor(new Interceptor() {
                 @Override
                 public Response intercept(Chain chain) throws IOException {
                                 extended = new RNFetchBlobDefaultResp(
                                         RNFetchBlob.RCTContext,
                                         taskId,
-                                        originalResponse.body());
+                                        originalResponse.body(),
+                                        options.increment);
                                 break;
                             case FileStorage:
                                 extended = new RNFetchBlobFileResp(
                                         RNFetchBlob.RCTContext,
                                         taskId,
                                         originalResponse.body(),
-                                        destPath);
+                                        destPath,
+                                        options.overwrite);
                                 break;
                             default:
                                 extended = new RNFetchBlobDefaultResp(
                                         RNFetchBlob.RCTContext,
                                         taskId,
-                                        originalResponse.body());
+                                        originalResponse.body(),
+                                        options.increment);
                                 break;
                         }
                         return originalResponse.newBuilder().body(extended).build();
                     }
                     catch (SocketTimeoutException e ){
                         timeout = true;
+                        RNFetchBlobUtils.emitWarningEvent("RNFetchBlob error when sending request : " + e.getLocalizedMessage());
                     } catch(Exception ex) {
-                        RNFetchBlobUtils.emitWarningEvent("RNFetchBlob error when sending request : " + ex.getLocalizedMessage());
+
                     }
                     return chain.proceed(chain.request());
                 }
                     // and write response data to destination path.
                     resp.body().bytes();
                 } catch (Exception ignored) {
-                    ignored.printStackTrace();
+//                    ignored.printStackTrace();
                 }
                 this.destPath = this.destPath.replace("?append=true", "");
                 callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 DownloadManager dm = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
                 dm.query(query);
                 Cursor c = dm.query(query);
+                String error = null;
                 String filePath = null;
                 // the file exists in media content database
                 if (c.moveToFirst()) {
                     if (cursor != null) {
                         cursor.moveToFirst();
                         filePath = cursor.getString(0);
-                        cursor.close();
-                        if(filePath != null) {
-                            this.callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, filePath);
-                            return;
-                        }
                     }
                 }
                 // When the file is not found in media content database, check if custom path exists
                         boolean exists = new File(customDest).exists();
                         if(!exists)
                             throw new Exception("Download manager download failed, the file does not downloaded to destination.");
-                        callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, customDest);
+                        else
+                            this.callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, customDest);
 
                     } catch(Exception ex) {
-                        this.callback.invoke(ex.getLocalizedMessage(), null, null);
+                        error = ex.getLocalizedMessage();
                     }
                 }
-                else
-                    this.callback.invoke("Download manager could not resolve downloaded file path.", RNFetchBlobConst.RNFB_RESPONSE_PATH, null);
+                else {
+                    if(filePath == null)
+                        this.callback.invoke("Download manager could not resolve downloaded file path.", RNFetchBlobConst.RNFB_RESPONSE_PATH, null);
+                    else
+                        this.callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, filePath);
+                }
+
             }
         }
     }

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

 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.io.IOException;
+import java.nio.charset.Charset;
 
 import okhttp3.MediaType;
 import okhttp3.ResponseBody;
     String mTaskId;
     ReactApplicationContext rctContext;
     ResponseBody originalBody;
+    boolean isIncrement = false;
 
-    public RNFetchBlobDefaultResp(ReactApplicationContext ctx, String taskId, ResponseBody body) {
+    public RNFetchBlobDefaultResp(ReactApplicationContext ctx, String taskId, ResponseBody body, boolean isIncrement) {
         this.rctContext = ctx;
         this.mTaskId = taskId;
         this.originalBody = body;
+        this.isIncrement = isIncrement;
     }
 
     @Override
                 args.putString("taskId", mTaskId);
                 args.putString("written", String.valueOf(bytesRead));
                 args.putString("total", String.valueOf(contentLength()));
+                if(isIncrement) {
+                    args.putString("chunk", sink.readString(Charset.defaultCharset()));
+                }
+                else {
+                    args.putString("chunk", "");
+                }
+
                 rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                         .emit(RNFetchBlobConst.EVENT_PROGRESS, args);
             }

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

     ReactApplicationContext rctContext;
     FileOutputStream ofStream;
 
-    public RNFetchBlobFileResp(ReactApplicationContext ctx, String taskId, ResponseBody body, String path) throws IOException {
+    public RNFetchBlobFileResp(ReactApplicationContext ctx, String taskId, ResponseBody body, String path, boolean overwrite) throws IOException {
         super();
         this.rctContext = ctx;
         this.mTaskId = taskId;
         assert path != null;
         this.mPath = path;
         if (path != null) {
-            boolean appendToExistingFile = path.contains("?append=true");
+            boolean appendToExistingFile = !overwrite;
             path = path.replace("?append=true", "");
             mPath = path;
             File f = new File(path);

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

+package com.RNFetchBlob.Utils;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import okhttp3.Cookie;
+import okhttp3.CookieJar;
+import okhttp3.HttpUrl;
+
+/**
+ * Created by wkh237on 2016/10/14.
+ */
+
+
+
+public class RNFBCookieJar implements CookieJar {
+
+    static final HashMap<String, List<Cookie>> cookieStore = new HashMap<>();
+    private List<Cookie> cookies;
+
+    @Override
+    public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
+        cookieStore.put(url.host(), cookies);
+    }
+
+    @Override
+    public List<Cookie> loadForRequest(HttpUrl url) {
+        List<Cookie> cookies = cookieStore.get(url.host());
+        return cookies != null ? cookies : new ArrayList<Cookie>();
+    }
+
+    public static WritableArray getCookies(String host) {
+        HttpUrl url = HttpUrl.parse(host);
+        List<Cookie> cookies = null;
+        if(url != null) {
+            cookies = cookieStore.get(url.host());
+        }
+        WritableArray cookieList = Arguments.createArray();
+        if(cookies != null) {
+            for(Cookie c : cookies){
+                cookieList.pushString(c.toString());
+            }
+            return cookieList;
+        }
+        return null;
+    }
+}

src/fs.js

     MovieDir : RNFetchBlob.MovieDir,
     DownloadDir : RNFetchBlob.DownloadDir,
     DCIMDir : RNFetchBlob.DCIMDir,
-    SDCardDir : RNFetchBlob.SDCardDir
+    SDCardDir : RNFetchBlob.SDCardDir,
+    MainBundleDir : RNFetchBlob.MainBundleDir
 }
 
 /**
 
 }
 
+function df():Promise<{ free : number, total : number }> {
+  return new Promise((resolve, reject) => {
+    RNFetchBlob.df((err, stat) => {
+      if(err)
+        reject(err)
+      else
+        resolve(stat)
+    })
+  })
+}
+
 export default {
   RNFetchBlobSession,
   unlink,
   scanFile,
   dirs,
   slice,
-  asset
+  asset,
+  df
 }

src/index.js

   NativeAppEventEmitter,
   Platform,
   AsyncStorage,
+  AppState,
 } from 'react-native'
 import type {
   RNFetchBlobNative,
   RNFetchBlobStream,
   RNFetchBlobResponseInfo
 } from './types'
+import URIUtil from './utils/uri'
 import StatefulPromise from './class/StatefulPromise.js'
 import fs from './fs'
 import getUUID from './utils/uuid'
 import base64 from 'base-64'
 import polyfill from './polyfill'
 import android from './android'
+import ios from './ios'
+import net from './net'
+import JSONStream from './json-stream'
 const {
   RNFetchBlobSession,
   readStream,
   cp
 } = fs
 
-
 const Blob = polyfill.Blob
 const emitter = DeviceEventEmitter
-const RNFetchBlob:RNFetchBlobNative = NativeModules.RNFetchBlob
+const RNFetchBlob = NativeModules.RNFetchBlob
+
+// when app resumes, check if there's any expired network task and trigger
+// their .expire event
+if(Platform.OS === 'ios') {
+  AppState.addEventListener('change', (e) => {
+    console.log('app state changed', e)
+    if(e === 'active')
+      RNFetchBlob.emitExpiredEvent(()=>{})
+  })
+}
 
 // register message channel event handler.
 emitter.addListener("RNFetchBlobMessage", (e) => {
+
   if(e.event === 'warn') {
     console.warn(e.detail)
   }
   return { fetch : fetch.bind(options) }
 }
 
+/**
+ * Fetch from file system, use the same interface as RNFB.fetch
+ * @param  {RNFetchBlobConfig} [options={}] Fetch configurations
+ * @param  {string} method     Should be one of `get`, `post`, `put`
+ * @param  {string} url        A file URI string
+ * @param  {string} headers    Arguments of file system API
+ * @param  {any} body       Data to put or post to file systen.
+ * @return {Promise}
+ */
+function fetchFile(options = {}, method, url, headers = {}, body):Promise {
+
+  if(!URIUtil.isFileURI(url)) {
+    throw `could not fetch file from an invalid URI : ${url}`
+  }
+
+  url = URIUtil.unwrapFileURI(url)
+
+  let promise = null
+  let cursor = 0
+  let total = -1
+  let cacheData = ''
+  let info = null
+  let _progress, _uploadProgress, _stateChange
+
+  switch(method.toLowerCase()) {
+
+    case 'post':
+    break
+
+    case 'put':
+    break
+
+    // read data from file system
+    default:
+      promise = fs.stat(url)
+      .then((stat) => {
+        total = stat.size
+        return fs.readStream(url,
+          headers.encoding || 'utf8',
+          Math.floor(headers.bufferSize) || 409600,
+          Math.floor(headers.interval) || 100
+        )
+      })
+      .then((stream) => new Promise((resolve, reject) => {
+        stream.open()
+        info = {
+          state : "2",
+          headers : { 'source' : 'system-fs' },
+          status : 200,
+          respType : 'text',
+          rnfbEncode : headers.encoding || 'utf8'
+        }
+        _stateChange(info)
+        stream.onData((chunk) => {
+          _progress && _progress(cursor, total, chunk)
+          if(headers.noCache)
+            return
+          cacheData += chunk
+        })
+        stream.onError((err) => { reject(err) })
+        stream.onEnd(() => {
+          resolve(new FetchBlobResponse(null, info, cacheData))
+        })
+      }))
+    break
+  }
+
+  promise.progress = (fn) => {
+    _progress = fn
+    return promise
+  }
+  promise.stateChange = (fn) => {
+    _stateChange = fn
+    return promise
+  }
+  promise.uploadProgress = (fn) => {
+    _uploadProgress = fn
+    return promise
+  }
+
+  return promise
+}
+
 /**
  * Create a HTTP request by settings, the `this` context is a `RNFetchBlobConfig` object.
  * @param  {string} method HTTP method, should be `GET`, `POST`, `PUT`, `DELETE`
   let options = this || {}
   let subscription, subscriptionUpload, stateEvent, partEvent
   let respInfo = {}
+  let [method, url, headers, body] = [...args]
+
+  // fetch from file system
+  if(URIUtil.isFileURI(url)) {
+    return fetchFile(options, method, url, headers, body)
+  }
 
+  // from remote HTTP(S)
   let promise = new Promise((resolve, reject) => {
-    let [method, url, headers, body] = [...args]
     let nativeMethodName = Array.isArray(body) ? 'fetchBlobForm' : 'fetchBlob'
 
     // on progress event listener
     subscription = emitter.addListener('RNFetchBlobProgress', (e) => {
       if(e.taskId === taskId && promise.onProgress) {
-        promise.onProgress(e.written, e.total)
+        promise.onProgress(e.written, e.total, e.chunk)
       }
     })
 
       }
     })
 
+    subscription = emitter.addListener('RNFetchBlobExpire', (e) => {
+      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)
       delete promise['stateChange']
       delete promise['part']
       delete promise['cancel']
+      // delete promise['expire']
       promise.cancel = () => {}
 
       if(err)
     promise.onStateChange = fn
     return promise
   }
+  promise.expire = (fn) => {
+    promise.onExpire = fn
+    return promise
+  }
   promise.cancel = (fn) => {
     fn = fn || function(){}
     subscription.remove()
   fetch,
   base64,
   android,
+  ios,
   config,
   session,
   fs,
   wrap,
-  polyfill
+  net,
+  polyfill,
+  JSONStream
 }

src/ios.js

+// Copyright 2016 wkh237@github. All rights reserved.
+// Use of this source code is governed by a MIT-style license that can be
+// found in the LICENSE file.
+// @flow
+
+import {
+  NativeModules,
+  DeviceEventEmitter,
+  Platform,
+  NativeAppEventEmitter,
+} from 'react-native'
+
+const RNFetchBlob:RNFetchBlobNative = NativeModules.RNFetchBlob
+
+/**
+ * Open a file using UIDocumentInteractionController
+ * @param  {string]} path Path of the file to be open.
+ * @param  {string} scheme URI scheme that needs to support, optional
+ * @return {Promise}
+ */
+function previewDocument(path:string, scheme:string) {
+  if(Platform.OS === 'ios')
+    return RNFetchBlob.previewDocument('file://' + path, scheme)
+  else
+    return Promise.reject('RNFetchBlob.openDocument only supports IOS.')
+}
+
+/**
+ * Preview a file using UIDocumentInteractionController
+ * @param  {string]} path Path of the file to be open.
+ * @param  {string} scheme URI scheme that needs to support, optional
+ * @return {Promise}
+ */
+function openDocument(path:string, scheme:string) {
+  if(Platform.OS === 'ios')
+    return RNFetchBlob.openDocument('file://' + path, scheme)
+  else
+    return Promise.reject('RNFetchBlob.previewDocument only supports IOS.')
+}
+
+export default {
+  openDocument,
+  previewDocument
+}

src/ios/RNFetchBlob.xcodeproj/project.pbxproj

 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = iphoneos;
 				VALIDATE_PRODUCT = YES;

src/ios/RNFetchBlob/RNFetchBlob.h

 #ifndef RNFetchBlob_h
 #define RNFetchBlob_h
 #import "RCTBridgeModule.h"
+#import <UIKit/UIKit.h>
 
 
-@interface RNFetchBlob : NSObject <RCTBridgeModule> {
+@interface RNFetchBlob : NSObject <RCTBridgeModule, UIDocumentInteractionControllerDelegate> {
 
     NSString * filePathPrefix;
 
 }
 
 @property (nonatomic) NSString * filePathPrefix;
+@property (retain) UIDocumentInteractionController * documentController;
 
 + (RCTBridge *)getRCTBridge;
++ (void) checkExpiredSessions;
 
 @end
 

src/ios/RNFetchBlob/RNFetchBlob.m

 
 #import "RNFetchBlob.h"
 #import "RCTLog.h"
+#import "RCTRootView.h"
 #import "RCTBridge.h"
 #import "RCTEventDispatcher.h"
 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobProgress.h"
 
 
-RCTBridge * bridgeRef;
+__strong RCTBridge * bridgeRef;
 dispatch_queue_t commonTaskQueue;
 dispatch_queue_t fsQueue;
 
 @implementation RNFetchBlob
 
 @synthesize filePathPrefix;
+@synthesize documentController;
 @synthesize bridge = _bridge;
 
 - (dispatch_queue_t) methodQueue {
 
 + (RCTBridge *)getRCTBridge
 {
-    return bridgeRef;
+    RCTRootView * rootView = [[UIApplication sharedApplication] keyWindow].rootViewController.view;
+    return rootView.bridge;
 }
 
 RCT_EXPORT_MODULE();
         [[NSFileManager defaultManager] createDirectoryAtPath:[RNFetchBlobFS getTempPath] withIntermediateDirectories:YES attributes:nil error:NULL];
     }
     bridgeRef = _bridge;
+    [RNFetchBlobNetwork emitExpiredTasks];
     return self;
 }
 
 - (NSDictionary *)constantsToExport
 {
     return @{
+             @"MainBundleDir" : [RNFetchBlobFS getMainBundleDir],
              @"DocumentDir": [RNFetchBlobFS getDocumentDir],
              @"CacheDir" : [RNFetchBlobFS getCacheDir]
              };
 
 }
 
+
 // Fetch blob data request
 RCT_EXPORT_METHOD(fetchBlob:(NSDictionary *)options
                   taskId:(NSString *)taskId
     [RNFetchBlobFS slice:src dest:dest start:start end:end encode:@"" resolver:resolve rejecter:reject];
 })
 
-#pragma mark RNFetchBlob private methods
+RCT_EXPORT_METHOD(previewDocument:(NSString*)uri scheme:(NSString *)scheme resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+{
+    
+    NSURL * url = [[NSURL alloc] initWithString:uri];
+    documentController = [UIDocumentInteractionController interactionControllerWithURL:url];
+    UIViewController *rootCtrl = [[[[UIApplication sharedApplication] delegate] window] rootViewController];
+    documentController.delegate = self;
+    if(scheme == nil || [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:scheme]]) {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            [documentController  presentOptionsMenuFromRect:rootCtrl.view.bounds inView:rootCtrl.view animated:YES];
+        });
+        resolve(@[[NSNull null]]);
+    } else {
+        reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
+    }
+})
+
+# pragma mark - open file with UIDocumentInteractionController and delegate
+
+RCT_EXPORT_METHOD(openDocument:(NSString*)uri scheme:(NSString *)scheme resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+{
+    
+    NSURL * url = [[NSURL alloc] initWithString:uri];
+    documentController = [UIDocumentInteractionController interactionControllerWithURL:url];
+    documentController.delegate = self;
+    
+    if(scheme == nil || [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:scheme]]) {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            [documentController presentPreviewAnimated:YES];
+        });
+        resolve(@[[NSNull null]]);
+    } else {
+        reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
+    }
+})
+
+RCT_EXPORT_METHOD(df:(RCTResponseSenderBlock)callback
+{
+    [RNFetchBlobFS df:callback];
+})
+
+- (UIViewController *) documentInteractionControllerViewControllerForPreview: (UIDocumentInteractionController *) controller {
+    UIWindow *window = [UIApplication sharedApplication].keyWindow;
+    return window.rootViewController;
+}
+
+# pragma mark - getCookies
+RCT_EXPORT_METHOD(getCookies:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+{
+    resolve([RNFetchBlobNetwork getCookies:url]);
+})
+
+# pragma mark - check expired network events
+
+RCT_EXPORT_METHOD(emitExpiredEvent:(RCTResponseSenderBlock)callback
+{
+    [RNFetchBlobNetwork emitExpiredTasks];
+})
 
 
 @end

src/ios/RNFetchBlobConst.h

 extern NSString *const MSG_EVENT_WARN;
 extern NSString *const MSG_EVENT_ERROR;
 
+extern NSString *const EVENT_EXPIRE;
 extern NSString *const EVENT_PROGRESS;
 extern NSString *const EVENT_SERVER_PUSH;
 extern NSString *const EVENT_PROGRESS_UPLOAD;

src/ios/RNFetchBlobConst.m

 extern NSString *const ASSET_PREFIX = @"bundle-assets://";
 extern NSString *const AL_PREFIX = @"assets-library://";
 
-
-
 // fetch configs
 extern NSString *const CONFIG_USE_TEMP = @"fileCache";
 extern NSString *const CONFIG_FILE_PATH = @"path";
 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";
 
 extern NSString *const MSG_EVENT = @"RNFetchBlobMessage";
 extern NSString *const MSG_EVENT_LOG = @"log";

src/ios/RNFetchBlobFS.h

 @property (nonatomic) BOOL appendData;
 
 // get dirs
++ (NSString *) getMainBundleDir;
 + (NSString *) getTempPath;
 + (NSString *) getCacheDir;
 + (NSString *) getDocumentDir;
 //+ (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;
++ (void) df:(RCTResponseSenderBlock)callback;
 
 // constructor
 - (id) init;
 - (void) closeInStream;
 - (void) closeOutStream;
 
+- (void) openFile:( NSString * _Nonnull ) uri;
+
 @end
 
 #endif /* RNFetchBlobFS_h */

src/ios/RNFetchBlobFS.m

 //  File system access methods
 //
 ////////////////////////////////////////
-
+@interface RNFetchBlobFS() {
+    UIDocumentInteractionController * docCtrl;
+}
+@end
 @implementation RNFetchBlobFS
 
 
 
 #pragma mark - system directories
 
++ (NSString *) getMainBundleDir {
+    return [[NSBundle mainBundle] bundlePath];
+}
+
 + (NSString *) getCacheDir {
     return [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
 }
 
 + (NSString *) getTempPath {
     
-    return [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject] stringByAppendingString:@"/RNFetchBlob_tmp"];
+    return NSTemporaryDirectory();
 }
 
 + (NSString *) getTempPath:(NSString*)taskId withExtension:(NSString *)ext {
             }
             else
             {
-                BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:path];
-                if(!exists) {
-                    reject(@"RNFetchBlobFS readFile error", @"file not exists", [[NSError alloc]init]);
+                if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+                    
+                    reject(@"RNFetchBlobFS readFile error", @"file not exists", nil);
                     return;
                 }
                 fileContent = [NSData dataWithContentsOfFile:path];
     }
 }
 
+#pragma mark - get disk space
+
++(void) df:(RCTResponseSenderBlock)callback
+{
+    uint64_t totalSpace = 0;
+    uint64_t totalFreeSpace = 0;
+    NSError *error = nil;
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error: &error];
+    
+    if (dictionary) {
+        NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];
+        NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
+        totalSpace = [fileSystemSizeInBytes unsignedLongLongValue];
+        totalFreeSpace = [freeFileSystemSizeInBytes unsignedLongLongValue];
+        callback(@[[NSNull null], @{
+                  @"free" : [NSString stringWithFormat:@"%d", totalFreeSpace],
+                  @"total" : [NSString stringWithFormat:@"%d", totalSpace]
+                }]);
+    } else {
+        callback(@[@"failed to get storage usage."]);
+    }
+    
+}
+
 + (void) writeAssetToPath:(ALAssetRepresentation * )rep dest:(NSString *)dest
 {
     int read = 0;

src/ios/RNFetchBlobNetwork.h

 //  Copyright © 2016 wkh237. All rights reserved.
 //
 
-#ifndef RNFetchBlobResp_h
-#define RNFetchBlobResp_h
+#ifndef RNFetchBlobNetwork_h
+#define RNFetchBlobNetwork_h
 
 #import <Foundation/Foundation.h>
 #import "RCTBridgeModule.h"
 @property (nullable, nonatomic) NSError * error;
 
 
-- (nullable id) init;
-- (void) sendRequest;
-
 + (NSMutableDictionary  * _Nullable ) normalizeHeaders:(NSDictionary * _Nullable)headers;
 + (void) cancelRequest:(NSString *)taskId;
++ (void) enableProgressReport:(NSString *) taskId;
++ (void) enableUploadProgress:(NSString *) taskId;
++ (void) emitExpiredTasks;
+
+- (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;
-- (void) sendRequest:(NSDictionary  * _Nullable )options contentLength:(long)contentLength bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
++ (NSArray *) getCookies:(NSString *) url;
+
 
 
 @end
 
 
-#endif /* RNFetchBlobResp_h */
+#endif /* RNFetchBlobNetwork_h */

src/ios/RNFetchBlobNetwork.m

 #import "RCTLog.h"
 #import <Foundation/Foundation.h>
 #import "RCTBridge.h"
+#import "RNFetchBlob.h"
 #import "RCTEventDispatcher.h"
 #import "RNFetchBlobFS.h"
+#import "RCTRootView.h"
 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
 #import "RNFetchBlobReqBuilder.h"
 ////////////////////////////////////////
 
 NSMapTable * taskTable;
+NSMapTable * expirationTable;
+NSMapTable * cookiesTable;
 NSMutableDictionary * progressTable;
 NSMutableDictionary * uploadProgressTable;
 
 {
     BOOL * respFile;
     BOOL isNewPart;
+    BOOL * isIncrement;
     NSMutableData * partBuffer;
     NSString * destPath;
     NSOutputStream * writeStream;
         taskQueue = [[NSOperationQueue alloc] init];
         taskQueue.maxConcurrentOperationCount = 10;
     }
-    if(taskTable == nil) {
+    if(expirationTable == nil)
+    {
+        expirationTable = [[NSMapTable alloc] init];
+    }
+    if(taskTable == nil)
+    {
         taskTable = [[NSMapTable alloc] init];
     }
     if(progressTable == nil)
     {
         uploadProgressTable = [[NSMutableDictionary alloc] init];
     }
+    if(cookiesTable == nil)
+    {
+        cookiesTable = [[NSMapTable alloc] init];
+    }
     return self;
 }
 
++ (NSArray *) getCookies:(NSString *) url
+{
+    NSString * hostname = [[NSURL URLWithString:url] host];
+    NSMutableArray * cookies = [NSMutableArray new];
+    NSArray * list = [cookiesTable objectForKey:hostname];
+    for(NSHTTPCookie * cookie in list)
+    {
+        NSMutableString * cookieStr = [[NSMutableString alloc] init];
+        [cookieStr appendString:cookie.name];
+        [cookieStr appendString:@"="];
+        [cookieStr appendString:cookie.value];
+        
+        if(cookie.expiresDate == nil) {
+            [cookieStr appendString:@"; max-age=0"];
+        }
+        else {
+            [cookieStr appendString:@"; expires="];
+            NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
+            [dateFormatter setDateFormat:@"EEE, dd MM yyyy HH:mm:ss ZZZ"];
+            NSString *strDate = [dateFormatter stringFromDate:cookie.expiresDate];
+            [cookieStr appendString:strDate];
+        }
+        
+        
+        [cookieStr appendString:@"; domain="];
+        [cookieStr appendString:hostname];
+        [cookieStr appendString:@"; path="];
+        [cookieStr appendString:cookie.path];
+        
+        
+        if (cookie.isSecure) {
+            [cookieStr appendString:@"; secure"];
+        }
+        
+        if (cookie.isHTTPOnly) {
+            [cookieStr appendString:@"; httponly"];
+        }
+        [cookies addObject:cookieStr];
+    }
+    return cookies;
+}
+
 + (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
     [progressTable setValue:config forKey:taskId];
     self.expectedBytes = 0;
     self.receivedBytes = 0;
     self.options = options;
+    isIncrement = [options valueForKey:@"increment"] == nil ? NO : [[options valueForKey:@"increment"] boolValue];
     redirects = [[NSMutableArray alloc] init];
-    [redirects addObject:req.URL.absoluteString];
-    
+    if(req.URL != nil)
+        [redirects addObject:req.URL.absoluteString];
+
     // set response format
     NSString * rnfbResp = [req.allHTTPHeaderFields valueForKey:@"RNFB-Response"];
     if([[rnfbResp lowercaseString] isEqualToString:@"base64"])
     bodyLength = contentLength;
 
     // the session trust any SSL certification
-    NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
+//    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;
     }
-    NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
+
+    __block NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
     [taskTable setObject:task forKey:taskId];
     [task resume];
 
     // network status indicator
     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
+    UIBackgroundTaskIdentifier tid = [app beginBackgroundTaskWithName:taskId expirationHandler:^{
+        NSLog([NSString stringWithFormat:@"session %@ expired", taskId ]);
+        [expirationTable setObject:task forKey:taskId];
+        [app endBackgroundTask:tid];
+    }];
+
+
+}
+
+// #115 Invoke fetch.expire event on those expired requests so that the expired event can be handled
++ (void) emitExpiredTasks
+{
+    NSEnumerator * emu =  [expirationTable keyEnumerator];
+    NSString * key;
+
+    while((key = [emu nextObject]))
+    {
+        RCTBridge * bridge = [RNFetchBlob getRCTBridge];
+        NSData * args = @{ @"taskId": key };
+        [bridge.eventDispatcher sendDeviceEventWithName:EVENT_EXPIRE body:args];
+
+    }
+    
+    // clear expired task entries
+    [expirationTable removeAllObjects];
+    expirationTable = [[NSMapTable alloc] init];
+
 }
 
 ////////////////////////////////////////
 
 #pragma mark NSURLSession delegate methods
 
+
+#pragma mark - Received Response
 // set expected content length on response received
 - (void) URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveResponse:(NSURLResponse *)response completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
 {
                      @"redirects": redirects,
                      @"respType" : respType,
                      @"timeout" : @NO,
-                     @"status": [NSString stringWithFormat:@"%d", statusCode ]
+                     @"status": [NSNumber numberWithInteger:statusCode]
                     };
 
+#pragma mark - handling cookies
+        // # 153 get cookies
+        if(response.URL != nil)
+        {
+            NSArray<NSHTTPCookie *> * cookies = [NSHTTPCookie cookiesWithResponseHeaderFields: headers forURL:response.URL];
+            if(cookies != nil && [cookies count] > 0) {
+                [cookiesTable setObject:cookies forKey:response.URL.host];
+            }
+        }
+        
         [self.bridge.eventDispatcher
          sendDeviceEventWithName: EVENT_STATE_CHANGE
          body:respInfo
         ];
         headers = nil;
         respInfo = nil;
+
     }
     else
         NSLog(@"oops");
             {
                 [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:nil];
             }
+            BOOL overwrite = [options valueForKey:@"overwrite"] == nil ? YES : [[options valueForKey:@"overwrite"] boolValue];
             BOOL appendToExistingFile = [destPath RNFBContainsString:@"?append=true"];
+            
+            appendToExistingFile = !overwrite;
+
             // For solving #141 append response data if the file already exists
             // base on PR#139 @kejinliang
             if(appendToExistingFile)
             {
                 [fm createFileAtPath:destPath contents:[[NSData alloc] init] attributes:nil];
             }
-            writeStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:YES];
+            writeStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:appendToExistingFile];
             [writeStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
             [writeStream open];
         }
         [partBuffer appendData:data];
         return ;
     }
-    
+
     NSNumber * received = [NSNumber numberWithLong:[data length]];
     receivedBytes += [received longValue];
+    NSString * chunkString = @"";
+
+    if(isIncrement == YES)
+    {
+        chunkString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    }
+
     if(respFile == NO)
     {
         [respData appendData:data];
          body:@{
                 @"taskId": taskId,
                 @"written": [NSString stringWithFormat:@"%d", receivedBytes],
-                @"total": [NSString stringWithFormat:@"%d", expectedBytes]
+                @"total": [NSString stringWithFormat:@"%d", expectedBytes],
+                @"chunk": chunkString
             }
          ];
     }
     {
         errMsg = [error localizedDescription];
     }
-    else
+
+    if(respFile == YES)
     {
-        if(respFile == YES)
+        [writeStream close];
+        rnfbRespType = RESP_TYPE_PATH;
+        respStr = destPath;
+    }
+    // base64 response
+    else {
+        // #73 fix unicode data encoding issue :
+        // when response type is BASE64, we should first try to encode the response data to UTF8 format
+        // 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)
         {
-            [writeStream close];
-            rnfbRespType = RESP_TYPE_PATH;
-            respStr = destPath;
+            rnfbRespType = RESP_TYPE_BASE64;
+            respStr = [respData base64EncodedStringWithOptions:0];
         }
-        // base64 response
-        else {
-            // #73 fix unicode data encoding issue :
-            // when response type is BASE64, we should first try to encode the response data to UTF8 format
-            // 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;
-                respStr = [respData base64EncodedStringWithOptions:0];
-            }
-            else if (responseFormat == UTF8)
+        else if (responseFormat == UTF8)
+        {
+            rnfbRespType = RESP_TYPE_UTF8;
+            respStr = utf8;
+        }
+        else
+        {
+            if(utf8 != nil)
             {
                 rnfbRespType = RESP_TYPE_UTF8;
                 respStr = utf8;
             }
             else
             {
-                if(utf8 != nil)
-                {
-                    rnfbRespType = RESP_TYPE_UTF8;
-                    respStr = utf8;
-                }
-                else
-                {
-                    rnfbRespType = RESP_TYPE_BASE64;
-                    respStr = [respData base64EncodedStringWithOptions:0];
-                }
+                rnfbRespType = RESP_TYPE_BASE64;
+                respStr = [respData base64EncodedStringWithOptions:0];
             }
         }
-    }
+        }
+
 
     callback(@[ errMsg, rnfbRespType, respStr]);
 
 
 - (void) URLSession:(NSURLSession *)session didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition, NSURLCredential * _Nullable credantial))completionHandler
 {
-    if([options valueForKey:CONFIG_TRUSTY] != nil)
+    BOOL trusty = [options valueForKey:CONFIG_TRUSTY];
+    if(!trusty)
     {
         completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
     }
     else
     {
-        NSURLSessionAuthChallengeDisposition disposition = NSURLSessionAuthChallengePerformDefaultHandling;
-        __block NSURLCredential *credential = nil;
-        if ([challenge.protectionSpace.authenticationMethod isEqualToString:NSURLAuthenticationMethodServerTrust])
-        {
-            credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
-            if (credential) {
-                disposition = NSURLSessionAuthChallengeUseCredential;
-            } else {
-                disposition = NSURLSessionAuthChallengePerformDefaultHandling;
-            }
-        }
-        else
-        {
-            disposition = NSURLSessionAuthChallengeCancelAuthenticationChallenge;
-            RCTLogWarn(@"counld not create connection with an unstrusted SSL certification, if you're going to create connection anyway, add `trusty:true` to RNFetchBlob.config");
-            [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
-        }
-        if (completionHandler) {
-            completionHandler(disposition, credential);
-        }
+        completionHandler(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
     }
 }
 
+
+- (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
+{
+    NSLog(@"sess done in background");
+}
+
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
 {
-    [redirects addObject:[request.URL absoluteString]];
+    if(request.URL != nil)
+        [redirects addObject:[request.URL absoluteString]];
     completionHandler(request);
 }
 

src/ios/RNFetchBlobProgress.m

 
 -(BOOL)shouldReport:(NSNumber *)nextProgress
 {
-    BOOL result = YES;
+    BOOL * result = YES;
     float countF = [self.count floatValue];
     if(countF > 0 && [nextProgress floatValue] > 0)
     {
     // NSTimeInterval is defined as double
     NSNumber *timeStampObj = [NSNumber numberWithDouble: timeStamp];
     float delta = [timeStampObj doubleValue] - lastTick;
-    BOOL shouldReport = delta > [self.interval doubleValue] && self.enable && result;
+    BOOL * shouldReport = delta > [self.interval doubleValue] && self.enable && result;
     if(shouldReport)
     {
         tick++;

src/json-stream.js

+import Oboe from './lib/oboe-browser.min.js'
+import XMLHttpRequest from './polyfill/XMLHttpRequest'
+import URIUtil from './utils/uri'
+
+const OboeExtended = (arg: string | object) => {
+
+
+  window.location = ''
+
+  if(!window.XMLHttpRequest.isRNFBPolyfill ) {
+    window.XMLHttpRequest = XMLHttpRequest
+    console.warn('Use JSONStream will automatically replace window.XMLHttpRequest with RNFetchBlob.polyfill.XMLHttpRequest. You are seeing this warning because you did not replace it maually.')
+  }
+
+  if(typeof arg === 'string') {
+    if(URIUtil.isFileURI(arg)) {
+      arg = {
+        url : 'JSONStream://' + arg,
+        headers : { noCache : true }
+      }
+    }
+    else
+      arg = 'JSONStream://' + arg
+
+  }
+  else if(typeof arg === 'object') {
+    let headers = arg.headers || {}
+    if(URIUtil.isFileURI(arg.url)) {
+      headers.noCache = true
+    }
+    arg = Object.assign(arg, {
+      url : 'JSONStream://' + arg.url,
+      headers
+    })
+  }
+  return Oboe(arg)
+}
+
+export default OboeExtended

src/net.js

+// Copyright 2016 wkh237@github. All rights reserved.
+// Use of this source code is governed by a MIT-style license that can be
+// found in the LICENSE file.
+// @flow
+
+import {
+  NativeModules,
+  DeviceEventEmitter,
+  Platform,
+  NativeAppEventEmitter,
+} from 'react-native'
+
+const RNFetchBlob = NativeModules.RNFetchBlob
+
+/**
+ * Get cookie according to the given url.
+ * @param  {string} url HTTP URL string.
+ * @return {Promise<Array<String>>}     Cookies of a specific domain.
+ */
+function getCookies(url:string):Promise<Array<String>> {
+  return RNFetchBlob.getCookies(url)
+}
+
+export default {
+  getCookies
+}

src/package.json

 {
   "name": "react-native-fetch-blob",
-  "version": "0.9.6",
+  "version": "0.10.0",
   "description": "A module provides upload, download, and files access API. Supports file stream read/write for process large files.",
   "main": "index.js",
   "scripts": {
   "repository": {
     "url": "https://github.com/wkh237/react-native-fetch-blob.git"
   },
-  "author": "wkh237",
-  "license": "MIT"
-}
+  "author": "wkh237 <xeiyan@gmail.com>",
+  "license": "MIT",
+  "contributors": [
+    "Andreas Amsenius <andreas@amsenius.se>",
+    "Corentin Smith <corentin.smith@gmail.com>",
+    "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>",
+    "Mike Monteith <mike@mikemonteith.com>",
+    "Nguyen Cao Nhat Linh <nhatlinh95@gmail.com>",
+    "Tim Suchanek <tim.suchanek@gmail.com>",
+    "follower <github@rancidbacon.com>",
+    "francisco-sanchez-molina <psm1984@gmail.com>",
+    "kejinliang <kejinliang@users.noreply.github.com>",
+    "smartt <github@eriksmartt.com>",
+    ""
+  ]
+}

src/polyfill/Fetch.js

         // When request body is a Blob, use file URI of the Blob as request body.
         else if (body.isRNFetchBlobPolyfill)
           promise = Promise.resolve(RNFetchBlob.wrap(body.blobPath))
-        else if (typeof body !== 'object')
+        else if (typeof body !== 'object' && options.headers['Content-Type'] !== 'application/json')
           promise = Promise.resolve(JSON.stringify(body))
         else if (typeof body !== 'string')
           promise = Promise.resolve(body.toString())

src/polyfill/XMLHttpRequest.js

 import Log from '../utils/log.js'
 import Blob from './Blob.js'
 import ProgressEvent from './ProgressEvent.js'
+import URIUtil from '../utils/uri'
 
 const log = new Log('XMLHttpRequest')
 
 
   // readonly
   _readyState : number = UNSENT;
+  _uriType : 'net' | 'file' = 'net';
   _response : any = '';
-  _responseText : any = null;
+  _responseText : any = '';
   _responseHeaders : any = {};
   _responseType : '' | 'arraybuffer' | 'blob'  | 'json' | 'text' = '';
   // TODO : not suppoted ATM
   _timeout : number = 60000;
   _sendFlag : boolean = false;
   _uploadStarted : boolean = false;
+  _increment : boolean = false;
 
   // RNFetchBlob compatible data structure
   _config : RNFetchBlobConfig = {};
     this._method = method
     this._url = url
     this._headers = {}
+    this._increment = URIUtil.isJSONStreamURI(this._url)
+    this._url = this._url.replace(/^JSONStream\:\/\//, '')
     this._dispatchReadStateChange(XMLHttpRequest.OPENED)
   }
 
    * @param  {any} body Body in RNfetchblob flavor
    */
   send(body) {
+
     this._body = body
+
     if(this._readyState !== XMLHttpRequest.OPENED)
       throw 'InvalidStateError : XMLHttpRequest is not opened yet.'
     let promise = Promise.resolve()
       for(let h in _headers) {
         _headers[h] = _headers[h].toString()
       }
+
       this._task = RNFetchBlob
                     .config({
                       auto: true,
                       timeout : this._timeout,
+                      increment : this._increment,
                       binaryContentTypes : XMLHttpRequest.binaryContentTypes
                     })
                     .fetch(_method, _url, _headers, body)
           .progress(this._progressEvent.bind(this))
           .catch(this._onError.bind(this))
           .then(this._onDone.bind(this))
+
     })
   }
 
     this.upload.dispatchEvent('progress', new ProgressEvent(true, send, total))
   }
 
-  _progressEvent(send:number, total:number) {
+  _progressEvent(send:number, total:number, chunk:string) {
     log.verbose(this.readyState)
     if(this._readyState === XMLHttpRequest.HEADERS_RECEIVED)
       this._dispatchReadStateChange(XMLHttpRequest.LOADING)
     if(total && total >= 0)
         lengthComputable = true
     let e = new ProgressEvent(lengthComputable, send, total)
+
+    if(this._increment) {
+      this._responseText += chunk
+    }
     this.dispatchEvent('progress', e)
   }
 
     return this._responseType
   }
 
-  get isRNFBPolyfill() {
+  static get isRNFBPolyfill() {
     return true
   }
 

src/react-native-fetch-blob.podspec

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

src/utils/uri.js

+export default {
+
+  isFileURI : (uri:string):boolean => {
+    if(typeof uri !== 'string')
+      return false
+    return /^RNFetchBlob-file\:\/\//.test(uri)
+  },
+
+  isJSONStreamURI : (uri:string):boolean => {
+    if(typeof uri !== 'string')
+      return false
+    return /^JSONStream\:\/\//.test(uri)
+  },
+
+  removeURIScheme : (uri:string, iterations:number):string => {
+    iterations = iterations || 1
+    let result = uri
+    for(let i=0;i<iterations;i++) {
+      result = String(result).replace(/^[^\:]+\:\/\//, '')
+    }
+    return String(result)
+  },
+
+  unwrapFileURI : (uri:string):string => {
+    return String(uri).replace(/^RNFetchBlob-file\:\/\//, '')
+  }
+
+}

test-server/public/json-dummy-1.json

+{
+  "name" : "fetchblob-dev"
+}

test-server/server.js

   next();
 })
 
+
+app.get('/10s-download', (req,res) => {
+  var count = 0
+  var data = ''
+  for(var i =0;i<1024000;i++)
+    data += '1'
+  res.set('Contet-Length', 1024000*10)
+  var it = setInterval(() => {
+    res.write(data)
+    count++
+    if(count == 10) {
+      clearInterval(it)
+      res.end()
+    }
+  }, 1000)
+})
+
 app.get('/video/:count', (req, res) => {
   var count = 0
   res.set('Content-Type', 'multipart/x-mixed-replace; boundary="---osclivepreview---"')
   }, 5000)
 })
 
-app.get('/10s-download', (req,res) => {
-  var count = 0
-  var data = ''
-  for(var i =0;i<1024000;i++)
-    data += '1'
-  res.set('Contet-Length', 1024000*10)
+app.all('/long/:ticks', (req, res) => {
+  var count = 0;
   var it = setInterval(() => {
-    res.write(data)
-    count++
-    if(count == 10) {
+    console.log('write data', count)
+    res.write('a')
+    if(++count > req.params.ticks){
       clearInterval(it)
       res.end()
     }
-  }, 1000)
+  }, 1000);
+
 })
 
-app.all('/long', (req, res) => {
-  var count = 0;
+app.all('/long/', (req, res) => {  var count = 0;
   var it = setInterval(() => {
     console.log('write data', count)
     res.write('a')
 
 })
 
+app.all('/cookie/:data', (req, res) => {
+  res.cookie('cookieName', req.params.data);
+  res.end()
+})
+
+app.all('/err-body', (req, res) => {
+  res.status(400)
+  res.write(JSON.stringify({ data : Date.now() }))
+  res.end()
+})
+
 app.all('/timeout', (req, res) => {
 })
 

test-server/test.jpeg

+undefined

test/test-0.10.0.js

+import RNTest from './react-native-testkit/'
+import React from 'react'
+import RNFetchBlob from 'react-native-fetch-blob'
+import {
+  StyleSheet,
+  Text,
+  View,
+  ScrollView,
+  Linking,
+  Platform,
+  Dimensions,
+  BackAndroid,
+  AsyncStorage,
+  Image,
+} from 'react-native';
+
+window.XMLHttpRequest = RNFetchBlob.polyfill.XMLHttpRequest
+window.Blob = RNFetchBlob.polyfill.Blob
+
+const JSONStream = RNFetchBlob.JSONStream
+const fs = RNFetchBlob.fs
+const { Assert, Comparer, Info, prop } = RNTest
+const describe = RNTest.config({
+  group : '0.10.0',
+  run : true,
+  expand : false,
+  timeout : 20000,
+})
+const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, FILENAME, DROPBOX_TOKEN, styles } = prop()
+const dirs = RNFetchBlob.fs.dirs
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
+let begin = Date.now()
+
+describe('json stream via HTTP', (report, done) => {
+
+  let count = 0
+  JSONStream(`${TEST_SERVER_URL}/public/json-dummy.json`).node('name', (name) => {
+    count++
+    if(Date.now() - begin < 100)
+    return
+    begin = Date.now()
+    report(<Info key="report" uid="100">
+      <Text>{count} records</Text>
+    </Info>)
+    done()
+  })
+
+})
+
+describe('json stream via fs', (report, done) => {
+
+  let fetch2 = new RNFetchBlob.polyfill.Fetch({
+    auto : true
+  })
+  let res = null
+  let count = 0
+
+  RNFetchBlob.config({
+    fileCache : true
+  })
+  .fetch('GET',`${TEST_SERVER_URL}/public/json-dummy.json`)
+  .then((resp) => {
+    res = resp
+    JSONStream({
+      url : RNFetchBlob.wrap(res.path()),
+      headers : { bufferSize : 10240 }
+    }).node('name', (name) => {
+      count++
+      if(Date.now() - begin < 100)
+      return
+      begin = Date.now()
+      report(<Info key="report" uid="100">
+        <Text>{count} records</Text>
+      </Info>)
+      done()
+    })
+  })
+})
+
+
+describe('cookie test', (report, done) => {
+  let time = Date.now()
+  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/cookie/${time}`)
+  .then((res) => RNFetchBlob.net.getCookies(`${TEST_SERVER_URL}`))
+  .then((cookies) => {
+    let result = /cookieName\=[^;]+/.exec(cookies[0])
+    console.log(result, 'cookieName=' + time)
+    report(<Assert key="cookie should not be empty"
+      expect={'cookieName=' + time}
+      actual={result[0]}/>)
+    done()
+  })
+
+})
+
+describe('SSL test #159', (report, done) => {
+  RNFetchBlob.config({
+    trusty : true
+    })
+    .fetch('GET', `${TEST_SERVER_URL_SSL}/public/github.png`, {
+      'Cache-Control' : 'no-store'
+    })
+    .then(res => {
+      report(<Assert
+        key="trusty request should pass"
+        expect={true}
+        actual={true}/>)
+      return RNFetchBlob.fetch('GET',`${TEST_SERVER_URL_SSL}/public/github.png`)
+    })
+    .catch(e => {
+      report(<Assert
+        key="non-trusty request should not pass"
+        expect={true}
+        actual={true}/>)
+      done()
+    })
+})
+
+describe('#171 appendExt verify', (report, done) => {
+
+  RNFetchBlob.config({
+    fileCache : true,
+    appendExt : 'png'
+  })
+  .fetch('GET', `${TEST_SERVER_URL}/public/github.png`, {
+    'Cache-Control' : 'no-store'
+  })
+  .then(res => {
+    console.log(res.path())
+    report(<Assert
+      key="extension appended to tmp path"
+      actual={/.png$/.test(res.path())}
+      expect={true}/>)
+    return fs.stat(res.path())
+  })
+  .then(stat => {
+    report(<Assert
+      key="verify the file existence"
+      expect="23975"
+      actual={stat.size} />)
+    done()
+  })
+
+})
+
+describe('#173 issue with append option', (report, done) => {
+  let dest = dirs.DocumentDir + '/tmp' + Date.now()
+  RNFetchBlob.config({
+    path : dest,
+    overwrite : true
+  })
+  .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
+  .then((res) => fs.stat(res.path()))
+  .then((stat) => {
+    report(<Assert
+      key="file size check #1"
+      expect="23975"
+      actual={stat.size}/>)
+    return RNFetchBlob.config({
+      path : dest,
+      overwrite : false
+    })
+    .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
+  })
+  .then((res) => fs.stat(res.path()))
+  .then((stat) => {
+    report(<Assert
+      key="file size check #2"
+      expect="47950"
+      actual={stat.size}/>)
+    return RNFetchBlob.config({
+      path : dest,
+      overwrite : true
+    })
+    .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
+  })
+  .then((res) => fs.stat(res.path()))
+  .then((stat) => {
+    report(<Assert
+      key="file size check #3"
+      expect="23975"
+      actual={stat.size}/>)
+    return RNFetchBlob.config({
+      path : dest,
+    })
+    .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
+  })
+  .then((res) => fs.stat(res.path()))
+  .then((stat) => {
+    report(<Assert
+      key="it should successfully overwrite existing file without config"
+      expect="23975"
+      actual={stat.size}/>)
+    done()
+  })
+
+})
+
+describe('#171 verification ', (report, done) => {
+
+  RNFetchBlob
+    .config({
+      session: 'SESSION_NAME',
+      fileCache: true,
+      appendExt: 'mp4'
+    })
+    .fetch('GET', `${TEST_SERVER_URL}/public/cat-fu.mp4`)
+    .then(res => {
+      console.log(res.path())
+    })
+
+
+
+})

test/test-0.6.2.js

 
 describe('Upload multipart data with file from CameraRoll', (report, done) => {
     let filename = 'test-from-storage-img-'+Date.now()+'.png'
+    console.log(photo)
     RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/upload-form`, {
         'Content-Type' : 'multipart/form-data',
       }, [
   let assetName = fs.asset('test-asset1.json')
   RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
     Authorization : `Bearer ${DROPBOX_TOKEN}`,
-    'Dropbox-API-Arg': `{\"path\": \"/rn-upload/file-from-asset-${Platform.OS}.json\",\"mode\": \"add\",\"autorename\": false,\"mute\": false}`,
+    'Dropbox-API-Arg': `{\"path\": \"/rn-upload/file-from-asset-${Platform.OS}.json\",\"mode\": \"overwrite\",\"autorename\": false,\"mute\": false}`,
     'Content-Type' : 'application/octet-stream',
   }, RNFetchBlob.wrap(assetName))
   .then((resp) => {
+    console.log(resp)
     resp = resp.json()
     report(
       <Assert key="file name check"

test/test-0.9.4.js

 
 window.XMLHttpRequest = RNFetchBlob.polyfill.XMLHttpRequest
 window.Blob = RNFetchBlob.polyfill.Blob
+window.fetch = new RNFetchBlob.polyfill.Fetch({
+  auto : true,
+  binaryContentTypes : ['image/', 'video/', 'audio/']
+}).build()
 
 const fs = RNFetchBlob.fs
 const { Assert, Comparer, Info, prop } = RNTest
       return res.json()
     })
     .then((data) => {
-      // console.log(data)
+      console.log(data)
       report(<Assert key="fetch request success" expect={20000} actual={data.total}/>)
       done()
     })
 })
 
 describe('issue #111 get redirect destination', (report, done) => {
-  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/redirect`)
+  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/redirect`, {
+    'Cache-Control' : 'no-store'
+  })
   .then((res) => {
     console.log(res.info())
     report(

test/test-0.9.5.js

 
 describe('issue #122 force response data format', (report, done) => {
 
-  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/public/json-dummy.json`, {
+  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/public/json-dummy-1.json`, {
     'RNFB-Response' : 'base64'
   })
   .then((res) => {
     report(
       <Assert key="test data verify" expect="fetchblob-dev" actual={JSON.parse(r).name}/>,
       <Assert key="should successfully decode the data" expect={true} actual={true}/>)
-    return RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/public/json-dummy.json`)
+    return RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/public/json-dummy-1.json`)
   })
   .then((res) => {
     report(
 
 })
 
-false && describe('#131 status code != 200 should not throw an error', (report, done) => {
+describe('#131 status code != 200 should not throw an error', (report, done) => {
 
   let count = 0
   let codes = [404, 500, 501, 403]

test/test-background.js

+import RNTest from './react-native-testkit/'
+import React from 'react'
+import RNFetchBlob from 'react-native-fetch-blob'
+import {
+  StyleSheet,
+  Text,
+  View,
+  ScrollView,
+  Linking,
+  Platform,
+  Dimensions,
+  AsyncStorage,
+  Image,
+} from 'react-native';
+const JSONStream = RNFetchBlob.JSONStream
+const fs = RNFetchBlob.fs
+const { Assert, Comparer, Info, prop } = RNTest
+const describe = RNTest.config({
+  group : 'background',
+  run : true,
+  expand : true,
+  timeout : 20000,
+})
+const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, FILENAME, DROPBOX_TOKEN, styles } = prop()
+const dirs = RNFetchBlob.fs.dirs
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
+let begin = Date.now()
+
+describe('background http response', (report, done) => {
+  let count = 0
+
+  let task = RNFetchBlob.config({
+    timeout : -1
+  }).fetch('GET', `${TEST_SERVER_URL}/long/3600`, {
+    'Cache-Control' : 'no-store'
+  })
+
+  task.expire(() => {
+    done()
+  })
+
+  task.catch((err) => {
+    console.log(err)
+  })
+
+  task.then((res) => {
+    console.log('resp response received', res.data.length)
+    // done()
+  })
+
+})

test/test-init.js

 
 // test environment variables
 
-prop('FILENAME', `${Platform.OS}-0.8.0-${Date.now()}.png`)
+prop('FILENAME', `${Platform.OS}-0.10.0-${Date.now()}.png`)
 prop('TEST_SERVER_URL', 'http://localhost:8123')
 prop('TEST_SERVER_URL_SSL', 'https://localhost:8124')
-// prop('TEST_SERVER_URL', 'http://192.168.17.194:8123')
-// prop('TEST_SERVER_URL_SSL', 'https://192.168.17.194:8124')
+// prop('TEST_SERVER_URL', 'http://192.168.0.12:8123')
+// prop('TEST_SERVER_URL_SSL', 'https://192.168.0.12:8124')
 prop('DROPBOX_TOKEN', 'fsXcpmKPrHgAAAAAAAAAoXZhcXYWdgLpQMan6Tb_bzJ237DXhgQSev12hA-gUXt4')
 prop('styles', {
   image : {
 // require('./test-0.9.4')
 // require('./test-0.9.5')
 // require('./test-0.9.6')
-require('./test-stream')
+require('./test-0.10.0')
+// require('./test-background.js')
+// require('./test-stream')
 // require('./test-fetch')
 // require('./test-fs')
 // require('./test-xmlhttp')

test/test-readable.js

+import RNTest from './react-native-testkit/'
+import React from 'react'
+import RNFetchBlob from 'react-native-fetch-blob'
+import Timer from 'react-timer-mixin'
+
+import {
+  StyleSheet,
+  Text,
+  View,
+  ScrollView,
+  CameraRoll,
+  Platform,
+  Dimensions,
+  Image,
+} from 'react-native';
+
+import EventEmitter from 'EventEmitter'
+
+const fs = RNFetchBlob.fs
+
+const Readable = RNFetchBlob.polyfill.Readable
+const { Assert, Comparer, Info, prop } = RNTest
+const describe = RNTest.config({
+  group : 'Blob',
+  run : true,
+  expand : false,
+  timeout : 20000,
+})
+const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, DROPBOX_TOKEN, styles } = prop()
+const  dirs = RNFetchBlob.fs.dirs
+
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
+let file = RNTest.prop('image')
+
+describe('first test', (report, done) => {
+  let e = new EventEmitter()
+  console.log(e)
+  e.addListener('aaa', (data) => { console.log(data) })
+  e.emit('aaa', 123)
+})