Merge branch '0.10.9'

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

README.md

-## New Maintainers
-
-We make quite a bit of use of react-native-fetch-blob at Jolt and would like to maintain the project.  Feel free to open issues, PRs, etc. here as you would on the original repository.  We will be investigating a new npm namespace under which to publish future versions of this library.
-
-<br>
-
-## About Pull Requests
-
-Bugfixes should be applied to the `0.10.9` branch and new features should be applied to the `0.11.0`. Documentation/README updates can be applied directly to `master`.
-
-<br>
-
 # 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)]()
 
 * [Installation](#user-content-installation)
 * [HTTP Data Transfer](#user-content-http-data-transfer)
  * [Regular Request](#user-content-regular-request)
- * [Download file](#download-example-fetch-files-that-need-authorization-token)
+ * [Download file](#user-content-download-example--fetch-files-that-needs-authorization-token)
  * [Upload file](#user-content-upload-example--dropbox-files-upload-api)
- * [Multipart/form upload](#multipartform-data-example-post-form-data-with-file-and-data)
+ * [Multipart/form upload](#user-content-multipartform-data-example--post-form-data-with-file-and-data)
  * [Upload/Download progress](#user-content-uploaddownload-progress)
  * [Cancel HTTP request](#user-content-cancel-request)
  * [Android Media Scanner, and Download Manager Support](#user-content-android-media-scanner-and-download-manager-support)
 - [dirs](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#dirs)
 - [createFile](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#createfilepath-data-encodingpromise)
 - [writeFile (0.6.0)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#writefilepathstring-contentstring--array-encodingstring-appendbooleanpromise)
-- [appendFile (0.6.0) ](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#appendfilepathstring-contentstring--array-encodingstringpromise)
+- [appendFile (0.6.0) ](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#appendfilepathstring-contentstring--arraynumber-encodingstring-promisenumber)
 - [readFile (0.6.0)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#readfilepath-encodingpromise)
-- [readStream](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#readstreampath-encoding-buffersizepromise)
-- [writeStream](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#writestreampathstring-encodingstring-appendbooleanpromise)
+- [readStream](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#readstreampath-encoding-buffersize-interval-promisernfbreadstream)
+- [hash (0.10.9)](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#hashpath-algorithm-promise)
+- [writeStream](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#writestreampathstring-encodingstringpromise)
+- [hash](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#hashpath-algorithmpromise)
 - [unlink](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#unlinkpathstringpromise)
 - [mkdir](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#mkdirpathstringpromise)
 - [ls](https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#lspathstringpromise)
       console.log('oops', err)
     })
     ifstream.onEnd(() => {  
-      <Image source={{ uri : 'data:image/png,base64' + data }}/>
+      <Image source={{ uri : 'data:image/png,base64' + data }}
     })
 })
 ```
 
 When using `writeStream`, the stream object becomes writable, and you can then perform operations like `write` and `close`.
 
+Since version 0.10.9 `write()` resolves with the `RNFetchBlob` instance so you can promise-chain write calls:
+
+```js
+RNFetchBlob.fs.writeStream(
+    PATH_TO_FILE,
+    // encoding, should be one of `base64`, `utf8`, `ascii`
+    'utf8',
+    // should data append to existing content ?
+    true
+)
+.then(ofstream => ofstream.write('foo'))
+.then(ofstream => ofstream.write('bar'))
+.then(ofstream => ofstream.write('foobar'))
+.then(ofstream => ofstream.close())
+.catch(console.error)
+```
+
+or 
+
+```js
+RNFetchBlob.fs.writeStream(
+    PATH_TO_FILE,
+    // encoding, should be one of `base64`, `utf8`, `ascii`
+    'utf8',
+    // should data append to existing content ?
+    true
+)
+.then(stream => Promise.all([
+    stream.write('foo'),
+    stream.write('bar'),
+    stream.write('foobar')
+]))
+// Use array destructuring to get the stream object from the first item of the array we get from Promise.all()
+.then(([stream]) => stream.close())
+.catch(console.error)
+```
+
+You should **NOT** do something like this:
+
 ```js
 RNFetchBlob.fs.writeStream(
     PATH_TO_FILE,
     // should data append to existing content ?
     true)
 .then((ofstream) => {
+    // BAD IDEA - Don't do this, those writes are unchecked:
     ofstream.write('foo')
     ofstream.write('bar')
     ofstream.close()
 })
-
+.catch(console.error)  // Cannot catch any write() errors!
 ```
 
+The problem with the above code is that the promises from the `ofstream.write()` calls are detached and "Lost".
+That means the entire promise chain A) resolves without waiting for the writes to finish and B) any errors caused by them are lost.
+That code may _seem_ to work if there are no errors, but those writes are of the type "fire and forget": You start them and then turn away and never know if they really succeeded.
+
 ### Cache File Management
 
 When using `fileCache` or `path` options along with `fetch` API, response data will automatically store into the file system. The files will **NOT** removed unless you `unlink` it. There're several ways to remove the files
 ### Development
 
 If you're interested in hacking this module, check our [development guide](https://github.com/wkh237/react-native-fetch-blob/wiki/Home), there might be some helpful information.
-Please feel free to make a PR or file an issue.
+Please feel free to make a PR or file an issue.

android.js

 
 /**
  * Send an intent to open the file.
- * @param  {string]} path Path of the file to be open.
+ * @param  {string} path Path of the file to be open.
  * @param  {string} mime MIME type string
  * @return {Promise}
  */
     return Promise.reject('RNFetchBlob.android.addCompleteDownload only supports Android.')
 }
 
+function getSDCardDir() {
+  if(Platform.OS === 'android')
+    return RNFetchBlob.getSDCardDir()
+  else
+    return Promise.reject('RNFetchBlob.android.getSDCardDir only supports Android.')
+}
+
+function getSDCardApplicationDir() {
+  if(Platform.OS === 'android')
+    return RNFetchBlob.getSDCardApplicationDir()
+  else
+    return Promise.reject('RNFetchBlob.android.getSDCardApplicationDir only supports Android.')
+}
+
 
 export default {
   actionViewIntent,
   getContentIntent,
-  addCompleteDownload
+  addCompleteDownload,
+  getSDCardDir,
+  getSDCardApplicationDir,
 }

android/build.gradle

 
 dependencies {
     compile 'com.facebook.react:react-native:+'
+    //compile 'com.squareup.okhttp3:okhttp:+'
     //{RNFetchBlob_PRE_0.28_DEPDENDENCY}
 }

android/gradle/wrapper/gradle-wrapper.properties

-#Wed May 18 12:33:41 CST 2016
+#Fri Jun 01 10:33:07 BRT 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip

android/src/main/AndroidManifest.xml

 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.RNFetchBlob">
 
-    <application
-        android:label="@string/app_name">
+    <!-- Required to access Google Play Licensing -->
+    <uses-permission android:name="com.android.vending.CHECK_LICENSE" />
 
+    <!-- Required to download files from Google Play -->
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <!-- Required to keep CPU alive while downloading files
+        (NOT to keep screen awake) -->
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <!-- Required to poll the state of the network connection
+        and respond to changes -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+    <!-- Required to check whether Wi-Fi is enabled -->
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+
+    <!-- Required to read and write the expansion files on shared storage -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
+    <application android:label="@string/app_name">
+
+        <provider
+            android:name="android.support.v4.content.FileProvider"
+            android:authorities="${applicationId}.provider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/provider_paths" />
+        </provider>
     </application>
 
-</manifest>
+</manifest>

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

 import android.app.Activity;
 import android.app.DownloadManager;
 import android.content.Intent;
+import android.content.pm.PackageManager;
 import android.net.Uri;
+import android.os.Build;
+import android.support.v4.content.FileProvider;
+import android.util.SparseArray;
 
 import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Callback;
 import okhttp3.OkHttpClient;
 import okhttp3.JavaNetCookieJar;
 
+import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.LinkedBlockingQueue;
 
 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
-    // Cookies
-    private final ForwardingCookieHandler mCookieHandler;
-    private final CookieJarContainer mCookieJarContainer;
     private final OkHttpClient mClient;
 
     static ReactApplicationContext RCTContext;
-    static LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
-    static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
+    private static LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
+    private 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;
-    static HashMap<Integer, Promise> promiseTable = new HashMap<>();
+    private static ThreadPoolExecutor fsThreadPool = new ThreadPoolExecutor(2, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
+    private static boolean ActionViewVisible = false;
+    private static SparseArray<Promise> promiseTable = new SparseArray<>();
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
 
         super(reactContext);
 
         mClient = OkHttpClientProvider.getOkHttpClient();
-        mCookieHandler = new ForwardingCookieHandler(reactContext);
-        mCookieJarContainer = (CookieJarContainer) mClient.cookieJar();
+        ForwardingCookieHandler mCookieHandler = new ForwardingCookieHandler(reactContext);
+        CookieJarContainer mCookieJarContainer = (CookieJarContainer) mClient.cookieJar();
         mCookieJarContainer.setCookieJar(new JavaNetCookieJar(mCookieHandler));
 
         RCTContext = reactContext;
     }
 
     @ReactMethod
-    public void createFile(final String path, final String content, final String encode, final Callback callback) {
+    public void createFile(final String path, final String content, final String encode, final Promise promise) {
         threadPool.execute(new Runnable() {
             @Override
             public void run() {
-                RNFetchBlobFS.createFile(path, content, encode, callback);
+                RNFetchBlobFS.createFile(path, content, encode, promise);
             }
         });
+    }
 
+    @ReactMethod
+    public void createFileASCII(final String path, final ReadableArray dataArray, final Promise promise) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.createFileASCII(path, dataArray, promise);
+            }
+        });
     }
 
     @ReactMethod
     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);
+            Uri uriForFile = FileProvider.getUriForFile(getCurrentActivity(),
+                    this.getReactApplicationContext().getPackageName() + ".provider", new File(path));
+
+            if (Build.VERSION.SDK_INT >= 24) {
+                // Create the intent with data and type
+                Intent intent = new Intent(Intent.ACTION_VIEW)
+                        .setDataAndType(uriForFile, mime);
+
+                // Set flag to give temporary permission to external app to use FileProvider
+                intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+
+                // Validate that the device can open the file
+                PackageManager pm = getCurrentActivity().getPackageManager();
+                if (intent.resolveActivity(pm) != null) {
+                    this.getReactApplicationContext().startActivity(intent);
+                }
+
+            } else {
+                Intent intent = new Intent(Intent.ACTION_VIEW)
+                        .setDataAndType(Uri.parse("file://" + path), mime).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+                this.getReactApplicationContext().startActivity(intent);
+            }
             ActionViewVisible = true;
 
             final LifecycleEventListener listener = new LifecycleEventListener() {
             };
             RCTContext.addLifecycleEventListener(listener);
         } catch(Exception ex) {
-            promise.reject(ex.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", ex.getLocalizedMessage());
         }
     }
 
-    @ReactMethod
-    public void createFileASCII(final String path, final ReadableArray dataArray, final Callback callback) {
-        threadPool.execute(new Runnable() {
-            @Override
-            public void run() {
-                RNFetchBlobFS.createFileASCII(path, dataArray, callback);
-            }
-        });
-
-    }
-
     @ReactMethod
     public void writeArrayChunk(final String streamId, final ReadableArray dataArray, final Callback callback) {
         RNFetchBlobFS.writeArrayChunk(streamId, dataArray, callback);
     }
 
     @ReactMethod
-    public void mkdir(String path, Callback callback) {
-        RNFetchBlobFS.mkdir(path, callback);
+    public void mkdir(String path, Promise promise) {
+        RNFetchBlobFS.mkdir(path, promise);
     }
 
     @ReactMethod
                 RNFetchBlobFS.cp(path, dest, callback);
             }
         });
-
     }
 
     @ReactMethod
     }
 
     @ReactMethod
-    public void ls(String path, Callback callback) {
-        RNFetchBlobFS.ls(path, callback);
+    public void ls(String path, Promise promise) {
+        RNFetchBlobFS.ls(path, promise);
     }
 
     @ReactMethod
                 RNFetchBlobFS.writeFile(path, encoding, data, append, promise);
             }
         });
-
     }
 
     @ReactMethod
                 new RNFetchBlobFS(ctx).scanFile(p, m, callback);
             }
         });
-
     }
 
     @ReactMethod
+    public void hash(final String path, final String algorithm, final Promise promise) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.hash(path, algorithm, promise);
+            }
+        });
+    }
+
     /**
      * @param path Stream file path
      * @param encoding Stream encoding, should be one of `base64`, `ascii`, and `utf8`
      * @param bufferSize Stream buffer size, default to 4096 or 4095(base64).
      */
+    @ReactMethod
     public void readStream(final String path, final String encoding, final int bufferSize, final int tick, final String streamId) {
         final ReactApplicationContext ctx = this.getReactApplicationContext();
         fsThreadPool.execute(new Runnable() {
     @ReactMethod
     public void fetchBlob(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
         new RNFetchBlobReq(options, taskId, method, url, headers, body, null, mClient, callback).run();
-}
+    }
 
     @ReactMethod
     public void fetchBlobForm(ReadableMap options, String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
 
     @ReactMethod
     public void addCompleteDownload (ReadableMap config, Promise promise) {
-        DownloadManager dm = (DownloadManager) RNFetchBlob.RCTContext.getSystemService(RNFetchBlob.RCTContext.DOWNLOAD_SERVICE);
+        DownloadManager dm = (DownloadManager) RCTContext.getSystemService(RCTContext.DOWNLOAD_SERVICE);
         String path = RNFetchBlobFS.normalizePath(config.getString("path"));
         if(path == null) {
-            promise.reject("RNFetchblob.addCompleteDownload can not resolve URI:" + config.getString("path"), "RNFetchblob.addCompleteDownload can not resolve URI:" + path);
+            promise.reject("EINVAL", "RNFetchblob.addCompleteDownload can not resolve URI:" + config.getString("path"));
             return;
         }
         try {
             promise.resolve(null);
         }
         catch(Exception ex) {
-            promise.reject("RNFetchblob.addCompleteDownload failed", ex.getStackTrace().toString());
+            promise.reject("EUNSPECIFIED", ex.getLocalizedMessage());
         }
 
     }
 
-}
+    @ReactMethod
+    public void getSDCardDir(Promise promise) {
+        RNFetchBlobFS.getSDCardDir(promise);
+    }
+
+    @ReactMethod
+    public void getSDCardApplicationDir(Promise promise) {
+        RNFetchBlobFS.getSDCardApplicationDir(this.getReactApplicationContext(), promise);
+    }
+}

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

 package com.RNFetchBlob;
 
+import android.support.annotation.NonNull;
 import android.util.Base64;
 
 import com.facebook.react.bridge.Arguments;
 import java.io.InputStream;
 import java.util.ArrayList;
 
+import android.net.Uri;
 import okhttp3.MediaType;
 import okhttp3.RequestBody;
 import okio.BufferedSink;
 
-public class RNFetchBlobBody extends RequestBody{
+class RNFetchBlobBody extends RequestBody{
 
-    InputStream requestStream;
-    long contentLength = 0;
-    ReadableArray form;
-    String mTaskId;
-    String rawBody;
-    RNFetchBlobReq.RequestType requestType;
-    MediaType mime;
-    File bodyCache;
+    private InputStream requestStream;
+    private long contentLength = 0;
+    private ReadableArray form;
+    private String mTaskId;
+    private String rawBody;
+    private RNFetchBlobReq.RequestType requestType;
+    private MediaType mime;
+    private File bodyCache;
     int reported = 0;
-    Boolean chunkedEncoding = false;
+    private Boolean chunkedEncoding = false;
 
-
-    public RNFetchBlobBody(String taskId) {
+    RNFetchBlobBody(String taskId) {
         this.mTaskId = taskId;
     }
 
         return this;
     }
 
-    RNFetchBlobBody setRequestType( RNFetchBlobReq.RequestType type) {
+    RNFetchBlobBody setRequestType(RNFetchBlobReq.RequestType type) {
         this.requestType = type;
         return this;
     }
         try {
             switch (requestType) {
                 case SingleFile:
-                    requestStream = getReuqestStream();
+                    requestStream = getRequestStream();
                     contentLength = requestStream.available();
                     break;
                 case AsIs:
     }
 
     @Override
-    public void writeTo(BufferedSink sink) {
+    public void writeTo(@NonNull BufferedSink sink) {
         try {
             pipeStreamToSink(requestStream, sink);
         } catch(Exception ex) {
         return true;
     }
 
-    private InputStream getReuqestStream() throws Exception {
+    private InputStream getRequestStream() throws Exception {
 
         // upload from storage
         if (rawBody.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
                     throw new Exception("error when getting request stream: " +e.getLocalizedMessage());
                 }
             }
+        } else if (rawBody.startsWith(RNFetchBlobConst.CONTENT_PREFIX)) {
+            String contentURI = rawBody.substring(RNFetchBlobConst.CONTENT_PREFIX.length());
+            try {
+                return RNFetchBlob.RCTContext.getContentResolver().openInputStream(Uri.parse(contentURI));
+            } catch (Exception e) {
+                throw new Exception("error when getting request stream for content URI: " + contentURI, e);
+            }
         }
         // base 64 encoded
         else {
         ArrayList<FormField> fields = countFormDataLength();
         ReactApplicationContext ctx = RNFetchBlob.RCTContext;
 
-        for(int i = 0;i < fields.size(); i++) {
-            FormField field = fields.get(i);
+        for(FormField field : fields) {
             String data = field.data;
             String name = field.name;
             // skip invalid fields
                             RNFetchBlobUtils.emitWarningEvent("Failed to create form data from path :" + orgPath + ", file not exists.");
                         }
                     }
+                } else if (data.startsWith(RNFetchBlobConst.CONTENT_PREFIX)) {
+                    String contentURI = data.substring(RNFetchBlobConst.CONTENT_PREFIX.length());
+                    InputStream is = null;
+                    try {
+                        is = ctx.getContentResolver().openInputStream(Uri.parse(contentURI));
+                        pipeStreamToFileStream(is, os);
+                    } catch(Exception e) {
+                        RNFetchBlobUtils.emitWarningEvent(
+                                "Failed to create form data from content URI:" + contentURI + ", " + e.getLocalizedMessage());
+                    } finally {
+                        if (is != null) {
+                            is.close();
+                        }
+                    }
                 }
                 // base64 embedded file content
                 else {
      * @param sink      The request body buffer sink
      * @throws IOException
      */
-    private void pipeStreamToSink(InputStream stream, BufferedSink sink) throws Exception {
-
-        byte [] chunk = new byte[10240];
+    private void pipeStreamToSink(InputStream stream, BufferedSink sink) throws IOException {
+        byte[] chunk = new byte[10240];
         int totalWritten = 0;
         int read;
         while((read = stream.read(chunk, 0, 10240)) > 0) {
-            if(read > 0) {
-                sink.write(chunk, 0, read);
-                totalWritten += read;
-                emitUploadProgress(totalWritten);
-            }
+            sink.write(chunk, 0, read);
+            totalWritten += read;
+            emitUploadProgress(totalWritten);
         }
         stream.close();
     }
 
     /**
      * Compute approximate content length for form data
-     * @return
+     * @return ArrayList<FormField>
      */
-    private ArrayList<FormField> countFormDataLength() {
+    private ArrayList<FormField> countFormDataLength() throws IOException {
         long total = 0;
         ArrayList<FormField> list = new ArrayList<>();
         ReactApplicationContext ctx = RNFetchBlob.RCTContext;
         for(int i = 0;i < form.size(); i++) {
             FormField field = new FormField(form.getMap(i));
             list.add(field);
-            String data = field.data;
-            if(data == null) {
+            if(field.data == null) {
                 RNFetchBlobUtils.emitWarningEvent("RNFetchBlob multipart request builder has found a field without `data` property, the field `"+ field.name +"` will be removed implicitly.");
             }
             else if (field.filename != null) {
+                String data = field.data;
                 // upload from storage
                 if (data.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
                     String orgPath = data.substring(RNFetchBlobConst.FILE_PREFIX.length());
                         File file = new File(RNFetchBlobFS.normalizePath(orgPath));
                         total += file.length();
                     }
+                } else if (data.startsWith(RNFetchBlobConst.CONTENT_PREFIX)) {
+                    String contentURI = data.substring(RNFetchBlobConst.CONTENT_PREFIX.length());
+                    InputStream is = null;
+                    try {
+                        is = ctx.getContentResolver().openInputStream(Uri.parse(contentURI));
+                        long length = is.available();
+                        total += length;
+                    } catch(Exception e) {
+                        RNFetchBlobUtils.emitWarningEvent(
+                                "Failed to estimate form data length from content URI:" + contentURI + ", " + e.getLocalizedMessage());
+                    } finally {
+                        if (is != null) {
+                            is.close();
+                        }
+                    }
                 }
                 // base64 embedded file content
                 else {
             }
             // data field
             else {
-                total += field.data != null ? field.data.getBytes().length : 0;
+                total += field.data.getBytes().length;
             }
         }
         contentLength = total;
      */
     private class FormField {
         public String name;
-        public String filename;
-        public String mime;
+        String filename;
+        String mime;
         public String data;
 
-        public FormField(ReadableMap rawData) {
+        FormField(ReadableMap rawData) {
             if(rawData.hasKey("name"))
                 name = rawData.getString("name");
             if(rawData.hasKey("filename"))
 
     /**
      * Emit progress event
-     * @param written
+     * @param written  Integer
      */
     private void emitUploadProgress(int written) {
         RNFetchBlobProgressConfig config = RNFetchBlobReq.getReportUploadProgress(mTaskId);

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

 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 
-import java.util.HashMap;
-
-
-public class RNFetchBlobConfig {
+class RNFetchBlobConfig {
 
     public Boolean fileCache;
     public String path;

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

     public static final String EVENT_HTTP_STATE = "RNFetchBlobState";
     public static final String EVENT_MESSAGE = "RNFetchBlobMessage";
     public static final String FILE_PREFIX = "RNFetchBlob-file://";
+    public static final String CONTENT_PREFIX = "RNFetchBlob-content://";
     public static final String FILE_PREFIX_BUNDLE_ASSET = "bundle-assets://";
     public static final String FILE_PREFIX_CONTENT = "content://";
     public static final String DATA_ENCODE_URI = "uri";

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

  */
 public class RNFetchBlobProgressConfig {
 
-    public enum ReportType {
+    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;
+    private long lastTick = 0;
+    private int tick = 0;
+    private int count = -1;
+    private int interval = -1;
+    private boolean enable = false;
+    private ReportType type = ReportType.Download;
 
     RNFetchBlobProgressConfig(boolean report, int interval, int count, ReportType type) {
         this.enable = report;

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

 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Build;
+import android.support.annotation.NonNull;
 import android.util.Base64;
 
 import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.facebook.react.modules.network.OkHttpClientProvider;
-import com.facebook.react.modules.network.TLSSocketFactory;
+
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+import javax.net.ssl.SSLContext;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
+import java.security.KeyStore;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.HashMap;
 
 import java.util.concurrent.TimeUnit;
 
+import 	javax.net.ssl.SSLSocketFactory;
+
 import okhttp3.Call;
 import okhttp3.ConnectionPool;
 import okhttp3.ConnectionSpec;
     }
 
     public static HashMap<String, Call> taskTable = new HashMap<>();
+    public static HashMap<String, Long> androidDownloadManagerTaskTable = new HashMap<>();
     static HashMap<String, RNFetchBlobProgressConfig> progressReport = new HashMap<>();
     static HashMap<String, RNFetchBlobProgressConfig> uploadProgressReport = new HashMap<>();
     static ConnectionPool pool = new ConnectionPool();
 
-    ReactApplicationContext ctx;
     RNFetchBlobConfig options;
     String taskId;
     String method;
             call.cancel();
             taskTable.remove(taskId);
         }
+
+        if (androidDownloadManagerTaskTable.containsKey(taskId)) {
+            long downloadManagerIdForTaskId = androidDownloadManagerTaskTable.get(taskId).longValue();
+            Context appCtx = RNFetchBlob.RCTContext.getApplicationContext();
+            DownloadManager dm = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
+            dm.remove(downloadManagerIdForTaskId);
+        }
     }
 
     @Override
                 }
                 // set headers
                 ReadableMapKeySetIterator it = headers.keySetIterator();
-                if(options.addAndroidDownloads.hasKey("mediaScannable") && options.addAndroidDownloads.hasKey("mediaScannable") == true ) {
+                if(options.addAndroidDownloads.hasKey("mediaScannable") && options.addAndroidDownloads.hasKey("mediaScannable")) {
                     req.allowScanningByMediaScanner();
                 }
                 while (it.hasNextKey()) {
                 Context appCtx = RNFetchBlob.RCTContext.getApplicationContext();
                 DownloadManager dm = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
                 downloadManagerId = dm.enqueue(req);
+                androidDownloadManagerTaskTable.put(taskId, Long.valueOf(downloadManagerId));
                 appCtx.registerReceiver(this, new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE));
                 return;
             }
                 cacheKey = this.taskId;
             }
 
-            File file = new File(RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext);
+            File file = new File(RNFetchBlobFS.getTmpPath(cacheKey) + ext);
 
             if (file.exists()) {
                 callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, file.getAbsolutePath());
         if(this.options.path != null)
             this.destPath = this.options.path;
         else if(this.options.fileCache)
-            this.destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext;
+            this.destPath = RNFetchBlobFS.getTmpPath(cacheKey) + ext;
 
 
         OkHttpClient.Builder clientBuilder;
                     requestType = RequestType.SingleFile;
                 }
                 if(rawRequestBody != null) {
-                    if(rawRequestBody.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
+                    if (rawRequestBody.startsWith(RNFetchBlobConst.FILE_PREFIX)
+                            || rawRequestBody.startsWith(RNFetchBlobConst.CONTENT_PREFIX)) {
                         requestType = RequestType.SingleFile;
                     }
                     else if (cType.toLowerCase().contains(";base64") || cType.toLowerCase().startsWith("application/octet")) {
             // Add request interceptor for upload progress event
             clientBuilder.addInterceptor(new Interceptor() {
                 @Override
-                public Response intercept(Chain chain) throws IOException {
+                public Response intercept(@NonNull Chain chain) throws IOException {
                     try {
                         Response originalResponse = chain.proceed(req);
                         ResponseBody extended;
             call.enqueue(new okhttp3.Callback() {
 
                 @Override
-                public void onFailure(Call call, IOException e) {
+                public void onFailure(@NonNull Call call, IOException e) {
                     cancelTask(taskId);
                     if(respInfo == null) {
                         respInfo = Arguments.createMap();
                 }
 
                 @Override
-                public void onResponse(Call call, Response response) throws IOException {
+                public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
                     ReadableMap notifyConfig = options.addAndroidDownloads;
                     // Download manager settings
                     if(notifyConfig != null ) {
     private void releaseTaskResource() {
         if(taskTable.containsKey(taskId))
             taskTable.remove(taskId);
+        if(androidDownloadManagerTaskTable.containsKey(taskId))
+            androidDownloadManagerTaskTable.remove(taskId);
         if(uploadProgressReport.containsKey(taskId))
             uploadProgressReport.remove(taskId);
         if(progressReport.containsKey(taskId))
                     // For XMLHttpRequest, automatic response data storing strategy, when response
                     // data is considered as binary data, write it to file system
                     if(isBlobResp && options.auto) {
-                        String dest = RNFetchBlobFS.getTmpPath(ctx, taskId);
+                        String dest = RNFetchBlobFS.getTmpPath(taskId);
                         InputStream ins = resp.body().byteStream();
                         FileOutputStream os = new FileOutputStream(new File(dest));
                         int read;
-                        byte [] buffer = new byte[10240];
+                        byte[] buffer = new byte[10240];
                         while ((read = ins.read(buffer)) != -1) {
                             os.write(buffer, 0, read);
                         }
             Context appCtx = RNFetchBlob.RCTContext.getApplicationContext();
             long id = intent.getExtras().getLong(DownloadManager.EXTRA_DOWNLOAD_ID);
             if (id == this.downloadManagerId) {
+                releaseTaskResource(); // remove task ID from task map
+
                 DownloadManager.Query query = new DownloadManager.Query();
                 query.setFilterById(downloadManagerId);
                 DownloadManager dm = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
                     // #297 handle failed request
                     int statusCode = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_STATUS));
                     if(statusCode == DownloadManager.STATUS_FAILED) {
-                        this.callback.invoke("Download manager failed to download from  " + this.url + ". Statu Code = " + statusCode, null, null);
+                        this.callback.invoke("Download manager failed to download from  " + this.url + ". Status Code = " + statusCode, null, null);
                         return;
                     }
                     String contentUri = c.getString(c.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
                             options.addAndroidDownloads.getString("mime").contains("image")) {
                         Uri uri = Uri.parse(contentUri);
                         Cursor cursor = appCtx.getContentResolver().query(uri, new String[]{android.provider.MediaStore.Images.ImageColumns.DATA}, null, null, null);
-
-                            // use default destination of DownloadManager
+                        // use default destination of DownloadManager
                         if (cursor != null) {
                             cursor.moveToFirst();
                             filePath = cursor.getString(0);
+                            cursor.close();
                         }
                     }
                 }
     public static OkHttpClient.Builder enableTls12OnPreLollipop(OkHttpClient.Builder client) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN && Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
             try {
-                client.sslSocketFactory(new TLSSocketFactory());
+                // Code from https://stackoverflow.com/a/40874952/544779
+                TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+                trustManagerFactory.init((KeyStore) null);
+                TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
+                if (trustManagers.length != 1 || !(trustManagers[0] instanceof X509TrustManager)) {
+                    throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers));
+                }
+                X509TrustManager trustManager = (X509TrustManager) trustManagers[0];
+                SSLContext sslContext = SSLContext.getInstance("SSL");
+                sslContext.init(null, new TrustManager[] { trustManager }, null);
+                SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
+
+                client.sslSocketFactory(sslSocketFactory, trustManager);
 
                 ConnectionSpec cs = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
                         .tlsVersions(TlsVersion.TLS_1_2)

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

             md.update(input.getBytes());
             byte[] digest = md.digest();
 
-            StringBuffer sb = new StringBuffer();
+            StringBuilder sb = new StringBuilder();
 
             for (byte b : digest) {
                 sb.append(String.format("%02x", b & 0xff));
         } catch (Exception ex) {
             ex.printStackTrace();
         } finally {
+            // TODO: Is discarding errors the intent? (https://www.owasp.org/index.php/Return_Inside_Finally_Block)
             return result;
         }
 

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

 package com.RNFetchBlob.Response;
 
+import android.support.annotation.NonNull;
 import android.util.Log;
 
 import com.RNFetchBlob.RNFetchBlobConst;
             File f = new File(path);
 
             File parent = f.getParentFile();
-            if(!parent.exists() && !parent.mkdirs()){
+            if(parent != null && !parent.exists() && !parent.mkdirs()){
                 throw new IllegalStateException("Couldn't create dir: " + parent);
             }
 
-            if(f.exists() == false)
+            if(!f.exists())
                 f.createNewFile();
             ofStream = new FileOutputStream(new File(path), appendToExistingFile);
         }
 
     private class ProgressReportingSource implements Source {
         @Override
-        public long read(Buffer sink, long byteCount) throws IOException {
+        public long read(@NonNull Buffer sink, long byteCount) throws IOException {
             try {
                 byte[] bytes = new byte[(int) byteCount];
                 long read = originalBody.byteStream().read(bytes, 0, (int) byteCount);

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

 package com.RNFetchBlob.Utils;
 
+import android.annotation.TargetApi;
 import android.content.Context;
 import android.database.Cursor;
 import android.net.Uri;
 import java.io.FileOutputStream;
 
 public class PathResolver {
+    @TargetApi(19)
     public static String getRealPathFromURI(final Context context, final Uri uri) {
 
         final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;

android/src/main/res/xml/provider_paths.xml

+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <external-path
+        name="external_files"
+        path="." />
+    <files-path
+        name="files-path"
+        path="." /> <!-- Used to access into application data files -->
+</paths>

class/RNFetchBlobReadStream.js

 
     // register for file stream event
     let subscription = emitter.addListener(this.streamId, (e) => {
-      let {event, detail} = e
+      let {event, code, detail} = e
       if(this._onData && event === 'data') {
         this._onData(detail)
         return
         this._onEnd(detail)
       }
       else {
+        const err = new Error(detail)
+        err.code = code || 'EUNSPECIFIED'
         if(this._onError)
-          this._onError(detail)
+          this._onError(err)
         else
-          throw new Error(detail)
+          throw err
       }
       // when stream closed or error, remove event handler
       if (event === 'error' || event === 'end') {

class/RNFetchBlobSession.js

 } from 'react-native'
 
 const RNFetchBlob = NativeModules.RNFetchBlob
-const emitter = DeviceEventEmitter
 
 let sessions = {}
 
 export default class RNFetchBlobSession {
 
-  add : (path:string) => RNFetchBlobSession;
-  remove : (path:string) => RNFetchBlobSession;
-  dispose : () => Promise;
-  list : () => Array<string>;
   name : string;
 
   static getSession(name:string):any {
 
   remove(path:string):RNFetchBlobSession {
     let list = sessions[this.name]
-    for(let i in list) {
+    for(let i of list) {
       if(list[i] === path) {
         sessions[this.name].splice(i, 1)
         break;
     return new Promise((resolve, reject) => {
       RNFetchBlob.removeSession(sessions[this.name], (err) => {
         if(err)
-          reject(err)
+          reject(new Error(err))
         else {
           delete sessions[this.name]
           resolve()

class/RNFetchBlobWriteStream.js

 } from 'react-native'
 
 const RNFetchBlob = NativeModules.RNFetchBlob
-const emitter = DeviceEventEmitter
 
 export default class RNFetchBlobWriteStream {
 
   id : string;
   encoding : string;
-  append : bool;
+  append : boolean;
 
-  constructor(streamId:string, encoding:string, append:string) {
+  constructor(streamId:string, encoding:string, append:boolean) {
     this.id = streamId
     this.encoding = encoding
     this.append = append
   }
 
-  write(data:string) {
+  write(data:string): Promise<RNFetchBlobWriteStream> {
     return new Promise((resolve, reject) => {
       try {
         let method = this.encoding === 'ascii' ? 'writeArrayChunk' : 'writeChunk'
         if(this.encoding.toLocaleLowerCase() === 'ascii' && !Array.isArray(data)) {
-            reject('ascii input data must be an Array')
+            reject(new Error('ascii input data must be an Array'))
             return
         }
         RNFetchBlob[method](this.id, data, (error) => {
           if(error)
-            reject(error)
+            reject(new Error(error))
           else
-            resolve()
+            resolve(this)
         })
       } catch(err) {
-        reject(err)
+        reject(new Error(err))
       }
     })
   }
           resolve()
         })
       } catch (err) {
-        reject(err)
+        reject(new Error(err))
       }
     })
   }

fs.js

 // Use of this source code is governed by a MIT-style license that can be
 // found in the LICENSE file.
 
-import {
-  NativeModules,
-  DeviceEventEmitter,
-  Platform,
-  NativeAppEventEmitter,
-} from 'react-native'
+// import type {RNFetchBlobConfig, RNFetchBlobNative, RNFetchBlobStream} from './types'
+
+import {NativeModules, Platform} from 'react-native'
 import RNFetchBlobSession from './class/RNFetchBlobSession'
 import RNFetchBlobWriteStream from './class/RNFetchBlobWriteStream'
 import RNFetchBlobReadStream from './class/RNFetchBlobReadStream'
 import RNFetchBlobFile from './class/RNFetchBlobFile'
-import type {
-  RNFetchBlobNative,
-  RNFetchBlobConfig,
-  RNFetchBlobStream
-} from './types'
-
-const RNFetchBlob:RNFetchBlobNative = NativeModules.RNFetchBlob
-const emitter = DeviceEventEmitter
+
+const RNFetchBlob: RNFetchBlobNative = NativeModules.RNFetchBlob
+
 const dirs = {
-    DocumentDir :  RNFetchBlob.DocumentDir,
-    CacheDir : RNFetchBlob.CacheDir,
-    PictureDir : RNFetchBlob.PictureDir,
-    MusicDir : RNFetchBlob.MusicDir,
-    MovieDir : RNFetchBlob.MovieDir,
-    DownloadDir : RNFetchBlob.DownloadDir,
-    DCIMDir : RNFetchBlob.DCIMDir,
-    SDCardDir : RNFetchBlob.SDCardDir,
-    SDCardApplicationDir : RNFetchBlob.SDCardApplicationDir,
-    MainBundleDir : RNFetchBlob.MainBundleDir,
-    LibraryDir : RNFetchBlob.LibraryDir
+  DocumentDir :  RNFetchBlob.DocumentDir,
+  CacheDir : RNFetchBlob.CacheDir,
+  PictureDir : RNFetchBlob.PictureDir,
+  MusicDir : RNFetchBlob.MusicDir,
+  MovieDir : RNFetchBlob.MovieDir,
+  DownloadDir : RNFetchBlob.DownloadDir,
+  DCIMDir : RNFetchBlob.DCIMDir,
+  SDCardDir: RNFetchBlob.SDCardDir, // Depracated
+  SDCardApplicationDir: RNFetchBlob.SDCardApplicationDir, // Deprecated
+  MainBundleDir : RNFetchBlob.MainBundleDir,
+  LibraryDir : RNFetchBlob.LibraryDir
+}
+
+function addCode(code: string, error: Error): Error {
+  error.code = code
+  return error
 }
 
 /**
  * @param  {string} name Stream ID
  * @return {RNFetchBlobSession}
  */
-function session(name:string):RNFetchBlobSession {
+function session(name: string): RNFetchBlobSession {
   let s = RNFetchBlobSession.getSession(name)
-  if(s)
+  if (s)
     return new RNFetchBlobSession(name)
   else {
     RNFetchBlobSession.setSession(name, [])
   }
 }
 
-function asset(path:string):string {
-  if(Platform.OS === 'ios') {
+function asset(path: string): string {
+  if (Platform.OS === 'ios') {
     // path from camera roll
-    if(/^assets-library\:\/\//.test(path))
+    if (/^assets-library\:\/\//.test(path))
       return path
   }
   return 'bundle-assets://' + path
 }
 
-function createFile(path:string, data:string, encoding: 'base64' | 'ascii' | 'utf8'):Promise {
-  encoding = encoding || 'utf8'
-  return new Promise((resolve, reject) => {
-    let handler = (err) => {
-      if(err)
-        reject(new Error(err))
-      else
-        resolve()
-    }
-    if(encoding.toLowerCase() === 'ascii') {
-      if(Array.isArray(data))
-        RNFetchBlob.createFileASCII(path, data, handler)
-      else
-        reject(new Error('`data` of ASCII file must be an array contains numbers'))
-    }
-    else {
-      RNFetchBlob.createFile(path, data, encoding, handler)
-    }
-  })
+function createFile(path: string, data: string, encoding: 'base64' | 'ascii' | 'utf8' = 'utf8'): Promise<string> {
+  if (encoding.toLowerCase() === 'ascii') {
+    return Array.isArray(data) ?
+      RNFetchBlob.createFileASCII(path, data) :
+      Promise.reject(addCode('EINVAL', new TypeError('`data` of ASCII file must be an array with 0..255 numbers')))
+  }
+  else {
+    return RNFetchBlob.createFile(path, data, encoding)
+  }
 }
 
 /**
  * Create write stream to a file.
  * @param  {string} path Target path of file stream.
  * @param  {string} encoding Encoding of input data.
- * @param  {bool} append  A flag represent if data append to existing ones.
- * @return {Promise<WriteStream>} A promise resolves a `WriteStream` object.
+ * @param  {boolean} [append]  A flag represent if data append to existing ones.
+ * @return {Promise<RNFetchBlobWriteStream>} A promise resolves a `WriteStream` object.
  */
 function writeStream(
-  path : string,
-  encoding : 'utf8' | 'ascii' | 'base64',
-  append? : ?bool,
-):Promise<RNFetchBlobWriteStream> {
-  if(!path)
-    throw Error('RNFetchBlob could not open file stream with empty `path`')
-  encoding = encoding || 'utf8'
-  append = append || false
+  path: string,
+  encoding?: 'utf8' | 'ascii' | 'base64' = 'utf8',
+  append?: boolean = false,
+): Promise<RNFetchBlobWriteStream> {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
   return new Promise((resolve, reject) => {
-    RNFetchBlob.writeStream(path, encoding || 'base64', append || false, (err, streamId:string) => {
-      if(err)
-        reject(new Error(err))
+    RNFetchBlob.writeStream(path, encoding, append, (errCode, errMsg, streamId: string) => {
+      if (errMsg) {
+        const err = new Error(errMsg)
+        err.code = errCode
+        reject(err)
+      }
       else
         resolve(new RNFetchBlobWriteStream(streamId, encoding))
     })
  * @param  {string} path   The file path.
  * @param  {string} encoding Data encoding, should be one of `base64`, `utf8`, `ascii`
  * @param  {boolean} bufferSize Size of stream buffer.
+ * @param  {number} [tick=10] Interval in milliseconds between reading chunks of data
  * @return {RNFetchBlobStream} RNFetchBlobStream stream instance.
  */
 function readStream(
-  path : string,
-  encoding : 'utf8' | 'ascii' | 'base64',
-  bufferSize? : ?number,
-  tick : ?number = 10
-):Promise<RNFetchBlobReadStream> {
+  path: string,
+  encoding: 'utf8' | 'ascii' | 'base64' = 'utf8',
+  bufferSize?: number,
+  tick?: number = 10
+): Promise<RNFetchBlobReadStream> {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
   return Promise.resolve(new RNFetchBlobReadStream(path, encoding, bufferSize, tick))
 }
 
  * @param  {string} path Path of directory to be created
  * @return {Promise}
  */
-function mkdir(path:string):Promise {
-
-  return new Promise((resolve, reject) => {
-    RNFetchBlob.mkdir(path, (err, res) => {
-      if(err)
-        reject(new Error(err))
-      else
-        resolve()
-    })
-  })
-
+function mkdir(path: string): Promise {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
+  return RNFetchBlob.mkdir(path)
 }
 
 /**
  * @param  {string} groupName Name of app group
  * @return {Promise}
  */
-function pathForAppGroup(groupName:string):Promise {
-  return RNFetchBlob.pathForAppGroup(groupName);
+function pathForAppGroup(groupName: string): Promise {
+  return RNFetchBlob.pathForAppGroup(groupName)
 }
 
 /**
  * @param  {'base64' | 'utf8' | 'ascii'} encoding Encoding of read stream.
  * @return {Promise<Array<number> | string>}
  */
-function readFile(path:string, encoding:string, bufferSize:?number):Promise<any> {
-  if(typeof path !== 'string')
-    return Promise.reject(new Error('Invalid argument "path" '))
+function readFile(path: string, encoding: string = 'utf8'): Promise<any> {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
   return RNFetchBlob.readFile(path, encoding)
 }
 
  * @param  {string} encoding Encoding of data (Optional).
  * @return {Promise}
  */
-function writeFile(path:string, data:string | Array<number>, encoding:?string):Promise {
-  encoding = encoding || 'utf8'
-  if(typeof path !== 'string')
-    return Promise.reject('Invalid argument "path" ')
-  if(encoding.toLocaleLowerCase() === 'ascii') {
-    if(!Array.isArray(data))
-      return Promise.reject(new Error(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`))
+function writeFile(path: string, data: string | Array<number>, encoding: ?string = 'utf8'): Promise {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
+  if (encoding.toLocaleLowerCase() === 'ascii') {
+    if (!Array.isArray(data)) {
+      return Promise.reject(addCode('EINVAL', new TypeError('"data" must be an Array when encoding is "ascii"')))
+    }
     else
-      return RNFetchBlob.writeFileArray(path, data, false);
-  } else {
-    if(typeof data !== 'string')
-      return Promise.reject(new Error(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`))
+      return RNFetchBlob.writeFileArray(path, data, false)
+  }
+  else {
+    if (typeof data !== 'string') {
+      return Promise.reject(addCode('EINVAL', new TypeError(`"data" must be a String when encoding is "utf8" or "base64", but it is "${typeof data}"`)))
+    }
     else
-      return RNFetchBlob.writeFile(path, encoding, data, false);
+      return RNFetchBlob.writeFile(path, encoding, data, false)
   }
 }
 
-function appendFile(path:string, data:string | Array<number>, encoding:?string):Promise {
-  encoding = encoding || 'utf8'
-  if(typeof path !== 'string')
-    return Promise.reject('Invalid argument "path" ')
-  if(encoding.toLocaleLowerCase() === 'ascii') {
-    if(!Array.isArray(data))
-      return Promise.reject(new Error(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`))
+function appendFile(path: string, data: string | Array<number>, encoding?: string = 'utf8'): Promise<number> {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
+  if (encoding.toLocaleLowerCase() === 'ascii') {
+    if (!Array.isArray(data)) {
+      return Promise.reject(addCode('EINVAL', new TypeError('`data` of ASCII file must be an array with 0..255 numbers')))
+    }
     else
-      return RNFetchBlob.writeFileArray(path, data, true);
-  } else {
-    if(typeof data !== 'string')
-      return Promise.reject(new Error(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`))
+      return RNFetchBlob.writeFileArray(path, data, true)
+  }
+  else {
+    if (typeof data !== 'string') {
+      return Promise.reject(addCode('EINVAL'), new TypeError(`"data" must be a String when encoding is "utf8" or "base64", but it is "${typeof data}"`))
+    }
     else
-      return RNFetchBlob.writeFile(path, encoding, data, true);
+      return RNFetchBlob.writeFile(path, encoding, data, true)
   }
 }
 
  * @param  {string} path Target path
  * @return {RNFetchBlobFile}
  */
-function stat(path:string):Promise<RNFetchBlobFile> {
+function stat(path: string): Promise<RNFetchBlobFile> {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
     RNFetchBlob.stat(path, (err, stat) => {
-      if(err)
+      if (err)
         reject(new Error(err))
       else {
-        if(stat) {
+        if (stat) {
           stat.size = parseInt(stat.size)
           stat.lastModified = parseInt(stat.lastModified)
         }
 
 /**
  * Android only method, request media scanner to scan the file.
- * @param  {Array<Object<string, string>>} Array contains Key value pairs with key `path` and `mime`.
+ * @param  {Array<Object<string, string>>} pairs Array contains Key value pairs with key `path` and `mime`.
  * @return {Promise}
  */
-function scanFile(pairs:any):Promise {
+function scanFile(pairs: any): Promise {
   return new Promise((resolve, reject) => {
+    if (pairs === undefined) {
+      return reject(addCode('EINVAL', new TypeError('Missing argument')))
+    }
     RNFetchBlob.scanFile(pairs, (err) => {
-      if(err)
-        reject(new Error(err))
+      if (err)
+        reject(addCode('EUNSPECIFIED', new Error(err)))
       else
         resolve()
     })
   })
 }
 
-function cp(path:string, dest:string):Promise<boolean> {
+function hash(path: string, algorithm: string): Promise<string> {
+  if (typeof path !== 'string' || typeof algorithm !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" and/or "algorithm"')))
+  }
+  return RNFetchBlob.hash(path, algorithm)
+}
+
+function cp(path: string, dest: string): Promise<boolean> {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string' || typeof dest !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" and/or "destination"')))
+    }
     RNFetchBlob.cp(path, dest, (err, res) => {
-      if(err)
-        reject(new Error(err))
+      if (err)
+        reject(addCode('EUNSPECIFIED', new Error(err)))
       else
         resolve(res)
     })
   })
 }
 
-function mv(path:string, dest:string):Promise<boolean> {
+function mv(path: string, dest: string): Promise<boolean> {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string' || typeof dest !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" and/or "destination"')))
+    }
     RNFetchBlob.mv(path, dest, (err, res) => {
-      if(err)
-        reject(new Error(err))
+      if (err)
+        reject(addCode('EUNSPECIFIED', new Error(err)))
       else
         resolve(res)
     })
   })
 }
 
-function lstat(path:string):Promise<Array<RNFetchBlobFile>> {
+function lstat(path: string): Promise<Array<RNFetchBlobFile>> {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
     RNFetchBlob.lstat(path, (err, stat) => {
-      if(err)
-        reject(new Error(err))
+      if (err)
+        reject(addCode('EUNSPECIFIED', new Error(err)))
       else
         resolve(stat)
     })
   })
 }
 
-function ls(path:string):Promise<Array<String>> {
-  return new Promise((resolve, reject) => {
-    RNFetchBlob.ls(path, (err, res) => {
-      if(err)
-        reject(new Error(err))
-      else
-        resolve(res)
-    })
-  })
+function ls(path: string): Promise<Array<String>> {
+  if (typeof path !== 'string') {
+    return Promise.reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+  }
+  return RNFetchBlob.ls(path)
 }
 
 /**
  * @param  {string}   path:string Path of target file.
  * @return {Promise}
  */
-function unlink(path:string):Promise {
+function unlink(path: string): Promise {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
     RNFetchBlob.unlink(path, (err) => {
-      if(err) {
-        reject(new Error(err))
+      if (err) {
+        reject(addCode('EUNSPECIFIED', new Error(err)))
       }
       else
         resolve()
 /**
  * Check if file exists and if it is a folder.
  * @param  {string} path Path to check
- * @return {Promise<bool, bool>}
+ * @return {Promise<boolean>}
  */
-function exists(path:string):Promise<bool, bool> {
-
+function exists(path: string): Promise<boolean> {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
     try {
       RNFetchBlob.exists(path, (exist) => {
         resolve(exist)
       })
-    } catch(err) {
-      reject(new Error(err))
+    }catch (err){
+      reject(addCode('EUNSPECIFIED', new Error(err)))
     }
   })
 
 }
 
-function slice(src:string, dest:string, start:number, end:number):Promise {
+function slice(src: string, dest: string, start: number, end: number): Promise {
+  if (typeof src !== 'string' || typeof dest !== 'string') {
+    return reject(addCode('EINVAL', new TypeError('Missing argument "src" and/or "destination"')))
+  }
+
   let p = Promise.resolve()
   let size = 0
+
   function normalize(num, size) {
-    if(num < 0)
+    if (num < 0)
       return Math.max(0, size + num)
-    if(!num && num !== 0)
+    if (!num && num !== 0)
       return size
     return num
   }
-  if(start < 0 || end < 0 || !start || !end) {
+
+  if (start < 0 || end < 0 || !start || !end) {
     p = p.then(() => stat(src))
-         .then((stat) => {
-           size = Math.floor(stat.size)
-           start = normalize(start || 0, size)
-           end = normalize(end, size)
-           return Promise.resolve()
-         })
+      .then((stat) => {
+        size = Math.floor(stat.size)
+        start = normalize(start || 0, size)
+        end = normalize(end, size)
+      })
   }
   return p.then(() => RNFetchBlob.slice(src, dest, start, end))
 }
 
-function isDir(path:string):Promise<bool, bool> {
-
+function isDir(path: string): Promise<bool> {
   return new Promise((resolve, reject) => {
+    if (typeof path !== 'string') {
+      return reject(addCode('EINVAL', new TypeError('Missing argument "path" ')))
+    }
     try {
       RNFetchBlob.exists(path, (exist, isDir) => {
         resolve(isDir)
       })
-    } catch(err) {
-      reject(new Error(err))
+    }catch (err){
+      reject(addCode('EUNSPECIFIED', new Error(err)))
     }
   })
 
 }
 
-function df():Promise<{ free : number, total : number }> {
+function df(): Promise<{ free: number, total: number }> {
   return new Promise((resolve, reject) => {
     RNFetchBlob.df((err, stat) => {
-      if(err)
-        reject(err)
+      if (err)
+        reject(addCode('EUNSPECIFIED', new Error(err)))
       else
         resolve(stat)
     })
   appendFile,
   pathForAppGroup,
   readFile,
+  hash,
   exists,
   createFile,
   isDir,

index.js

   RNFetchBlobResponseInfo
 } from './types'
 import URIUtil from './utils/uri'
-import StatefulPromise from './class/StatefulPromise.js'
+//import StatefulPromise from './class/StatefulPromise.js'
 import fs from './fs'
 import getUUID from './utils/uuid'
 import base64 from 'base-64'
 }
 
 function wrap(path:string):string {
-  return 'RNFetchBlob-file://' + path
+  const prefix = path.startsWith('content://') ? 'RNFetchBlob-content://' : 'RNFetchBlob-file://'
+  return prefix + path
 }
 
 /**
  * @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.
+ * @param  {any}    body       Data to put or post to file systen.
  * @return {Promise}
  */
 function fetchFile(options = {}, method, url, headers = {}, body):Promise {
     }
     /**
      * Start read stream from cached file
-     * @param  {String} encoding Encode type, should be one of `base64`, `ascrii`, `utf8`.
-     * @param  {Function} fn On data event handler
+     * @param  {String} encoding Encode type, should be one of `base64`, `ascii`, `utf8`.
      * @return {void}
      */
-    this.readStream = (encode: 'base64' | 'utf8' | 'ascii'):RNFetchBlobStream | null => {
+    this.readStream = (encoding: 'base64' | 'utf8' | 'ascii'):RNFetchBlobStream | null => {
       if(this.type === 'path') {
-        return readStream(this.data, encode)
+        return readStream(this.data, encoding)
       }
       else {
         console.warn('RNFetchblob', 'this response data does not contains any available stream')
      * @param  {String} encoding Encode type, should be one of `base64`, `ascrii`, `utf8`.
      * @return {String}
      */
-    this.readFile = (encode: 'base64' | 'utf8' | 'ascii') => {
+    this.readFile = (encoding: 'base64' | 'utf8' | 'ascii') => {
       if(this.type === 'path') {
-        encode = encode || 'utf8'
-        return readFile(this.data, encode)
+        return readFile(this.data, encoding)
       }
       else {
         console.warn('RNFetchblob', 'this response does not contains a readable file')

ios.js

 
 /**
  * Open a file using UIDocumentInteractionController
- * @param  {string]} path Path of the file to be open.
+ * @param  {string} path Path of the file to be open.
  * @param  {string} scheme URI scheme that needs to support, optional
  * @return {Promise}
  */
 
 /**
  * Preview a file using UIDocumentInteractionController
- * @param  {string]} path Path of the file to be open.
+ * @param  {string} path Path of the file to be open.
  * @param  {string} scheme URI scheme that needs to support, optional
  * @return {Promise}
  */

ios/RNFetchBlob.xcodeproj/project.pbxproj

 	objects = {
 
 /* Begin PBXBuildFile section */
+		8C4801A6200CF71700FED7ED /* RNFetchBlobRequest.m in Sources */ = {isa = PBXBuildFile; fileRef = 8C4801A5200CF71700FED7ED /* RNFetchBlobRequest.m */; };
 		A158F4271D052E49006FFD38 /* RNFetchBlobFS.m in Sources */ = {isa = PBXBuildFile; fileRef = A158F4261D052E49006FFD38 /* RNFetchBlobFS.m */; };
 		A158F42D1D0535BB006FFD38 /* RNFetchBlobConst.m in Sources */ = {isa = PBXBuildFile; fileRef = A158F42C1D0535BB006FFD38 /* RNFetchBlobConst.m */; };
 		A158F4301D0539DB006FFD38 /* RNFetchBlobNetwork.m in Sources */ = {isa = PBXBuildFile; fileRef = A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */; };
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		8C4801A4200CF71700FED7ED /* RNFetchBlobRequest.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFetchBlobRequest.h; sourceTree = "<group>"; };
+		8C4801A5200CF71700FED7ED /* RNFetchBlobRequest.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFetchBlobRequest.m; sourceTree = "<group>"; };
 		A158F4261D052E49006FFD38 /* RNFetchBlobFS.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNFetchBlobFS.m; sourceTree = "<group>"; };
 		A158F4281D052E57006FFD38 /* RNFetchBlobFS.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFetchBlobFS.h; sourceTree = "<group>"; };
 		A158F4291D0534A9006FFD38 /* RNFetchBlobConst.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFetchBlobConst.h; sourceTree = "<group>"; };
 				A1F950181D7E9134002A95A6 /* IOS7Polyfill.h */,
 				A1AAE2981D300E4D0051D11C /* RNFetchBlobReqBuilder.m */,
 				A1AAE2971D300E3E0051D11C /* RNFetchBlobReqBuilder.h */,
-				A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */,
 				A158F42E1D0539CE006FFD38 /* RNFetchBlobNetwork.h */,
+				A158F42F1D0539DB006FFD38 /* RNFetchBlobNetwork.m */,
+				8C4801A4200CF71700FED7ED /* RNFetchBlobRequest.h */,
+				8C4801A5200CF71700FED7ED /* RNFetchBlobRequest.m */,
 				A158F42C1D0535BB006FFD38 /* RNFetchBlobConst.m */,
 				A158F4291D0534A9006FFD38 /* RNFetchBlobConst.h */,
 				A158F4281D052E57006FFD38 /* RNFetchBlobFS.h */,
 			buildActionMask = 2147483647;
 			files = (
 				A166D1AA1CE0647A00273590 /* RNFetchBlob.h in Sources */,
+				8C4801A6200CF71700FED7ED /* RNFetchBlobRequest.m in Sources */,
 				A158F42D1D0535BB006FFD38 /* RNFetchBlobConst.m in Sources */,
 				A158F4271D052E49006FFD38 /* RNFetchBlobFS.m in Sources */,
 				A158F4301D0539DB006FFD38 /* RNFetchBlobNetwork.m in Sources */,

ios/RNFetchBlob/RNFetchBlob.h

 @property (retain) UIDocumentInteractionController * documentController;
 
 + (RCTBridge *)getRCTBridge;
-+ (void) checkExpiredSessions;
 
 @end
 

ios/RNFetchBlob/RNFetchBlob.m

 
 + (RCTBridge *)getRCTBridge
 {
-    RCTRootView * rootView = [[UIApplication sharedApplication] keyWindow].rootViewController.view;
+    RCTRootView * rootView = (RCTRootView*) [[UIApplication sharedApplication] keyWindow].rootViewController.view;
     return rootView.bridge;
 }
 
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
 RCT_EXPORT_MODULE();
 
 - (id) init {
         // send HTTP request
         else
         {
-            RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-            [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+            [[RNFetchBlobNetwork sharedInstance] sendRequest:options
+                                               contentLength:bodyLength
+                                                      bridge:self.bridge
+                                                      taskId:taskId
+                                                 withRequest:req
+                                                    callback:callback];
         }
     }];
 
         // send HTTP request
         else
         {
-            __block RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-            [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+            [[RNFetchBlobNetwork sharedInstance] sendRequest:options
+                                               contentLength:bodyLength
+                                                      bridge:self.bridge
+                                                      taskId:taskId
+                                                 withRequest:req
+                                                    callback:callback];
         }
     }];
 }
 
 #pragma mark - fs.createFile
-RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
-
+RCT_EXPORT_METHOD(createFile:(NSString *)path
+                  data:(NSString *)data
+                  encoding:(NSString *)encoding
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
     NSFileManager * fm = [NSFileManager defaultManager];
     NSData * fileContent = nil;
 
         fileContent = [[NSData alloc] initWithData:[data dataUsingEncoding:NSASCIIStringEncoding allowLossyConversion:YES]];
     }
 
-    BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
-    if(success == YES)
-        callback(@[[NSNull null]]);
-    else
-        callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
-
+    if ([fm fileExistsAtPath:path]) {
+        reject(@"EEXIST", [NSString stringWithFormat:@"File '%@' already exists", path], nil);
+    }
+    else {
+        BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
+        if(success == YES)
+            resolve(@[[NSNull null]]);
+        else
+            reject(@"EUNSPECIFIED", [NSString stringWithFormat:@"Failed to create new file at path '%@', please ensure the folder exists", path], nil);
+    }
 }
 
 #pragma mark - fs.createFileASCII
 // method for create file with ASCII content
-RCT_EXPORT_METHOD(createFileASCII:(NSString *)path data:(NSArray *)dataArray callback:(RCTResponseSenderBlock)callback) {
-
+RCT_EXPORT_METHOD(createFileASCII:(NSString *)path
+                  data:(NSArray *)dataArray
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
     NSFileManager * fm = [NSFileManager defaultManager];
     NSMutableData * fileContent = [NSMutableData alloc];
     // prevent stack overflow, alloc on heap
     for(int i = 0; i < dataArray.count; i++) {
         bytes[i] = [[dataArray objectAtIndex:i] charValue];
     }
+
     [fileContent appendBytes:bytes length:dataArray.count];
-    BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
-    free(bytes);
-    if(success == YES)
-        callback(@[[NSNull null]]);
-    else
-        callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
 
+    if ([fm fileExistsAtPath:path]) {
+        reject(@"EEXIST", [NSString stringWithFormat:@"File '%@' already exists", path], nil);
+    }
+    else {
+        BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
+        if(success == YES)
+            resolve(@[[NSNull null]]);
+        else
+            reject(@"EUNSPECIFIED", [NSString stringWithFormat:@"failed to create new file at path '%@', please ensure the folder exists", path], nil);
+    }
+
+    free(bytes);
 }
 
 #pragma mark - fs.pathForAppGroup
     if(path) {
         resolve(path);
     } else {
-        reject(@"RNFetchBlob file not found", @"could not find path for app group", nil);
+        reject(@"EUNSPECIFIED", @"could not find path for app group", nil);
     }
 }
 
 {
     RNFetchBlobFS * fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     NSFileManager * fm = [NSFileManager defaultManager];
-    BOOL isDir = nil;
-    BOOL exist = [fm fileExistsAtPath:path isDirectory:&isDir];
-    if( exist == NO || isDir == YES) {
-        callback(@[[NSString stringWithFormat:@"target path `%@` may not exists or it's a folder", path]]);
-        return;
+    NSString * folder = [path stringByDeletingLastPathComponent];
+    NSError* err = nil;
+    BOOL isDir = NO;
+    BOOL exists = [fm fileExistsAtPath:path isDirectory: &isDir];
+
+    if(!exists) {
+        [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:&err];
+        if(err != nil) {
+            callback(@[@"ENOTDIR", [NSString stringWithFormat:@"Failed to create parent directory of '%@'; error: %@", path, [err description]]]);
+        }
+        if(![fm createFileAtPath:path contents:nil attributes:nil]) {
+            callback(@[@"ENOENT", [NSString stringWithFormat:@"File '%@' does not exist and could not be created", path]]);
+        }
+    }
+    else if(isDir) {
+        callback(@[@"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path]]);
     }
+
     NSString * streamId = [fileStream openWithPath:path encode:encoding appendData:append];
-    callback(@[[NSNull null], streamId]);
+    callback(@[[NSNull null], [NSNull null], streamId]);
 }
 
 #pragma mark - fs.writeArrayChunk
 }
 
 #pragma mark - fs.ls
-RCT_EXPORT_METHOD(ls:(NSString *)path callback:(RCTResponseSenderBlock) callback)
+RCT_EXPORT_METHOD(ls:(NSString *)path resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
     BOOL isDir = nil;
     exist = [fm fileExistsAtPath:path isDirectory:&isDir];
-    if(exist == NO || isDir == NO) {
-        callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not a folder", path]]);
-        return ;
+    if(exist == NO) {
+        return reject(@"ENOENT", [NSString stringWithFormat:@"No such file '%@'", path], nil);
+    }
+    if(isDir == NO) {
+        return reject(@"ENOTDIR", [NSString stringWithFormat:@"Not a directory '%@'", path], nil);
     }
     NSError * error = nil;
     NSArray * result = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:&error];
 
     if(error == nil)
-        callback(@[[NSNull null], result == nil ? [NSNull null] :result ]);
+        resolve(result);
     else
-        callback(@[[error localizedDescription], [NSNull null]]);
-
+        reject(@"EUNSPECIFIED", [error description], nil);
 }
 
 #pragma mark - fs.stat
 
             exist = [fm fileExistsAtPath:path isDirectory:&isDir];
             if(exist == NO) {
-                callback(@[[NSString stringWithFormat:@"failed to stat path `%@` for it is not exist or it is not exist", path]]);
+                callback(@[[NSString stringWithFormat:@"failed to stat path `%@` because it does not exist or it is not a folder", path]]);
                 return ;
             }
             result = [RNFetchBlobFS stat:path error:&error];
 
     exist = [fm fileExistsAtPath:path isDirectory:&isDir];
     if(exist == NO) {
-        callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not exist", path]]);
+        callback(@[[NSString stringWithFormat:@"failed to lstat path `%@` because it does not exist or it is not a folder", path]]);
         return ;
     }
     NSError * error = nil;
 #pragma mark - fs.cp
 RCT_EXPORT_METHOD(cp:(NSString*)src toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback)
 {
-
 //    path = [RNFetchBlobFS getPathOfAsset:path];
     [RNFetchBlobFS getPathFromUri:src completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
         NSError * error = nil;
         }
         else
         {
+            // If the destination exists there will be an error
             BOOL result = [[NSFileManager defaultManager] copyItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
 
             if(error == nil)
                 callback(@[[error localizedDescription], @NO]);
         }
     }];
-
 }
 
 
 }
 
 #pragma mark - fs.mkdir
-RCT_EXPORT_METHOD(mkdir:(NSString *)path callback:(RCTResponseSenderBlock) callback)
+RCT_EXPORT_METHOD(mkdir:(NSString *)path resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
-    if([[NSFileManager defaultManager] fileExistsAtPath:path]) {
-        callback(@[@"mkdir failed, folder already exists"]);
-        return;
-    }
-    else
-        [RNFetchBlobFS mkdir:path];
-    callback(@[[NSNull null]]);
+    [RNFetchBlobFS mkdir:path resolver:resolve rejecter:reject];
 }
 
 #pragma mark - fs.readFile
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
-
-    [RNFetchBlobFS readFile:path encoding:encoding onComplete:^(id content, NSString * err) {
-        if(err != nil)
-        {
-            reject(@"RNFetchBlob failed to read file", err, nil);
+    
+    [RNFetchBlobFS readFile:path encoding:encoding onComplete:^(NSData * content, NSString * code, NSString * err) {
+        if(err != nil) {
+            reject(code, err, nil);
             return;
         }
-        if(encoding == @"ascii")
-        {
+        if(encoding == @"ascii") {
             resolve((NSMutableArray *)content);
         }
-        else
-        {
+        else {
             resolve((NSString *)content);
         }
     }];
 }
 
+#pragma mark - fs.hash
+RCT_EXPORT_METHOD(hash:(NSString *)path
+                  algorithm:(NSString *)algorithm
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [RNFetchBlobFS hash:path algorithm:[NSString stringWithString:algorithm] resolver:resolve rejecter:reject];
+}
+
 #pragma mark - fs.readStream
 RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize tick:(int)tick streamId:(NSString *)streamId)
 {
 
 #pragma mark - net.cancelRequest
 RCT_EXPORT_METHOD(cancelRequest:(NSString *)taskId callback:(RCTResponseSenderBlock)callback) {
-    [RNFetchBlobNetwork cancelRequest:taskId];
+    [[RNFetchBlobNetwork sharedInstance] cancelRequest:taskId];
     callback(@[[NSNull null], taskId]);
 
 }
 {
 
     RNFetchBlobProgress * cfg = [[RNFetchBlobProgress alloc] initWithType:Download interval:interval count:count];
-    [RNFetchBlobNetwork enableProgressReport:taskId config:cfg];
+    [[RNFetchBlobNetwork sharedInstance] enableProgressReport:taskId config:cfg];
 }
 
 #pragma mark - net.enableUploadProgressReport
 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];
+    [[RNFetchBlobNetwork sharedInstance] enableUploadProgress:taskId config:cfg];
 }
 
 #pragma mark - fs.slice
       });
         resolve(@[[NSNull null]]);
     } else {
-        reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
+        reject(@"EINVAL", @"scheme is not supported", nil);
     }
 }
 
 
     if(scheme == nil || [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:scheme]]) {
         dispatch_sync(dispatch_get_main_queue(), ^{
-            [documentController presentPreviewAnimated:YES];
+            if([documentController presentPreviewAnimated:YES]) {
+                resolve(@[[NSNull null]]);
+            } else {
+                reject(@"EINVAL", @"document is not supported", nil);
+            }
         });
-        resolve(@[[NSNull null]]);
     } else {
-        reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
+        reject(@"EINVAL", @"scheme is not supported", nil);
     }
 }
 
     {
         resolve(@[[NSNull null]]);
     } else {
-        reject(@"RNFetchBlob could not open document", [error description], nil);
+        reject(@"EUNSPECIFIED", [error description], nil);
     }
 
 }

ios/RNFetchBlobConst.m

 //
 #import "RNFetchBlobConst.h"
 
-extern NSString *const FILE_PREFIX = @"RNFetchBlob-file://";
-extern NSString *const ASSET_PREFIX = @"bundle-assets://";
-extern NSString *const AL_PREFIX = @"assets-library://";
+NSString *const FILE_PREFIX = @"RNFetchBlob-file://";
+NSString *const ASSET_PREFIX = @"bundle-assets://";
+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 CONFIG_FILE_EXT = @"appendExt";
-extern NSString *const CONFIG_TRUSTY = @"trusty";
-extern NSString *const CONFIG_INDICATOR = @"indicator";
-extern NSString *const CONFIG_KEY = @"key";
-extern NSString *const CONFIG_EXTRA_BLOB_CTYPE = @"binaryContentTypes";
+NSString *const CONFIG_USE_TEMP = @"fileCache";
+NSString *const CONFIG_FILE_PATH = @"path";
+NSString *const CONFIG_FILE_EXT = @"appendExt";
+NSString *const CONFIG_TRUSTY = @"trusty";
+NSString *const CONFIG_INDICATOR = @"indicator";
+NSString *const CONFIG_KEY = @"key";
+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";
+NSString *const EVENT_STATE_CHANGE = @"RNFetchBlobState";
+NSString *const EVENT_SERVER_PUSH = @"RNFetchBlobServerPush";
+NSString *const EVENT_PROGRESS = @"RNFetchBlobProgress";
+NSString *const EVENT_PROGRESS_UPLOAD = @"RNFetchBlobProgress-upload";
+NSString *const EVENT_EXPIRE = @"RNFetchBlobExpire";
 
-extern NSString *const MSG_EVENT = @"RNFetchBlobMessage";
-extern NSString *const MSG_EVENT_LOG = @"log";
-extern NSString *const MSG_EVENT_WARN = @"warn";
-extern NSString *const MSG_EVENT_ERROR = @"error";
-extern NSString *const FS_EVENT_DATA = @"data";
-extern NSString *const FS_EVENT_END = @"end";
-extern NSString *const FS_EVENT_WARN = @"warn";
-extern NSString *const FS_EVENT_ERROR = @"error";
+NSString *const MSG_EVENT = @"RNFetchBlobMessage";
+NSString *const MSG_EVENT_LOG = @"log";
+NSString *const MSG_EVENT_WARN = @"warn";
+NSString *const MSG_EVENT_ERROR = @"error";
+NSString *const FS_EVENT_DATA = @"data";
+NSString *const FS_EVENT_END = @"end";
+NSString *const FS_EVENT_WARN = @"warn";
+NSString *const FS_EVENT_ERROR = @"error";
 
-extern NSString *const KEY_REPORT_PROGRESS = @"reportProgress";
-extern NSString *const KEY_REPORT_UPLOAD_PROGRESS = @"reportUploadProgress";
+NSString *const KEY_REPORT_PROGRESS = @"reportProgress";
+NSString *const KEY_REPORT_UPLOAD_PROGRESS = @"reportUploadProgress";
 
 // response type
-extern NSString *const RESP_TYPE_BASE64 = @"base64";
-extern NSString *const RESP_TYPE_UTF8 = @"utf8";
-extern NSString *const RESP_TYPE_PATH = @"path";
+NSString *const RESP_TYPE_BASE64 = @"base64";
+NSString *const RESP_TYPE_UTF8 = @"utf8";
+NSString *const RESP_TYPE_PATH = @"path";

ios/RNFetchBlobFS.h

     NSString * streamId;
 }
 
-@property (nonatomic) NSOutputStream * outStream;
-@property (nonatomic) NSInputStream * inStream;
+@property (nonatomic) NSOutputStream * _Nullable outStream;
+@property (nonatomic) NSInputStream * _Nullable inStream;
 @property (strong, nonatomic) RCTResponseSenderBlock callback;
 @property (nonatomic) RCTBridge * bridge;
 @property (nonatomic) NSString * encoding;
 // fs methods
 + (RNFetchBlobFS *) getFileStreams;
 + (BOOL) mkdir:(NSString *) path;
++ (void) mkdir:(NSString *) path resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
++ (void) hash:(NSString *)path
+    algorithm:(NSString *)algorithm
+     resolver:(RCTPromiseResolveBlock)resolve
+     rejecter:(RCTPromiseRejectBlock)reject;
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error;
 + (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback;
 + (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
-+ (void) readFile:(NSString *)path encoding:(NSString *)encoding onComplete:(void (^)(NSData * content, NSString * errMsg))onComplete;
++ (void) readFile:(NSString *)path encoding:(NSString *)encoding onComplete:(void (^)(NSData * content, NSString* code, NSString * errMsg))onComplete;
 + (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
 + (void) slice:(NSString *)path
          dest:(NSString *)dest

ios/RNFetchBlobFS.m

 #import "IOS7Polyfill.h"
 @import AssetsLibrary;
 
+#import <CommonCrypto/CommonDigest.h>
+
 #if __has_include(<React/RCTAssert.h>)
 #import <React/RCTBridge.h>
 #import <React/RCTEventDispatcher.h>
             {
                 if([[NSFileManager defaultManager] fileExistsAtPath:path] == NO)
                 {
-                    NSString * message = [NSString stringWithFormat:@"File not exists at path %@", path];
-                    NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"detail": message };
+                    NSString * message = [NSString stringWithFormat:@"File does not exist at path %@", path];
+                    NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"code": @"ENOENT", @"detail": message };
                     [event sendDeviceEventWithName:streamId body:payload];
                     free(buffer);
                     return ;
             }
             else
             {
-                NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"detail": @"RNFetchBlob.readStream unable to resolve URI" };
+                NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"code": @"EINVAL", @"detail": @"Unable to resolve URI" };
                 [event sendDeviceEventWithName:streamId body:payload];
             }
             // release buffer
         }
         @catch (NSError * err)
         {
-            NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"detail": [NSString stringWithFormat:@"RNFetchBlob.readStream error %@", [err description]] };
+            NSDictionary * payload = @{ @"event": FS_EVENT_ERROR, @"code": @"EUNSPECIFIED", @"detail": [err description] };
             [event sendDeviceEventWithName:streamId body:payload];
         }
         @finally
                     [asciiArray addObject:[NSNumber numberWithChar:bytePtr[i]]];
                 }
             }
-            
+
             NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : asciiArray };
             [event sendDeviceEventWithName:streamId body:payload];
         }
-        
+
     }
     @catch (NSException * ex)
     {
 
 # pragma mark - write file
 
-+ (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
++ (void) writeFile:(NSString *)path
+                    encoding:(NSString *)encoding
+                    data:(NSString *)data
+                    append:(BOOL)append
+                    resolver:(RCTPromiseResolveBlock)resolve
+                    rejecter:(RCTPromiseRejectBlock)reject
 {
     @try {
         NSFileManager * fm = [NSFileManager defaultManager];
         NSError * err = nil;
-        // check if the folder exists, if not exists, create folders recursively
+        // check if the folder exists, if it does not exist create folders recursively
         // after the folders created, write data into the file
         NSString * folder = [path stringByDeletingLastPathComponent];
         encoding = [encoding lowercaseString];
-        if(![fm fileExistsAtPath:folder]) {
-            [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:&err];
-            [fm createFileAtPath:path contents:nil attributes:nil];
+
+        BOOL isDir = NO;
+        BOOL exists = NO;
+        exists = [fm fileExistsAtPath:path isDirectory: &isDir];
+
+        if (isDir) {
+            return reject(@"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path], nil);
         }
-        if(err != nil) {
-            reject(@"RNFetchBlob writeFile Error", @"could not create file at path", nil);
-            return;
+
+        if(!exists) {
+            [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:&err];
+            if(err != nil) {
+                return reject(@"ENOTDIR", [NSString stringWithFormat:@"Failed to create parent directory of '%@'; error: %@", path, [err description]], nil);
+            }
+            if(![fm createFileAtPath:path contents:nil attributes:nil]) {
+                return reject(@"ENOENT", [NSString stringWithFormat:@"File '%@' does not exist and could not be created", path], nil);
+            }
         }
+
         NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
         NSData * content = nil;
         if([encoding RNFBContainsString:@"base64"]) {
         else if([encoding isEqualToString:@"uri"]) {
             NSNumber* size = [[self class] writeFileFromFile:data toFile:path append:append callback:^(NSString *errMsg, NSNumber *size) {
                 if(errMsg != nil)
-                    reject(@"RNFetchBlob writeFile Error", errMsg, nil);
+                    reject(@"EUNSPECIFIED", errMsg, nil);
                 else
                     resolve(size);
             }];
     }
     @catch (NSException * e)
     {
-        reject(@"RNFetchBlob writeFile Error", @"Error", [e description]);
+        reject(@"EUNSPECIFIED", [e description], nil);
     }
 }
 
 # pragma mark - write file (array)
 
-+ (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
++ (void) writeFileArray:(NSString *)path
+                         data:(NSArray *)data
+                         append:(BOOL)append
+                         resolver:(RCTPromiseResolveBlock)resolve
+                         rejecter:(RCTPromiseRejectBlock)reject
+{
     @try {
         NSFileManager * fm = [NSFileManager defaultManager];
         NSError * err = nil;
         // check if the folder exists, if not exists, create folders recursively
         // after the folders created, write data into the file
         NSString * folder = [path stringByDeletingLastPathComponent];
-        if(![fm fileExistsAtPath:folder]) {
+
+        BOOL isDir = NO;
+        BOOL exists = NO;
+        exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
+
+        if (isDir) {
+            return reject(@"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path], nil);
+        }
+
+        if(!exists) {
             [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:&err];
+            if(err != nil) {
+                return reject(@"EUNSPECIFIED", [NSString stringWithFormat:@"Failed to create parent directory of '%@'; error: %@", path, [err description]], nil);
+            }
         }
+
         NSMutableData * fileContent = [NSMutableData alloc];
         // prevent stack overflow, alloc on heap
         char * bytes = (char*) malloc([data count]);
             bytes[i] = [[data objectAtIndex:i] charValue];
         }
         [fileContent appendBytes:bytes length:data.count];
-        if(![fm fileExistsAtPath:path]) {
-            [fm createFileAtPath:path contents:fileContent attributes:NULL];
+
+        if(!exists) {
+            if(![fm createFileAtPath:path contents:fileContent attributes:NULL]) {
+                return reject(@"ENOENT", [NSString stringWithFormat:@"File '%@' does not exist and could not be created", path], nil);
+            }
         }
         // if file exists, write file
         else {
     }
     @catch (NSException * e)
     {
-        reject(@"RNFetchBlob writeFile Error", @"Error", [e description]);
+        reject(@"EUNSPECIFIED", [e description], nil);
     }
 }
 
 
 + (void) readFile:(NSString *)path
          encoding:(NSString *)encoding
-       onComplete:(void (^)(id content, NSString * errMsg))onComplete
+       onComplete:(void (^)(NSData * content, NSString * codeStr, NSString * errMsg))onComplete
 {
     [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
         __block NSData * fileContent;
             [asset getBytes:buffer fromOffset:0 length:asset.size error:&err];
             if(err != nil)
             {
-                onComplete(nil, [err description]);
+                onComplete(nil, @"EUNSPECIFIED", [err description]);
                 free(buffer);
                 return;
             }
         }
         else
         {
-            if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
-                onComplete(nil, @"file not exists");
+            BOOL isDir = NO;
+            if(![[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir]) {
+                if (isDir) {
+                    onComplete(nil, @"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path]);
+                } else {
+                    onComplete(nil, @"ENOENT", [NSString stringWithFormat:@"No such file '%@'", path]);
+                }
                 return;
             }
             fileContent = [NSData dataWithContentsOfFile:path];
-            
+
         }
-        
+
         if(encoding != nil)
         {
             if([[encoding lowercaseString] isEqualToString:@"utf8"])
             {
                 NSString * utf8 = [[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding];
                 if(utf8 == nil)
-                    onComplete([[NSString alloc] initWithData:fileContent encoding:NSISOLatin1StringEncoding], nil);
+                    onComplete([[NSString alloc] initWithData:fileContent encoding:NSISOLatin1StringEncoding], nil, nil);
                 else
-                    onComplete(utf8, nil);
+                    onComplete(utf8, nil, nil);
             }
             else if ([[encoding lowercaseString] isEqualToString:@"base64"]) {
-                onComplete([fileContent base64EncodedStringWithOptions:0], nil);
+                onComplete([fileContent base64EncodedStringWithOptions:0], nil, nil);
             }
             else if ([[encoding lowercaseString] isEqualToString:@"ascii"]) {
                 NSMutableArray * resultArray = [NSMutableArray array];
                 for(int i=0;i<[fileContent length];i++) {
                     [resultArray addObject:[NSNumber numberWithChar:bytes[i]]];
                 }
-                onComplete(resultArray, nil);
+                onComplete(resultArray, nil, nil);
             }
         }
         else
         {
-            onComplete(fileContent, nil);
+            onComplete(fileContent, nil, nil);
         }
-        
+
     }];
 }
 
+# pragma mark - hash
+
++ (void) hash:(NSString *)path
+                  algorithm:(NSString *)algorithm
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject
+{
+    BOOL isDir = NO;
+    BOOL exists = NO;
+    exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
+
+    if (isDir) {
+        return reject(@"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path], nil);
+    }
+    if (!exists) {
+        return reject(@"ENOENT", [NSString stringWithFormat:@"No such file '%@'", path], nil);
+    }
+
+    NSError *error = nil;
+
+    NSDictionary *attributes = [[NSFileManager defaultManager] attributesOfItemAtPath:path error:&error];
+
+    if (error) {
+        reject(@"EUNKNOWN", [error description], nil);
+        return;
+    }
+
+    if ([attributes objectForKey:NSFileType] == NSFileTypeDirectory) {
+        reject(@"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path], nil);
+        return;
+    }
+
+    NSData *content = [[NSFileManager defaultManager] contentsAtPath:path];
+
+    NSArray *keys = [NSArray arrayWithObjects:@"md5", @"sha1", @"sha224", @"sha256", @"sha384", @"sha512", nil];
+
+    NSArray *digestLengths = [NSArray arrayWithObjects:
+        @CC_MD5_DIGEST_LENGTH,
+        @CC_SHA1_DIGEST_LENGTH,
+        @CC_SHA224_DIGEST_LENGTH,
+        @CC_SHA256_DIGEST_LENGTH,
+        @CC_SHA384_DIGEST_LENGTH,
+        @CC_SHA512_DIGEST_LENGTH,
+        nil];
+
+    NSDictionary *keysToDigestLengths = [NSDictionary dictionaryWithObjects:digestLengths forKeys:keys];
+
+    int digestLength = [[keysToDigestLengths objectForKey:algorithm] intValue];
+
+    if (!digestLength) {
+      return reject(@"EINVAL", [NSString stringWithFormat:@"Invalid algorithm '%@', must be one of md5, sha1, sha224, sha256, sha384, sha512", algorithm], nil);
+    }
+
+    unsigned char buffer[digestLength];
+
+    if ([algorithm isEqualToString:@"md5"]) {
+        CC_MD5(content.bytes, (CC_LONG)content.length, buffer);
+    } else if ([algorithm isEqualToString:@"sha1"]) {
+        CC_SHA1(content.bytes, (CC_LONG)content.length, buffer);
+    } else if ([algorithm isEqualToString:@"sha224"]) {
+        CC_SHA224(content.bytes, (CC_LONG)content.length, buffer);
+    } else if ([algorithm isEqualToString:@"sha256"]) {
+        CC_SHA256(content.bytes, (CC_LONG)content.length, buffer);
+    } else if ([algorithm isEqualToString:@"sha384"]) {
+        CC_SHA384(content.bytes, (CC_LONG)content.length, buffer);
+    } else if ([algorithm isEqualToString:@"sha512"]) {
+        CC_SHA512(content.bytes, (CC_LONG)content.length, buffer);
+    } else {
+        reject(@"EINVAL", [NSString stringWithFormat:@"Invalid algorithm '%@', must be one of md5, sha1, sha224, sha256, sha384, sha512", algorithm], nil);
+        return;
+    }
+
+    NSMutableString *output = [NSMutableString stringWithCapacity:digestLength * 2];
+    for(int i = 0; i < digestLength; i++)
+        [output appendFormat:@"%02x",buffer[i]];
+
+    resolve(output);
+}
 
 # pragma mark - mkdir
 
-+ (BOOL) mkdir:(NSString *) path {
-    BOOL isDir;
++ (void) mkdir:(NSString *) path resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+{
+    BOOL isDir = NO;
     NSError * err = nil;
-    // if temp folder not exists, create one
-    if(![[NSFileManager defaultManager] fileExistsAtPath: path isDirectory:&isDir]) {
+    if([[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:&isDir]) {
+        reject(@"EEXIST", [NSString stringWithFormat:@"%@ '%@' already exists", isDir ? @"Directory" : @"File", path], nil);
+        return;
+    }
+    else {
         [[NSFileManager defaultManager] createDirectoryAtPath:path withIntermediateDirectories:YES attributes:nil error:&err];
     }
-    return err == nil;
+    if(err == nil) {
+        resolve(@YES);
+    }
+    else {
+        reject(@"EUNSPECIFIED", [NSString stringWithFormat:@"Error creating folder '%@', error: %@", path, [err description]], nil);
+    }
 }
 
 # pragma mark - stat
     NSData * decodedData = nil;
     if([[self.encoding lowercaseString] isEqualToString:@"base64"]) {
         decodedData = [[NSData alloc] initWithBase64EncodedString:chunk options: NSDataBase64DecodingIgnoreUnknownCharacters];
-    } 
+    }
     else if([[self.encoding lowercaseString] isEqualToString:@"utf8"]) {
         decodedData = [chunk dataUsingEncoding:NSUTF8StringEncoding];
     }
             NSFileManager * fm = [NSFileManager defaultManager];
             NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
             [os open];
-            // abort for the source file not exists
-            if([fm fileExistsAtPath:path] == NO)
-            {
-                reject(@"RNFetchBlob slice failed : the file does not exists", path, nil);
-                return;
+
+            BOOL isDir = NO;
+            BOOL exists = NO;
+            exists = [fm fileExistsAtPath:path isDirectory: &isDir];
+
+            if (isDir) {
+                return reject(@"EISDIR", [NSString stringWithFormat:@"Expecting a file but '%@' is a directory", path], nil);
+            }
+            if(!exists) {
+                return reject(@"ENOENT", [NSString stringWithFormat: @"No such file '%@'", path ], nil);
             }
+
             long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
             long max = MIN(size, [end longValue]);
 
             if(![fm fileExistsAtPath:dest]) {
-                [fm createFileAtPath:dest contents:@"" attributes:nil];
+                if(![fm createFileAtPath:dest contents:@"" attributes:nil]) {
+                    return reject(@"ENOENT", [NSString stringWithFormat:@"File '%@' does not exist and could not be created", path], nil);
+                }
             }
             [handle seekToFileOffset:[start longValue]];
-            while(read < expected)
-            {
-
+            while(read < expected) {
                 NSData * chunk;
                 long chunkSize = 0;
                 if([start longValue] + read + 10240 > max)
             long size = asset.size;
             long max = MIN(size, [end longValue]);
 
-            while(read < expected)
-            {
-
+            while(read < expected) {
                 uint8_t * chunk[10240];
                 long chunkSize = 0;
                 if([start longValue] + read + 10240 > max)
             [os close];
             resolve(dest);
         }
-        else
-        {
-            reject(@"slice error",  [NSString stringWithFormat: @"could not resolve URI %@", path ], nil);
+        else {
+            reject(@"EINVAL", [NSString stringWithFormat: @"Could not resolve URI %@", path ], nil);
         }
 
     }];
     if (dictionary) {
         NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];
         NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
-        
+
         callback(@[[NSNull null], @{
                   @"free" : freeFileSystemSizeInBytes,
                   @"total" : fileSystemSizeInBytes,
     return;
 }
 
-@end
+@end

ios/RNFetchBlobNetwork.h

 //  Copyright © 2016 wkh237. All rights reserved.
 //
 
+#ifndef RNFetchBlobNetwork_h
+#define RNFetchBlobNetwork_h
+
 #import <Foundation/Foundation.h>
 #import "RNFetchBlobProgress.h"
 #import "RNFetchBlobFS.h"
+#import "RNFetchBlobRequest.h"
 
 #if __has_include(<React/RCTAssert.h>)
 #import <React/RCTBridgeModule.h>
 #import "RCTBridgeModule.h"
 #endif
 
-#ifndef RNFetchBlobNetwork_h
-#define RNFetchBlobNetwork_h
-
-
-
-typedef void(^CompletionHander)(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error);
-typedef void(^DataTaskCompletionHander) (NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error);
 
 @interface RNFetchBlobNetwork : NSObject  <NSURLSessionDelegate, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 
-@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;
-@property (nullable, nonatomic) NSDictionary * options;
-@property (nullable, nonatomic) RNFetchBlobFS * fileStream;
-@property (strong, nonatomic) CompletionHander fileTaskCompletionHandler;
-@property (strong, nonatomic) DataTaskCompletionHander dataTaskCompletionHandler;
-@property (nullable, nonatomic) NSError * error;
-
+@property(nonnull, nonatomic) NSOperationQueue *taskQueue;
+@property(nonnull, nonatomic) NSMapTable<NSString*, RNFetchBlobRequest*> * requestsTable;
 
++ (RNFetchBlobNetwork* _Nullable)sharedInstance;
 + (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;
+- (void) cancelRequest:(NSString * _Nonnull)taskId;
+- (void) enableProgressReport:(NSString * _Nonnull) taskId config:(RNFetchBlobProgress * _Nullable)config;
+- (void) enableUploadProgress:(NSString * _Nonnull) taskId config:(RNFetchBlobProgress * _Nullable)config;
 
 
 @end

ios/RNFetchBlobNetwork.m

 
 
 #import <Foundation/Foundation.h>
-#import "RNFetchBlob.h"
-#import "RNFetchBlobFS.h"
 #import "RNFetchBlobNetwork.h"
+
+#import "RNFetchBlob.h"
 #import "RNFetchBlobConst.h"
-#import "RNFetchBlobReqBuilder.h"
-#import "IOS7Polyfill.h"
-#import <CommonCrypto/CommonDigest.h>
 #import "RNFetchBlobProgress.h"
 
 #if __has_include(<React/RCTAssert.h>)
 //
 ////////////////////////////////////////
 
-NSMapTable * taskTable;
 NSMapTable * expirationTable;
-NSMutableDictionary * progressTable;
-NSMutableDictionary * uploadProgressTable;
 
 __attribute__((constructor))
 static void initialize_tables() {
-    if(expirationTable == nil)
-    {
+    if (expirationTable == nil) {
         expirationTable = [[NSMapTable alloc] init];
     }
-    if(taskTable == nil)
-    {
-        taskTable = [[NSMapTable alloc] init];
-    }
-    if(progressTable == nil)
-    {
-        progressTable = [[NSMutableDictionary alloc] init];
-    }
-    if(uploadProgressTable == nil)
-    {
-        uploadProgressTable = [[NSMutableDictionary alloc] init];
-    }
 }
 
 
-typedef NS_ENUM(NSUInteger, ResponseFormat) {
-    UTF8,
-    BASE64,
-    AUTO
-};
-
-
-@interface RNFetchBlobNetwork ()
-{
-    BOOL * respFile;
-    BOOL isNewPart;
-    BOOL * isIncrement;
-    NSMutableData * partBuffer;
-    NSString * destPath;
-    NSOutputStream * writeStream;
-    long bodyLength;
-    NSMutableDictionary * respInfo;
-    NSInteger respStatus;
-    NSMutableArray * redirects;
-    ResponseFormat responseFormat;
-    BOOL * followRedirect;
-    BOOL backgroundTask;
-}
-
-@end
-
 @implementation RNFetchBlobNetwork
 
-NSOperationQueue *taskQueue;
-@synthesize taskId;
-@synthesize expectedBytes;
-@synthesize receivedBytes;
-@synthesize respData;
-@synthesize callback;
-@synthesize bridge;
-@synthesize options;
-@synthesize fileTaskCompletionHandler;
-@synthesize dataTaskCompletionHandler;
-@synthesize error;
 
-
-// constructor
 - (id)init {
     self = [super init];
-    if(taskQueue == nil) {
-        taskQueue = [[NSOperationQueue alloc] init];
-        taskQueue.maxConcurrentOperationCount = 10;
+    if (self) {
+        self.requestsTable = [NSMapTable mapTableWithKeyOptions:NSMapTableStrongMemory valueOptions:NSMapTableWeakMemory];
+        
+        self.taskQueue = [[NSOperationQueue alloc] init];
+        self.taskQueue.qualityOfService = NSQualityOfServiceUtility;
+        self.taskQueue.maxConcurrentOperationCount = 10;
     }
+    
     return self;
 }
 
-+ (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config
-{
-    if(progressTable == nil)
-    {
-        progressTable = [[NSMutableDictionary alloc] init];
-    }
-    [progressTable setValue:config forKey:taskId];
-}
-
-+ (void) enableUploadProgress:(NSString *) taskId config:(RNFetchBlobProgress *)config
-{
-    if(uploadProgressTable == nil)
-    {
-        uploadProgressTable = [[NSMutableDictionary alloc] init];
-    }
-    [uploadProgressTable setValue:config forKey:taskId];
-}
-
-// removing case from headers
-+ (NSMutableDictionary *) normalizeHeaders:(NSDictionary *)headers
-{
++ (RNFetchBlobNetwork* _Nullable)sharedInstance {
+    static id _sharedInstance = nil;
+    static dispatch_once_t onceToken;
 
-    NSMutableDictionary * mheaders = [[NSMutableDictionary alloc]init];
-    for(NSString * key in headers) {
-        [mheaders setValue:[headers valueForKey:key] forKey:[key lowercaseString]];
-    }
-
-    return mheaders;
-}
-
-- (NSString *)md5:(NSString *)input {
-    const char* str = [input UTF8String];
-    unsigned char result[CC_MD5_DIGEST_LENGTH];
-    CC_MD5(str, (CC_LONG)strlen(str), result);
-
-    NSMutableString *ret = [NSMutableString stringWithCapacity:CC_MD5_DIGEST_LENGTH*2];
-    for(int i = 0; i<CC_MD5_DIGEST_LENGTH; i++) {
-        [ret appendFormat:@"%02x",result[i]];
-    }
-    return ret;
+    dispatch_once(&onceToken, ^{
+        _sharedInstance = [[self alloc] init];
+    });
+    
+    return _sharedInstance;
 }
 
-// send HTTP request
 - (void) sendRequest:(__weak NSDictionary  * _Nullable )options
        contentLength:(long) contentLength
               bridge:(RCTBridge * _Nullable)bridgeRef
          withRequest:(__weak NSURLRequest * _Nullable)req
             callback:(_Nullable RCTResponseSenderBlock) callback
 {
-    self.taskId = taskId;
-    self.respData = [[NSMutableData alloc] initWithLength:0];
-    self.callback = callback;
-    self.bridge = bridgeRef;
-    self.expectedBytes = 0;
-    self.receivedBytes = 0;
-    self.options = options;
+    RNFetchBlobRequest *request = [[RNFetchBlobRequest alloc] init];
+    [request sendRequest:options
+           contentLength:contentLength
+                  bridge:bridgeRef
+                  taskId:taskId
+             withRequest:req
+      taskOperationQueue:self.taskQueue
+                callback:callback];
     
-    backgroundTask = [options valueForKey:@"IOSBackgroundTask"] == nil ? NO : [[options valueForKey:@"IOSBackgroundTask"] boolValue];
-    followRedirect = [options valueForKey:@"followRedirect"] == nil ? YES : [[options valueForKey:@"followRedirect"] boolValue];
-    isIncrement = [options valueForKey:@"increment"] == nil ? NO : [[options valueForKey:@"increment"] boolValue];
-    redirects = [[NSMutableArray alloc] init];
-    if(req.URL != nil)
-        [redirects addObject:req.URL.absoluteString];
-
-    // set response format
-    NSString * rnfbResp = [req.allHTTPHeaderFields valueForKey:@"RNFB-Response"];
-    if([[rnfbResp lowercaseString] isEqualToString:@"base64"])
-        responseFormat = BASE64;
-    else if([[rnfbResp lowercaseString] isEqualToString:@"utf8"])
-        responseFormat = UTF8;
-    else
-        responseFormat = AUTO;
-
-    NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
-    NSString * ext = [self.options valueForKey:CONFIG_FILE_EXT];
-	NSString * key = [self.options valueForKey:CONFIG_KEY];
-    __block NSURLSession * session;
-
-    bodyLength = contentLength;
-
-    // the session trust any SSL certification
-    NSURLSessionConfiguration *defaultConfigObject;
-
-    defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
-
-    if(backgroundTask)
-    {
-        defaultConfigObject = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:taskId];
-    }
-
-    // set request timeout
-    float timeout = [options valueForKey:@"timeout"] == nil ? -1 : [[options valueForKey:@"timeout"] floatValue];
-    if(timeout > 0)
-    {
-        defaultConfigObject.timeoutIntervalForRequest = timeout/1000;
-    }
-    defaultConfigObject.HTTPMaximumConnectionsPerHost = 10;
-    session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:taskQueue];
-    if(path != nil || [self.options valueForKey:CONFIG_USE_TEMP]!= nil)
-    {
-        respFile = YES;
-
-		NSString* cacheKey = taskId;
-		if (key != nil) {
-            cacheKey = [self md5:key];
-			if (cacheKey == nil) {
-				cacheKey = taskId;
-			}
-
-			destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
-            if ([[NSFileManager defaultManager] fileExistsAtPath:destPath]) {
-				callback(@[[NSNull null], RESP_TYPE_PATH, destPath]);
-                return;
-            }
-		}
-
-        if(path != nil)
-            destPath = path;
-        else
-            destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
-    }
-    else
-    {
-        respData = [[NSMutableData alloc] init];
-        respFile = NO;
-    }
-
-    __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 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];
-
+    @synchronized([RNFetchBlobNetwork class]) {
+        [self.requestsTable setObject:request forKey:taskId];
     }
-
-    // clear expired task entries
-    [expirationTable removeAllObjects];
-    expirationTable = [[NSMapTable alloc] init];
-
 }
 
-////////////////////////////////////////
-//
-//  NSURLSession delegates
-//
-////////////////////////////////////////
-
-
-#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
+- (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
-    expectedBytes = [response expectedContentLength];
-
-    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse*)response;
-    NSInteger statusCode = [(NSHTTPURLResponse *)response statusCode];
-    NSString * respType = @"";
-    respStatus = statusCode;
-    if ([response respondsToSelector:@selector(allHeaderFields)])
-    {
-        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];
-            if([respCType RNFBContainsString:@"text/"])
-            {
-                respType = @"text";
-            }
-            else if([respCType RNFBContainsString:@"application/json"])
-            {
-                respType = @"json";
-            }
-            // If extra blob content type is not empty, check if response type matches
-            else if( extraBlobCTypes !=  nil) {
-                for(NSString * substr in extraBlobCTypes)
-                {
-                    if([respCType RNFBContainsString:[substr lowercaseString]])
-                    {
-                        respType = @"blob";
-                        respFile = YES;
-                        destPath = [RNFetchBlobFS getTempPath:taskId withExtension:nil];
-                        break;
-                    }
-                }
-            }
-            else
-            {
-                respType = @"blob";
-                // for XMLHttpRequest, switch response data handling strategy automatically
-                if([options valueForKey:@"auto"] == YES) {
-                    respFile = YES;
-                    destPath = [RNFetchBlobFS getTempPath:taskId withExtension:@""];
-                }
-            }
+    if (config) {
+        @synchronized ([RNFetchBlobNetwork class]) {
+            [self.requestsTable objectForKey:taskId].progressConfig = config;
         }
-        else
-            respType = @"text";
-        respInfo = @{
-                     @"taskId": taskId,
-                     @"state": @"2",
-                     @"headers": headers,
-                     @"redirects": redirects,
-                     @"respType" : respType,
-                     @"timeout" : @NO,
-                     @"status": [NSNumber numberWithInteger:statusCode]
-                    };
-
-#pragma mark - handling cookies
-        // # 153 get cookies
-        if(response.URL != nil)
-        {
-            NSHTTPCookieStorage * cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
-            NSArray<NSHTTPCookie *> * cookies = [NSHTTPCookie cookiesWithResponseHeaderFields: headers forURL:response.URL];
-            if(cookies != nil && [cookies count] > 0) {
-                [cookieStore setCookies:cookies forURL:response.URL mainDocumentURL:nil];
-            }
-        }
-
-        [self.bridge.eventDispatcher
-         sendDeviceEventWithName: EVENT_STATE_CHANGE
-         body:respInfo
-        ];
-        headers = nil;
-        respInfo = nil;
-
-    }
-    else
-        NSLog(@"oops");
-
-    if(respFile == YES)
-    {
-        @try{
-            NSFileManager * fm = [NSFileManager defaultManager];
-            NSString * folder = [destPath stringByDeletingLastPathComponent];
-            if(![fm fileExistsAtPath:folder])
-            {
-                [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)
-            {
-                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:appendToExistingFile];
-            [writeStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
-            [writeStream open];
-        }
-        @catch(NSException * ex)
-        {
-            NSLog(@"write file error");
-        }
-    }
-
-    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 = @"";
-
-    if(isIncrement == YES)
-    {
-        chunkString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-    }
-
-    if(respFile == NO)
-    {
-        [respData appendData:data];
-    }
-    else
-    {
-        [writeStream write:[data bytes] maxLength:[data length]];
     }
-    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
-         body:@{
-                @"taskId": taskId,
-                @"written": [NSString stringWithFormat:@"%d", receivedBytes],
-                @"total": [NSString stringWithFormat:@"%d", expectedBytes],
-                @"chunk": chunkString
-            }
-         ];
-    }
-    received = nil;
-
 }
 
-- (void) URLSession:(NSURLSession *)session didBecomeInvalidWithError:(nullable NSError *)error
+- (void) enableUploadProgress:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
-    if([session isEqual:session])
-        session = nil;
-}
-
-
-- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
-{
-
-    self.error = error;
-    NSString * errMsg = [NSNull null];
-    NSString * respStr = [NSNull null];
-    NSString * rnfbRespType = @"";
-
-    [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
-
-    if(respInfo == nil)
-    {
-        respInfo = [NSNull null];
-    }
-
-    if(error != nil)
-    {
-        errMsg = [error localizedDescription];
-    }
-
-    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)
-        {
-            rnfbRespType = RESP_TYPE_BASE64;
-            respStr = [respData base64EncodedStringWithOptions:0];
-        }
-        else if (responseFormat == UTF8)
-        {
-            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];
-            }
+    if (config) {
+        @synchronized ([RNFetchBlobNetwork class]) {
+            [self.requestsTable objectForKey:taskId].uploadProgressConfig = config;
         }
     }
-
-
-    callback(@[ errMsg, rnfbRespType, respStr]);
-
-    @synchronized(taskTable, uploadProgressTable, progressTable)
-    {
-        if([taskTable objectForKey:taskId] == nil)
-            NSLog(@"object released by ARC.");
-        else
-            [taskTable removeObjectForKey:taskId];
-        [uploadProgressTable removeObjectForKey:taskId];
-        [progressTable removeObjectForKey:taskId];
-    }
-
-    respData = nil;
-    receivedBytes = 0;
-    [session finishTasksAndInvalidate];
-
 }
 
-// upload progress handler
-- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didSendBodyData:(int64_t)bytesSent totalBytesSent:(int64_t)totalBytesWritten totalBytesExpectedToSend:(int64_t)totalBytesExpectedToWrite
+- (void) cancelRequest:(NSString *)taskId
 {
-    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", totalBytesExpectedToWrite]
-                }
-         ];
+    NSURLSessionDataTask * task;
+    
+    @synchronized ([RNFetchBlobNetwork class]) {
+        task = [self.requestsTable objectForKey:taskId].task;
     }
-}
-
-+ (void) cancelRequest:(NSString *)taskId
-{
-    NSURLSessionDataTask * task = [taskTable objectForKey:taskId];
-    if(task != nil && task.state == NSURLSessionTaskStateRunning)
+    
+    if (task && task.state == NSURLSessionTaskStateRunning) {
         [task cancel];
-}
-
-
-- (void) URLSession:(NSURLSession *)session didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition, NSURLCredential * _Nullable credantial))completionHandler
-{
-    BOOL trusty = [options valueForKey:CONFIG_TRUSTY];
-    if(!trusty)
-    {
-        completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
-    }
-    else
-    {
-        completionHandler(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
     }
 }
 
-
-- (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
+// removing case from headers
++ (NSMutableDictionary *) normalizeHeaders:(NSDictionary *)headers
 {
-    NSLog(@"sess done in background");
+    NSMutableDictionary * mheaders = [[NSMutableDictionary alloc]init];
+    for (NSString * key in headers) {
+        [mheaders setValue:[headers valueForKey:key] forKey:[key lowercaseString]];
+    }
+    
+    return mheaders;
 }
 
-- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
+// #115 Invoke fetch.expire event on those expired requests so that the expired event can be handled
++ (void) emitExpiredTasks
 {
-
-    if(followRedirect)
-    {
-        if(request.URL != nil)
-            [redirects addObject:[request.URL absoluteString]];
-        completionHandler(request);
-    }
-    else
-    {
-        completionHandler(nil);
+    @synchronized ([RNFetchBlobNetwork class]){
+        NSEnumerator * emu =  [expirationTable keyEnumerator];
+        NSString * key;
+        
+        while ((key = [emu nextObject]))
+        {
+            RCTBridge * bridge = [RNFetchBlob getRCTBridge];
+            id args = @{ @"taskId": key };
+            [bridge.eventDispatcher sendDeviceEventWithName:EVENT_EXPIRE body:args];
+            
+        }
+        
+        // clear expired task entries
+        [expirationTable removeAllObjects];
+        expirationTable = [[NSMapTable alloc] init];
     }
 }
 

ios/RNFetchBlobReqBuilder.h

                      body:(NSString *)body
                onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
 
-+(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSMutableArray *) headers;
++(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSDictionary *) headers;
 
 
 @end

ios/RNFetchBlobReqBuilder.m

                     if([orgPath hasPrefix:AL_PREFIX])
                     {
                         
-                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString * err) {
+                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(id content, NSString* code, NSString * err) {
                             if(err != nil)
                             {
                                 onComplete(nil, nil);
                             }
                             else
                             {
-                                [request setHTTPBody:content];
+                                [request setHTTPBody:((NSData *)content)];
                                 [request setHTTPMethod: method];
                                 [request setAllHTTPHeaderFields:mheaders];
-                                onComplete(request, [content length]);
+                                onComplete(request, [((NSData *)content) length]);
                             }
                         }];
                         
                         NSString * orgPath = [content substringFromIndex:[FILE_PREFIX length]];
                         orgPath = [RNFetchBlobFS getPathOfAsset:orgPath];
 
-                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString * err) {
+                        [RNFetchBlobFS readFile:orgPath encoding:nil onComplete:^(NSData *content, NSString* code, NSString * err) {
                             if(err != nil)
                             {
                                 onComplete(formData, YES);
     }
 }
 
-+(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSMutableDictionary *) headers {
++(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSDictionary *) headers {
 
     NSString * normalCase = [headers valueForKey:field];
     NSString * ignoredCase = [headers valueForKey:[field lowercaseString]];

ios/RNFetchBlobRequest.h

+//
+//  RNFetchBlobRequest.h
+//  RNFetchBlob
+//
+//  Created by Artur Chrusciel on 15.01.18.
+//  Copyright © 2018 wkh237.github.io. All rights reserved.
+//
+
+#ifndef RNFetchBlobRequest_h
+#define RNFetchBlobRequest_h
+
+#import <Foundation/Foundation.h>
+
+#import "RNFetchBlobProgress.h"
+
+#if __has_include(<React/RCTAssert.h>)
+#import <React/RCTBridgeModule.h>
+#else
+#import "RCTBridgeModule.h"
+#endif
+
+@interface RNFetchBlobRequest : NSObject <NSURLSessionDelegate, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
+
+@property (nullable, nonatomic) NSString * taskId;
+@property (nonatomic) long long expectedBytes;
+@property (nonatomic) long long receivedBytes;
+@property (nonatomic) BOOL isServerPush;
+@property (nullable, nonatomic) NSMutableData * respData;
+@property (nullable, strong, nonatomic) RCTResponseSenderBlock callback;
+@property (nullable, nonatomic) RCTBridge * bridge;
+@property (nullable, nonatomic) NSDictionary * options;
+@property (nullable, nonatomic) NSError * error;
+@property (nullable, nonatomic) RNFetchBlobProgress *progressConfig;
+@property (nullable, nonatomic) RNFetchBlobProgress *uploadProgressConfig;
+@property (nullable, nonatomic, weak) NSURLSessionDataTask *task;
+
+- (void) sendRequest:(NSDictionary  * _Nullable )options
+       contentLength:(long)contentLength
+              bridge:(RCTBridge * _Nullable)bridgeRef
+              taskId:(NSString * _Nullable)taskId
+         withRequest:(NSURLRequest * _Nullable)req
+  taskOperationQueue:(NSOperationQueue * _Nonnull)operationQueue
+            callback:(_Nullable RCTResponseSenderBlock) callback;
+
+@end
+
+#endif /* RNFetchBlobRequest_h */

ios/RNFetchBlobRequest.m

+//
+//  RNFetchBlobRequest.m
+//  RNFetchBlob
+//
+//  Created by Artur Chrusciel on 15.01.18.
+//  Copyright © 2018 wkh237.github.io. All rights reserved.
+//
+
+#import "RNFetchBlobRequest.h"
+
+#import "RNFetchBlobFS.h"
+#import "RNFetchBlobConst.h"
+#import "RNFetchBlobReqBuilder.h"
+
+#import "IOS7Polyfill.h"
+#import <CommonCrypto/CommonDigest.h>
+
+
+typedef NS_ENUM(NSUInteger, ResponseFormat) {
+    UTF8,
+    BASE64,
+    AUTO
+};
+
+@interface RNFetchBlobRequest ()
+{
+    BOOL respFile;
+    BOOL isNewPart;
+    BOOL isIncrement;
+    NSMutableData * partBuffer;
+    NSString * destPath;
+    NSOutputStream * writeStream;
+    long bodyLength;
+    NSInteger respStatus;
+    NSMutableArray * redirects;
+    ResponseFormat responseFormat;
+    BOOL followRedirect;
+    BOOL backgroundTask;
+}
+
+@end
+
+@implementation RNFetchBlobRequest
+
+@synthesize taskId;
+@synthesize expectedBytes;
+@synthesize receivedBytes;
+@synthesize respData;
+@synthesize callback;
+@synthesize bridge;
+@synthesize options;
+@synthesize error;
+
+
+- (NSString *)md5:(NSString *)input {
+    const char* str = [input UTF8String];
+    unsigned char result[CC_MD5_DIGEST_LENGTH];
+    CC_MD5(str, (CC_LONG)strlen(str), result);
+    
+    NSMutableString *ret = [NSMutableString stringWithCapacity:CC_MD5_DIGEST_LENGTH*2];
+    for (int i = 0; i<CC_MD5_DIGEST_LENGTH; i++) {
+        [ret appendFormat:@"%02x",result[i]];
+    }
+    return ret;
+}
+
+// send HTTP request
+- (void) sendRequest:(__weak NSDictionary  * _Nullable )options
+       contentLength:(long) contentLength
+              bridge:(RCTBridge * _Nullable)bridgeRef
+              taskId:(NSString * _Nullable)taskId
+         withRequest:(__weak NSURLRequest * _Nullable)req
+  taskOperationQueue:(NSOperationQueue * _Nonnull)operationQueue
+            callback:(_Nullable RCTResponseSenderBlock) callback
+{
+    self.taskId = taskId;
+    self.respData = [[NSMutableData alloc] initWithLength:0];
+    self.callback = callback;
+    self.bridge = bridgeRef;
+    self.expectedBytes = 0;
+    self.receivedBytes = 0;
+    self.options = options;
+    
+    backgroundTask = [[options valueForKey:@"IOSBackgroundTask"] boolValue];
+    // when followRedirect not set in options, defaults to TRUE
+    followRedirect = [options valueForKey:@"followRedirect"] == nil ? YES : [[options valueForKey:@"followRedirect"] boolValue];
+    isIncrement = [[options valueForKey:@"increment"] boolValue];
+    redirects = [[NSMutableArray alloc] init];
+    
+    if (req.URL) {
+        [redirects addObject:req.URL.absoluteString];
+    }
+    
+    // set response format
+    NSString * rnfbResp = [req.allHTTPHeaderFields valueForKey:@"RNFB-Response"];
+    
+    if ([[rnfbResp lowercaseString] isEqualToString:@"base64"]) {
+        responseFormat = BASE64;
+    } else if ([[rnfbResp lowercaseString] isEqualToString:@"utf8"]) {
+        responseFormat = UTF8;
+    } else {
+        responseFormat = AUTO;
+    }
+    
+    NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
+    NSString * key = [self.options valueForKey:CONFIG_KEY];
+    NSURLSession * session;
+    
+    bodyLength = contentLength;
+    
+    // the session trust any SSL certification
+    NSURLSessionConfiguration *defaultConfigObject;
+    
+    defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
+    
+    if (backgroundTask) {
+        defaultConfigObject = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:taskId];
+    }
+    
+    // request timeout, -1 if not set in options
+    float timeout = [options valueForKey:@"timeout"] == nil ? -1 : [[options valueForKey:@"timeout"] floatValue];
+    
+    if (timeout > 0) {
+        defaultConfigObject.timeoutIntervalForRequest = timeout/1000;
+    }
+    
+    defaultConfigObject.HTTPMaximumConnectionsPerHost = 10;
+    session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:operationQueue];
+    
+    if (path || [self.options valueForKey:CONFIG_USE_TEMP]) {
+        respFile = YES;
+        
+        NSString* cacheKey = taskId;
+        if (key) {
+            cacheKey = [self md5:key];
+            
+            if (!cacheKey) {
+                cacheKey = taskId;
+            }
+            
+            destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
+            
+            if ([[NSFileManager defaultManager] fileExistsAtPath:destPath]) {
+                callback(@[[NSNull null], RESP_TYPE_PATH, destPath]);
+                
+                return;
+            }
+        }
+        
+        if (path) {
+            destPath = path;
+        } else {
+            destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
+        }
+    } else {
+        respData = [[NSMutableData alloc] init];
+        respFile = NO;
+    }
+    
+    self.task = [session dataTaskWithRequest:req];
+    [self.task resume];
+    
+    // network status indicator
+    if ([[options objectForKey:CONFIG_INDICATOR] boolValue]) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
+        });
+    }
+}
+
+////////////////////////////////////////
+//
+//  NSURLSession delegates
+//
+////////////////////////////////////////
+
+
+#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
+{
+    expectedBytes = [response expectedContentLength];
+    
+    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse*)response;
+    NSInteger statusCode = [(NSHTTPURLResponse *)response statusCode];
+    NSString * respType = @"";
+    respStatus = statusCode;
+    
+    if ([response respondsToSelector:@selector(allHeaderFields)])
+    {
+        NSDictionary *headers = [httpResponse allHeaderFields];
+        NSString * respCType = [[RNFetchBlobReqBuilder getHeaderIgnoreCases:@"Content-Type" fromHeaders:headers] lowercaseString];
+        
+        if (self.isServerPush) {
+            if (partBuffer) {
+                [self.bridge.eventDispatcher
+                 sendDeviceEventWithName:EVENT_SERVER_PUSH
+                 body:@{
+                        @"taskId": taskId,
+                        @"chunk": [partBuffer base64EncodedStringWithOptions:0],
+                        }
+                 ];
+            }
+            
+            partBuffer = [[NSMutableData alloc] init];
+            completionHandler(NSURLSessionResponseAllow);
+
+            return;
+        } else {
+            self.isServerPush = [[respCType lowercaseString] RNFBContainsString:@"multipart/x-mixed-replace;"];
+        }
+        
+        if(respCType)
+        {
+            NSArray * extraBlobCTypes = [options objectForKey:CONFIG_EXTRA_BLOB_CTYPE];
+            
+            if ([respCType RNFBContainsString:@"text/"]) {
+                respType = @"text";
+            } else if ([respCType RNFBContainsString:@"application/json"]) {
+                respType = @"json";
+            } else if(extraBlobCTypes) { // If extra blob content type is not empty, check if response type matches
+                for (NSString * substr in extraBlobCTypes) {
+                    if ([respCType RNFBContainsString:[substr lowercaseString]]) {
+                        respType = @"blob";
+                        respFile = YES;
+                        destPath = [RNFetchBlobFS getTempPath:taskId withExtension:nil];
+                        break;
+                    }
+                }
+            } else {
+                respType = @"blob";
+                
+                // for XMLHttpRequest, switch response data handling strategy automatically
+                if ([options valueForKey:@"auto"]) {
+                    respFile = YES;
+                    destPath = [RNFetchBlobFS getTempPath:taskId withExtension:@""];
+                }
+            }
+        } else {
+            respType = @"text";
+        }
+        
+#pragma mark - handling cookies
+        // # 153 get cookies
+        if (response.URL) {
+            NSHTTPCookieStorage * cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+            NSArray<NSHTTPCookie *> * cookies = [NSHTTPCookie cookiesWithResponseHeaderFields: headers forURL:response.URL];
+            if (cookies.count) {
+                [cookieStore setCookies:cookies forURL:response.URL mainDocumentURL:nil];
+            }
+        }
+        
+        [self.bridge.eventDispatcher
+         sendDeviceEventWithName: EVENT_STATE_CHANGE
+         body:@{
+                @"taskId": taskId,
+                @"state": @"2",
+                @"headers": headers,
+                @"redirects": redirects,
+                @"respType" : respType,
+                @"timeout" : @NO,
+                @"status": [NSNumber numberWithInteger:statusCode]
+                }
+         ];
+    } else {
+        NSLog(@"oops");
+    }
+    
+    if (respFile)
+    {
+        @try{
+            NSFileManager * fm = [NSFileManager defaultManager];
+            NSString * folder = [destPath stringByDeletingLastPathComponent];
+            
+            if (![fm fileExistsAtPath:folder]) {
+                [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:nil];
+            }
+            
+            // if not set overwrite in options, defaults to TRUE
+            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) {
+                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:appendToExistingFile];
+            [writeStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
+            [writeStream open];
+        }
+        @catch(NSException * ex)
+        {
+            NSLog(@"write file error");
+        }
+    }
+    
+    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 = @"";
+    
+    if (isIncrement) {
+        chunkString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    }
+    
+    if (respFile) {
+        [writeStream write:[data bytes] maxLength:[data length]];
+    } else {
+        [respData appendData:data];
+    }
+    
+    if (expectedBytes == 0) {
+        return;
+    }
+    
+    NSNumber * now =[NSNumber numberWithFloat:((float)receivedBytes/(float)expectedBytes)];
+    
+    if ([self.progressConfig shouldReport:now]) {
+        [self.bridge.eventDispatcher
+         sendDeviceEventWithName:EVENT_PROGRESS
+         body:@{
+                @"taskId": taskId,
+                @"written": [NSString stringWithFormat:@"%ld", (long) receivedBytes],
+                @"total": [NSString stringWithFormat:@"%ld", (long) expectedBytes],
+                @"chunk": chunkString
+                }
+         ];
+    }
+}
+
+- (void) URLSession:(NSURLSession *)session didBecomeInvalidWithError:(nullable NSError *)error
+{
+    if ([session isEqual:session]) {
+        session = nil;
+    }
+}
+
+
+- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
+    
+    self.error = error;
+    NSString * errMsg;
+    NSString * respStr;
+    NSString * rnfbRespType;
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
+    });
+    
+    if (error) {
+        if (error.domain == NSURLErrorDomain && error.code == NSURLErrorCancelled) {
+            errMsg = @"task cancelled";
+        } else {
+            errMsg = [error localizedDescription];
+        }
+    }
+    
+    if (respFile) {
+        [writeStream close];
+        rnfbRespType = RESP_TYPE_PATH;
+        respStr = destPath;
+    } else { // base64 response
+        // #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) {
+            rnfbRespType = RESP_TYPE_UTF8;
+            respStr = utf8;
+        } else {
+            if (utf8) {
+                rnfbRespType = RESP_TYPE_UTF8;
+                respStr = utf8;
+            } else {
+                rnfbRespType = RESP_TYPE_BASE64;
+                respStr = [respData base64EncodedStringWithOptions:0];
+            }
+        }
+    }
+    
+    
+    callback(@[
+               errMsg ?: [NSNull null],
+               rnfbRespType ?: @"",
+               respStr ?: [NSNull null]
+               ]);
+    
+    respData = nil;
+    receivedBytes = 0;
+    [session finishTasksAndInvalidate];
+    
+}
+
+// upload progress handler
+- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didSendBodyData:(int64_t)bytesSent totalBytesSent:(int64_t)totalBytesWritten totalBytesExpectedToSend:(int64_t)totalBytesExpectedToWrite
+{
+    if (totalBytesExpectedToWrite == 0) {
+        return;
+    }
+    
+    NSNumber * now = [NSNumber numberWithFloat:((float)totalBytesWritten/(float)totalBytesExpectedToWrite)];
+
+    if ([self.uploadProgressConfig shouldReport:now]) {
+        [self.bridge.eventDispatcher
+         sendDeviceEventWithName:EVENT_PROGRESS_UPLOAD
+         body:@{
+                @"taskId": taskId,
+                @"written": [NSString stringWithFormat:@"%ld", (long) totalBytesWritten],
+                @"total": [NSString stringWithFormat:@"%ld", (long) totalBytesExpectedToWrite]
+                }
+         ];
+    }
+}
+
+
+- (void) URLSession:(NSURLSession *)session didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition, NSURLCredential * _Nullable credantial))completionHandler
+{
+    if ([[options valueForKey:CONFIG_TRUSTY] boolValue]) {
+        completionHandler(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
+    } else {
+        completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, [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
+{
+    
+    if (followRedirect) {
+        if (request.URL) {
+            [redirects addObject:[request.URL absoluteString]];
+        }
+        
+        completionHandler(request);
+    } else {
+        completionHandler(nil);
+    }
+}
+
+
+@end

json-stream.js

 import XMLHttpRequest from './polyfill/XMLHttpRequest'
 import URIUtil from './utils/uri'
 
-const OboeExtended = (arg: string | object) => {
+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.')
+    console.warn(
+        'Use JSONStream will automatically replace window.XMLHttpRequest with RNFetchBlob.polyfill.XMLHttpRequest. ' +
+        'You are seeing this warning because you did not replace it manually.'
+    )
   }
 
   if(typeof arg === 'string') {

polyfill/Fetch.js

               // release blob cache created when sending request
               if(blobCache !== null && blobCache instanceof Blob)
                 blobCache.close()
-              return Promise.resolve(new RNFetchBlobFetchRepsonse(resp))
+              return Promise.resolve(new RNFetchBlobFetchResponse(resp))
             })
           })
 
 
 }
 
-class RNFetchBlobFetchRepsonse {
+class RNFetchBlobFetchResponse {
 
   constructor(resp:FetchBlobResponse) {
     let info = resp.info()

polyfill/File.js

 // Use of this source code is governed by a MIT-style license that can be
 // found in the LICENSE file.
 
-import fs from '../fs.js'
 import Blob from './Blob.js'
 
 export default class File extends Blob {
 
   static build(name:string, data:any, cType:string):Promise<File> {
     return new Promise((resolve, reject) => {
+      if (data === undefined) {
+        reject(new TypeError('data is undefined'))
+      }
       new File(data, cType).onCreated((f) => {
         f.name = name
         resolve(f)

polyfill/XMLHttpRequest.js

       /[\(\)\>\<\@\,\:\\\/\[\]\?\=\}\{\s\ \u007f\;\t\0\v\r]/,
       /tt/
     ]
-    for(let i in invalidPatterns) {
-      if(invalidPatterns[i].test(name) || typeof name !== 'string') {
+    for(let pattern of invalidPatterns) {
+      if(pattern.test(name) || typeof name !== 'string') {
         throw `SyntaxError : Invalid header field name ${name}`
       }
     }