Merge branch '0.10.9' into exception_fixes

README.md

 - [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)
 
 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

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}
  */

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
+#Sat Aug 12 07:48:35 CEST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME

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

 import android.app.DownloadManager;
 import android.content.Intent;
 import android.net.Uri;
+import android.util.SparseArray;
 
 import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Callback;
 
 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);
             }
         });
     }
             };
             RCTContext.addLifecycleEventListener(listener);
         } catch(Exception ex) {
-            promise.reject(ex.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", ex.getLocalizedMessage());
         }
     }
 
     }
 
     @ReactMethod
-    public void mkdir(String path, Callback callback) {
-        RNFetchBlobFS.mkdir(path, callback);
+    public void mkdir(String path, Promise promise) {
+        RNFetchBlobFS.mkdir(path, promise);
     }
 
     @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
     }
 
     @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 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());
         }
 
     }

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 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;
     }
     }
 
     @Override
-    public void writeTo(BufferedSink sink) {
+    public void writeTo(@NonNull BufferedSink sink) {
         try {
             pipeStreamToSink(requestStream, sink);
         } catch(Exception ex) {
         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
      * @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() {
         long total = 0;
         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());
             }
             // 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/RNFetchBlobFS.java

 package com.RNFetchBlob;
 
-import android.content.pm.PackageInfo;
-import android.content.pm.PackageManager;
 import android.content.res.AssetFileDescriptor;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
+import java.io.*;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
+import java.security.MessageDigest;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 
-public class RNFetchBlobFS {
+class RNFetchBlobFS {
 
-    ReactApplicationContext mCtx;
-    DeviceEventManagerModule.RCTDeviceEventEmitter emitter;
-    String encoding = "base64";
-    boolean append = false;
-    OutputStream writeStreamInstance = null;
-    static HashMap<String, RNFetchBlobFS> fileStreams = new HashMap<>();
+    private ReactApplicationContext mCtx;
+    private DeviceEventManagerModule.RCTDeviceEventEmitter emitter;
+    private String encoding = "base64";
+    private OutputStream writeStreamInstance = null;
+    private static HashMap<String, RNFetchBlobFS> fileStreams = new HashMap<>();
 
     RNFetchBlobFS(ReactApplicationContext ctx) {
         this.mCtx = ctx;
         this.emitter = ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
     }
 
-    static String getExternalFilePath(ReactApplicationContext ctx, String taskId, RNFetchBlobConfig config) {
-        if(config.path != null)
-            return config.path;
-        else if(config.fileCache && config.appendExt != null)
-            return RNFetchBlobFS.getTmpPath(ctx, taskId) + "." + config.appendExt;
-        else
-            return RNFetchBlobFS.getTmpPath(ctx, taskId);
-    }
-
     /**
      * Write string with encoding to file
      * @param path Destination file path.
      * @param data Array passed from JS context.
      * @param promise RCT Promise
      */
-    static public void writeFile(String path, String encoding, String data, final boolean append, final Promise promise) {
+    static void writeFile(String path, String encoding, String data, final boolean append, final Promise promise) {
         try {
-            int written = 0;
+            int written;
             File f = new File(path);
             File dir = f.getParentFile();
-            if(!dir.exists())
-                dir.mkdirs();
+
+            if(!f.exists()) {
+                if(dir != null && !dir.exists()) {
+                    if (!dir.mkdirs()) {
+                        promise.reject("EUNSPECIFIED", "Failed to create parent directory of '" + path + "'");
+                        return;
+                    }
+                }
+                if(!f.createNewFile()) {
+                    promise.reject("ENOENT", "File '" + path + "' does not exist and could not be created");
+                    return;
+                }
+            }
+
             FileOutputStream fout = new FileOutputStream(f, append);
             // write data from a file
             if(encoding.equalsIgnoreCase(RNFetchBlobConst.DATA_ENCODE_URI)) {
-                data = normalizePath(data);
-                File src = new File(data);
-                if(!src.exists()) {
-                    promise.reject("RNfetchBlob writeFileError", "source file : " + data + "not exists");
+                String normalizedData = normalizePath(data);
+                File src = new File(normalizedData);
+                if (!src.exists()) {
+                    promise.reject("ENOENT", "No such file '" + path + "' " + "('" + normalizedData + "')");
                     fout.close();
-                    return ;
+                    return;
                 }
                 FileInputStream fin = new FileInputStream(src);
-                byte [] buffer = new byte [10240];
+                byte[] buffer = new byte [10240];
                 int read;
                 written = 0;
                 while((read = fin.read(buffer)) > 0) {
             }
             fout.close();
             promise.resolve(written);
+        } catch (FileNotFoundException e) {
+            // According to https://docs.oracle.com/javase/7/docs/api/java/io/FileOutputStream.html
+            promise.reject("ENOENT", "File '" + path + "' does not exist and could not be created, or it is a directory");
         } catch (Exception e) {
-            promise.reject("RNFetchBlob writeFileError", e.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", e.getLocalizedMessage());
         }
     }
 
      * @param data Array passed from JS context.
      * @param promise RCT Promise
      */
-    static public void writeFile(String path, ReadableArray data, final boolean append, final Promise promise) {
-
+    static void writeFile(String path, ReadableArray data, final boolean append, final Promise promise) {
         try {
-
             File f = new File(path);
             File dir = f.getParentFile();
-            if(!dir.exists())
-                dir.mkdirs();
+
+            if(!f.exists()) {
+                if(dir != null && !dir.exists()) {
+                    if (!dir.mkdirs()) {
+                        promise.reject("ENOTDIR", "Failed to create parent directory of '" + path + "'");
+                        return;
+                    }
+                }
+                if(!f.createNewFile()) {
+                    promise.reject("ENOENT", "File '" + path + "' does not exist and could not be created");
+                    return;
+                }
+            }
+
             FileOutputStream os = new FileOutputStream(f, append);
-            byte [] bytes = new byte[data.size()];
+            byte[] bytes = new byte[data.size()];
             for(int i=0;i<data.size();i++) {
                 bytes[i] = (byte) data.getInt(i);
             }
             os.write(bytes);
             os.close();
             promise.resolve(data.size());
+        } catch (FileNotFoundException e) {
+            // According to https://docs.oracle.com/javase/7/docs/api/java/io/FileOutputStream.html
+            promise.reject("ENOENT", "File '" + path + "' does not exist and could not be created");
         } catch (Exception e) {
-            promise.reject("RNFetchBlob writeFileError", e.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", e.getLocalizedMessage());
         }
     }
 
      * Read file with a buffer that has the same size as the target file.
      * @param path  Path of the file.
      * @param encoding  Encoding of read stream.
-     * @param promise
+     * @param promise  JS promise
      */
-    static public void readFile(String path, String encoding, final Promise promise ) {
+    static void readFile(String path, String encoding, final Promise promise) {
         String resolved = normalizePath(path);
         if(resolved != null)
             path = resolved;
         try {
             byte[] bytes;
+            int bytesRead;
+            int length;  // max. array length limited to "int", also see https://stackoverflow.com/a/10787175/544779
 
             if(resolved != null && resolved.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
                 String assetName = path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
-                long length = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
-                bytes = new byte[(int) length];
+                // This fails should an asset file be >2GB
+                length = (int) RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
+                bytes = new byte[length];
                 InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
-                in.read(bytes, 0, (int) length);
+                bytesRead = in.read(bytes, 0, length);
                 in.close();
             }
             // issue 287
             else if(resolved == null) {
                 InputStream in = RNFetchBlob.RCTContext.getContentResolver().openInputStream(Uri.parse(path));
-                int length = (int) in.available();
+                // TODO See https://developer.android.com/reference/java/io/InputStream.html#available()
+                // Quote: "Note that while some implementations of InputStream will return the total number of bytes
+                // in the stream, many will not. It is never correct to use the return value of this method to
+                // allocate a buffer intended to hold all data in this stream."
+                length = in.available();
                 bytes = new byte[length];
-                in.read(bytes);
+                bytesRead = in.read(bytes);
                 in.close();
             }
             else {
                 File f = new File(path);
-                int length = (int) f.length();
+                length = (int) f.length();
                 bytes = new byte[length];
                 FileInputStream in = new FileInputStream(f);
-                in.read(bytes);
+                bytesRead = in.read(bytes);
                 in.close();
             }
 
+            if (bytesRead < length) {
+                promise.reject("EUNSPECIFIED", "Read only " + bytesRead + " bytes of " + length);
+                return;
+            }
+
             switch (encoding.toLowerCase()) {
                 case "base64" :
                     promise.resolve(Base64.encodeToString(bytes, Base64.NO_WRAP));
                     break;
                 case "ascii" :
                     WritableArray asciiResult = Arguments.createArray();
-                    for(byte b : bytes) {
-                        asciiResult.pushInt((int)b);
+                    for (byte b : bytes) {
+                        asciiResult.pushInt((int) b);
                     }
                     promise.resolve(asciiResult);
                     break;
                     break;
             }
         }
+        catch(FileNotFoundException err) {
+            String msg = err.getLocalizedMessage();
+            if (msg.contains("EISDIR")) {
+                promise.reject("EISDIR", "Expecting a file but '" + path + "' is a directory; " +  msg);
+            } else {
+                promise.reject("ENOENT", "No such file '" + path + "'; " + msg);
+            }
+        }
         catch(Exception err) {
-            promise.reject("ReadFile Error", err.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", err.getLocalizedMessage());
         }
 
     }
      * Static method that returns system folders to JS context
      * @param ctx   React Native application context
      */
-    static public Map<String, Object> getSystemfolders(ReactApplicationContext ctx) {
+    static Map<String, Object> getSystemfolders(ReactApplicationContext ctx) {
         Map<String, Object> res = new HashMap<>();
 
         res.put("DocumentDir", ctx.getFilesDir().getAbsolutePath());
 
     /**
      * Static method that returns a temp file path
-     * @param ctx   React Native application context
      * @param taskId    An unique string for identify
-     * @return
+     * @return String
      */
-    static public String getTmpPath(ReactApplicationContext ctx, String taskId) {
+    static String getTmpPath(String taskId) {
         return RNFetchBlob.RCTContext.getFilesDir() + "/RNFetchBlobTmp_" + taskId;
     }
 
      * @param encoding  File stream decoder, should be one of `base64`, `utf8`, `ascii`
      * @param bufferSize    Buffer size of read stream, default to 4096 (4095 when encode is `base64`)
      */
-    public void readStream(String path, String encoding, int bufferSize, int tick, final String streamId) {
+    void readStream(String path, String encoding, int bufferSize, int tick, final String streamId) {
         String resolved = normalizePath(path);
         if(resolved != null)
             path = resolved;
-        try {
 
+        try {
             int chunkSize = encoding.equalsIgnoreCase("base64") ? 4095 : 4096;
             if(bufferSize > 0)
                 chunkSize = bufferSize;
 
             if(resolved != null && path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
                 fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
-
             }
             // fix issue 287
             else if(resolved == null) {
             } else if (encoding.equalsIgnoreCase("base64")) {
                 while ((cursor = fs.read(buffer)) != -1) {
                     if(cursor < chunkSize) {
-                        byte [] copy = new byte[cursor];
-                        for(int i =0;i<cursor;i++) {
-                            copy[i] = buffer[i];
-                        }
+                        byte[] copy = new byte[cursor];
+                        System.arraycopy(buffer, 0, copy, 0, cursor);
                         emitStreamEvent(streamId, "data", Base64.encodeToString(copy, Base64.NO_WRAP));
                     }
                     else
                         SystemClock.sleep(tick);
                 }
             } else {
-                String msg = "unrecognized encoding `" + encoding + "`";
-                emitStreamEvent(streamId, "error", msg);
+                emitStreamEvent(
+                        streamId,
+                        "error",
+                        "EINVAL",
+                        "Unrecognized encoding `" + encoding + "`, should be one of `base64`, `utf8`, `ascii`"
+                );
                 error = true;
             }
 
                 emitStreamEvent(streamId, "end", "");
             fs.close();
             buffer = null;
-
+        } catch (FileNotFoundException err) {
+            emitStreamEvent(
+                    streamId,
+                    "error",
+                    "ENOENT",
+                    "No such file '" + path + "'"
+            );
         } catch (Exception err) {
-            emitStreamEvent(streamId, "warn", "Failed to convert data to "+encoding+" encoded string, this might due to the source data is not able to convert using this encoding.");
+            emitStreamEvent(
+                    streamId,
+                    "error",
+                    "EUNSPECIFIED",
+                    "Failed to convert data to " + encoding + " encoded string. This might be because this encoding cannot be used for this data."
+            );
             err.printStackTrace();
         }
     }
     /**
      * Create a write stream and store its instance in RNFetchBlobFS.fileStreams
      * @param path  Target file path
-     * @param encoding Should be one of `base64`, `utf8`, `ascii`
-     * @param append    Flag represents if the file stream overwrite existing content
-     * @param callback
+     * @param encoding  Should be one of `base64`, `utf8`, `ascii`
+     * @param append  Flag represents if the file stream overwrite existing content
+     * @param callback  Callback
      */
-    public void writeStream(String path, String encoding, boolean append, Callback callback) {
-        File dest = new File(path);
-        if(!dest.exists() || dest.isDirectory()) {
-            callback.invoke("write stream error: target path `" + path + "` may not exists or it's a folder");
-            return;
-        }
+    void writeStream(String path, String encoding, boolean append, Callback callback) {
         try {
+            File dest = new File(path);
+            File dir = dest.getParentFile();
+
+            if(!dest.exists()) {
+                if(dir != null && !dir.exists()) {
+                    if (!dir.mkdirs()) {
+                        callback.invoke("ENOTDIR", "Failed to create parent directory of '" + path + "'");
+                        return;
+                    }
+                }
+                if(!dest.createNewFile()) {
+                    callback.invoke("ENOENT", "File '" + path + "' does not exist and could not be created");
+                    return;
+                }
+            } else if(dest.isDirectory()) {
+                callback.invoke("EISDIR", "Expecting a file but '" + path + "' is a directory");
+                return;
+            }
+
             OutputStream fs = new FileOutputStream(path, append);
             this.encoding = encoding;
-            this.append = append;
             String streamId = UUID.randomUUID().toString();
             RNFetchBlobFS.fileStreams.put(streamId, this);
             this.writeStreamInstance = fs;
-            callback.invoke(null, streamId);
+            callback.invoke(null, null, streamId);
         } catch(Exception err) {
-            callback.invoke("write stream error: failed to create write stream at path `"+path+"` "+ err.getLocalizedMessage());
+            callback.invoke("EUNSPECIFIED", "Failed to create write stream at path `" + path + "`; " + err.getLocalizedMessage());
         }
-
     }
 
     /**
      * @param callback JS context callback
      */
     static void writeChunk(String streamId, String data, Callback callback) {
-
         RNFetchBlobFS fs = fileStreams.get(streamId);
         OutputStream stream = fs.writeStreamInstance;
-        byte [] chunk = RNFetchBlobFS.stringToBytes(data, fs.encoding);
-
+        byte[] chunk = RNFetchBlobFS.stringToBytes(data, fs.encoding);
         try {
             stream.write(chunk);
             callback.invoke();
      * @param callback JS context callback
      */
     static void writeArrayChunk(String streamId, ReadableArray data, Callback callback) {
-
         try {
             RNFetchBlobFS fs = fileStreams.get(streamId);
             OutputStream stream = fs.writeStreamInstance;
-            byte [] chunk = new byte[data.size()];
+            byte[] chunk = new byte[data.size()];
             for(int i =0; i< data.size();i++) {
                 chunk[i] = (byte) data.getInt(i);
             }
             RNFetchBlobFS.deleteRecursive(new File(path));
             callback.invoke(null, true);
         } catch(Exception err) {
-            if(err != null)
             callback.invoke(err.getLocalizedMessage(), false);
         }
     }
 
-    static void deleteRecursive(File fileOrDirectory) {
-
+    private static void deleteRecursive(File fileOrDirectory) throws IOException {
         if (fileOrDirectory.isDirectory()) {
-            for (File child : fileOrDirectory.listFiles()) {
-                deleteRecursive(child);
+            File[] files = fileOrDirectory.listFiles();
+            if (files == null) {
+                throw new NullPointerException("Received null trying to list files of directory '" + fileOrDirectory + "'");
+            } else {
+                for (File child : files) {
+                    deleteRecursive(child);
+                }
             }
         }
-        fileOrDirectory.delete();
+        boolean result = fileOrDirectory.delete();
+        if (!result) {
+            throw new IOException("Failed to delete '" + fileOrDirectory + "'");
+        }
     }
 
     /**
      * Make a folder
-     * @param path Source path
-     * @param callback  JS context callback
+     * @param path  Source path
+     * @param promise  JS promise
      */
-    static void mkdir(String path, Callback callback) {
+    static void mkdir(String path, Promise promise) {
         File dest = new File(path);
         if(dest.exists()) {
-            callback.invoke("mkdir error: failed to create folder at `" + path + "` folder already exists");
+            promise.reject("EEXIST", dest.isDirectory() ? "Folder" : "File" + " '" + path + "' already exists");
             return;
         }
-        dest.mkdirs();
-        callback.invoke();
+        try {
+            boolean result = dest.mkdirs();
+            if (!result) {
+                promise.reject("EUNSPECIFIED", "mkdir failed to create some or all directories in '" + path + "'");
+                return;
+            }
+        } catch (Exception e) {
+            promise.reject("EUNSPECIFIED", e.getLocalizedMessage());
+            return;
+        }
+        promise.resolve(true);
     }
+
     /**
      * Copy file to destination path
      * @param path Source path
      * @param callback  JS context callback
      */
     static void cp(String path, String dest, Callback callback) {
-
         path = normalizePath(path);
         InputStream in = null;
         OutputStream out = null;
 
         try {
-
             if(!isPathExists(path)) {
-                callback.invoke("cp error: source file at path`" + path + "` not exists");
+                callback.invoke("Source file at path`" + path + "` does not exist");
                 return;
             }
-            if(!new File(dest).exists())
-                new File(dest).createNewFile();
+            if(!new File(dest).exists()) {
+                boolean result = new File(dest).createNewFile();
+                if (!result) {
+                    callback.invoke("Destination file at '" + dest + "' already exists");
+                    return;
+                }
+            }
 
             in = inputStreamFromPath(path);
             out = new FileOutputStream(dest);
             while ((len = in.read(buf)) > 0) {
                 out.write(buf, 0, len);
             }
-
         } catch (Exception err) {
             callback.invoke(err.getLocalizedMessage());
         } finally {
     static void mv(String path, String dest, Callback callback) {
         File src = new File(path);
         if(!src.exists()) {
-            callback.invoke("mv error: source file at path `" + path + "` does not exists");
+            callback.invoke("Source file at path `" + path + "` does not exist");
+            return;
+        }
+        try {
+            boolean result = src.renameTo(new File(dest));
+            if (!result) {
+                callback.invoke("mv failed for unknown reasons");
+                return;
+            }
+        } catch (Exception e) {
+            callback.invoke(e.getLocalizedMessage());
             return;
         }
-        src.renameTo(new File(dest));
         callback.invoke();
     }
 
      * @param callback  JS context callback
      */
     static void exists(String path, Callback callback) {
-
         if(isAsset(path)) {
             try {
                 String filename = path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
-                AssetFileDescriptor fd = RNFetchBlob.RCTContext.getAssets().openFd(filename);
+                com.RNFetchBlob.RNFetchBlob.RCTContext.getAssets().openFd(filename);
                 callback.invoke(true, false);
             } catch (IOException e) {
                 callback.invoke(false, false);
      * @param path Target folder
      * @param callback  JS context callback
      */
-    static void ls(String path, Callback callback) {
-        path = normalizePath(path);
-        File src = new File(path);
-        if (!src.exists() || !src.isDirectory()) {
-            callback.invoke("ls error: failed to list path `" + path + "` for it is not exist or it is not a folder");
-            return;
-        }
-        String[] files = new File(path).list();
-        WritableArray arg = Arguments.createArray();
-        for (String i : files) {
-            arg.pushString(i);
+    static void ls(String path, Promise promise) {
+        try {
+            path = normalizePath(path);
+            File src = new File(path);
+            if (!src.exists()) {
+                promise.reject("ENOENT", "No such file '" + path + "'");
+                return;
+            }
+            if (!src.isDirectory()) {
+                promise.reject("ENOTDIR", "Not a directory '" + path + "'");
+                return;
+            }
+            String[] files = new File(path).list();
+            WritableArray arg = Arguments.createArray();
+            // File => list(): "If this abstract pathname does not denote a directory, then this method returns null."
+            // We excluded that possibility above - ignore the "can produce NullPointerException" warning of the IDE.
+            for (String i : files) {
+                arg.pushString(i);
+            }
+            promise.resolve(arg);
+        } catch (Exception e) {
+            e.printStackTrace();
+            promise.reject("EUNSPECIFIED", e.getLocalizedMessage());
         }
-        callback.invoke(null, arg);
     }
 
     /**
      * Create a file by slicing given file path
-     * @param src   Source file path
+     * @param path   Source file path
      * @param dest  Destination of created file
      * @param start Start byte offset in source file
      * @param end   End byte offset
      * @param encode NOT IMPLEMENTED
      */
-    public static void slice(String src, String dest, int start, int end, String encode, Promise promise) {
+    static void slice(String path, String dest, int start, int end, String encode, Promise promise) {
         try {
-            src = normalizePath(src);
-            File source = new File(src);
-            if(!source.exists()) {
-                promise.reject("RNFetchBlob.slice error", "source file : " + src + " not exists");
+            path = normalizePath(path);
+            File source = new File(path);
+            if(source.isDirectory()){
+                promise.reject("EISDIR", "Expecting a file but '" + path + "' is a directory");
                 return;
             }
-            long size = source.length();
-            long max = Math.min(size, end);
-            long expected = max - start;
-            long now = 0;
-            FileInputStream in = new FileInputStream(new File(src));
+            if(!source.exists()){
+                promise.reject("ENOENT", "No such file '" + path + "'");
+                return;
+            }
+            int size = (int) source.length();
+            int max = Math.min(size, end);
+            int expected = max - start;
+            int now = 0;
+            FileInputStream in = new FileInputStream(new File(path));
             FileOutputStream out = new FileOutputStream(new File(dest));
-            in.skip(start);
-            byte [] buffer = new byte[10240];
+            int skipped = (int) in.skip(start);
+            if (skipped != start) {
+                promise.reject("EUNSPECIFIED", "Skipped " + skipped + " instead of the specified " + start + " bytes, size is " + size);
+                return;
+            }
+            byte[] buffer = new byte[10240];
             while(now < expected) {
-                long read = in.read(buffer, 0, 10240);
-                long remain = expected - now;
+                int read = in.read(buffer, 0, 10240);
+                int remain = expected - now;
                 if(read <= 0) {
                     break;
                 }
             promise.resolve(dest);
         } catch (Exception e) {
             e.printStackTrace();
-            promise.reject(e.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", e.getLocalizedMessage());
         }
     }
 
             protected Integer doInBackground(String ...args) {
                 WritableArray res = Arguments.createArray();
                 if(args[0] == null) {
-                    callback.invoke("lstat error: the path specified for lstat is either `null` or `undefined`.");
+                    callback.invoke("the path specified for lstat is either `null` or `undefined`.");
                     return 0;
                 }
                 File src = new File(args[0]);
                 if(!src.exists()) {
-                    callback.invoke("lstat error: failed to list path `" + args[0] + "` for it is not exist or it is not a folder");
+                    callback.invoke("failed to lstat path `" + args[0] + "` because it does not exist or it is not a folder");
                     return 0;
                 }
                 if(src.isDirectory()) {
                     String [] files = src.list();
+                    // File => list(): "If this abstract pathname does not denote a directory, then this method returns null."
+                    // We excluded that possibility above - ignore the "can produce NullPointerException" warning of the IDE.
                     for(String p : files) {
-                        res.pushMap(statFile ( src.getPath() + "/" + p));
+                        res.pushMap(statFile(src.getPath() + "/" + p));
                     }
                 }
                 else {
 
     /**
      * show status of a file or directory
-     * @param path
-     * @param callback
+     * @param path  Path
+     * @param callback  Callback
      */
     static void stat(String path, Callback callback) {
         try {
             path = normalizePath(path);
             WritableMap result = statFile(path);
             if(result == null)
-                callback.invoke("stat error: failed to list path `" + path + "` for it is not exist or it is not a folder", null);
+                callback.invoke("failed to stat path `" + path + "` because it does not exist or it is not a folder", null);
             else
                 callback.invoke(null, result);
         } catch(Exception err) {
 
     /**
      * Basic stat method
-     * @param path
-     * @return Stat result of a file or path
+     * @param path  Path
+     * @return Stat  Result of a file or path
      */
     static WritableMap statFile(String path) {
         try {
 
     /**
      * Media scanner scan file
-     * @param path
-     * @param mimes
-     * @param callback
+     * @param path  Path to file
+     * @param mimes  Array of MIME type strings
+     * @param callback  Callback for results
      */
     void scanFile(String [] path, String[] mimes, final Callback callback) {
         try {
         }
     }
 
+    static void hash(String path, String algorithm, Promise promise) {
+        try {
+            Map<String, String> algorithms = new HashMap<>();
+
+            algorithms.put("md5", "MD5");
+            algorithms.put("sha1", "SHA-1");
+            algorithms.put("sha224", "SHA-224");
+            algorithms.put("sha256", "SHA-256");
+            algorithms.put("sha384", "SHA-384");
+            algorithms.put("sha512", "SHA-512");
+
+            if (!algorithms.containsKey(algorithm)) {
+                promise.reject("EINVAL", "Invalid algorithm '" + algorithm + "', must be one of md5, sha1, sha224, sha256, sha384, sha512");
+                return;
+            }
+
+            File file = new File(path);
+
+            if (file.isDirectory()) {
+                promise.reject("EISDIR", "Expecting a file but '" + path + "' is a directory");
+                return;
+            }
+
+            if (!file.exists()) {
+                promise.reject("ENOENT", "No such file '" + path + "'");
+                return;
+            }
+
+            MessageDigest md = MessageDigest.getInstance(algorithms.get(algorithm));
+
+            FileInputStream inputStream = new FileInputStream(path);
+            byte[] buffer = new byte[(int)file.length()];
+
+            int read;
+            while ((read = inputStream.read(buffer)) != -1) {
+                md.update(buffer, 0, read);
+            }
+
+            StringBuilder hexString = new StringBuilder();
+            for (byte digestByte : md.digest())
+                hexString.append(String.format("%02x", digestByte));
+
+            promise.resolve(hexString.toString());
+        } catch (Exception e) {
+            e.printStackTrace();
+            promise.reject("EUNSPECIFIED", e.getLocalizedMessage());
+        }
+    }
+
     /**
      * Create new file at path
      * @param path The destination path of the new file.
      * @param data Initial data of the new file.
      * @param encoding Encoding of initial data.
-     * @param callback RCT bridge callback.
+     * @param promise Promise for Javascript
      */
-    static void createFile(String path, String data, String encoding, Callback callback) {
+    static void createFile(String path, String data, String encoding, Promise promise) {
         try {
             File dest = new File(path);
             boolean created = dest.createNewFile();
                 String orgPath = data.replace(RNFetchBlobConst.FILE_PREFIX, "");
                 File src = new File(orgPath);
                 if(!src.exists()) {
-                    callback.invoke("RNfetchBlob writeFileError", "source file : " + data + "not exists");
+                    promise.reject("ENOENT", "Source file : " + data + " does not exist");
                     return ;
                 }
                 FileInputStream fin = new FileInputStream(src);
                 OutputStream ostream = new FileOutputStream(dest);
-                byte [] buffer = new byte [10240];
+                byte[] buffer = new byte[10240];
                 int read = fin.read(buffer);
-                while(read > 0) {
+                while (read > 0) {
                     ostream.write(buffer, 0, read);
                     read = fin.read(buffer);
                 }
                 fin.close();
                 ostream.close();
-            }
-            else {
+            } else {
                 if (!created) {
-                    callback.invoke("create file error: failed to create file at path `" + path + "` for its parent path may not exists, or the file already exists. If you intended to overwrite the existing file use fs.writeFile instead.");
+                    promise.reject("EEXIST", "File `" + path + "` already exists");
                     return;
                 }
                 OutputStream ostream = new FileOutputStream(dest);
                 ostream.write(RNFetchBlobFS.stringToBytes(data, encoding));
             }
-            callback.invoke(null, path);
+            promise.resolve(path);
         } catch(Exception err) {
-            callback.invoke(err.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", err.getLocalizedMessage());
         }
     }
 
      * Create file for ASCII encoding
      * @param path  Path of new file.
      * @param data  Content of new file
-     * @param callback  JS context callback
+     * @param promise  JS Promise
      */
-    static void createFileASCII(String path, ReadableArray data, Callback callback) {
+    static void createFileASCII(String path, ReadableArray data, Promise promise) {
         try {
             File dest = new File(path);
-            if(dest.exists()) {
-                callback.invoke("create file error: failed to create file at path `" + path + "`, file already exists.");
-                return;
-            }
             boolean created = dest.createNewFile();
             if(!created) {
-                callback.invoke("create file error: failed to create file at path `" + path + "` for its parent path may not exists");
+                promise.reject("EEXIST", "File at path `" + path + "` already exists");
                 return;
             }
             OutputStream ostream = new FileOutputStream(dest);
-            byte [] chunk = new byte[data.size()];
-            for(int i =0; i<data.size();i++) {
+            byte[] chunk = new byte[data.size()];
+            for(int i=0; i<data.size(); i++) {
                 chunk[i] = (byte) data.getInt(i);
             }
             ostream.write(chunk);
-            chunk = null;
-            callback.invoke(null, path);
+            promise.resolve(path);
         } catch(Exception err) {
-            callback.invoke(err.getLocalizedMessage());
+            promise.reject("EUNSPECIFIED", err.getLocalizedMessage());
         }
     }
 
      * @param callback JS contest callback
      */
     static void removeSession(ReadableArray paths, final Callback callback) {
-
         AsyncTask<ReadableArray, Integer, Integer> task = new AsyncTask<ReadableArray, Integer, Integer>() {
             @Override
             protected Integer doInBackground(ReadableArray ...paths) {
                 try {
+                    ArrayList<String> failuresToDelete = new ArrayList<>();
                     for (int i = 0; i < paths[0].size(); i++) {
-                        File f = new File(paths[0].getString(i));
-                        if (f.exists())
-                            f.delete();
+                        String fileName = paths[0].getString(i);
+                        File f = new File(fileName);
+                        if (f.exists()) {
+                            boolean result = f.delete();
+                            if (!result) {
+                                failuresToDelete.add(fileName);
+                            }
+                        }
+                    }
+                    if (failuresToDelete.isEmpty()) {
+                        callback.invoke(null, true);
+                    } else {
+                        StringBuilder listString = new StringBuilder();
+                        listString.append("Failed to delete: ");
+                        for (String s : failuresToDelete) {
+                            listString.append(s).append(", ");
+                        }
+                        callback.invoke(listString.toString());
                     }
-                    callback.invoke(null, true);
                 } catch(Exception err) {
                     callback.invoke(err.getLocalizedMessage());
                 }
         this.emitter.emit(streamName, eventData);
     }
 
+    // "event" always is "data"...
     private void emitStreamEvent(String streamName, String event, WritableArray data) {
         WritableMap eventData = Arguments.createMap();
         eventData.putString("event", event);
         this.emitter.emit(streamName, eventData);
     }
 
-    // TODO : should we remove this ?
-    void emitFSData(String taskId, String event, String data) {
+    // "event" always is "error"...
+    private void emitStreamEvent(String streamName, String event, String code, String message) {
         WritableMap eventData = Arguments.createMap();
         eventData.putString("event", event);
-        eventData.putString("detail", data);
-        this.emitter.emit("RNFetchBlobStream" + taskId, eventData);
+        eventData.putString("code", code);
+        eventData.putString("detail", message);
+        this.emitter.emit(streamName, eventData);
     }
 
     /**
      * the stream is created by Assets Manager, otherwise use FileInputStream.
      * @param path The file to open stream
      * @return InputStream instance
-     * @throws IOException
+     * @throws IOException If the given file does not exist or is a directory FileInputStream will throw a FileNotFoundException
      */
-    static InputStream inputStreamFromPath(String path) throws IOException {
+    private static InputStream inputStreamFromPath(String path) throws IOException {
         if (path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
             return RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
         }
      * @param path A file path URI string
      * @return A boolean value represents if the path exists.
      */
-    static boolean isPathExists(String path) {
+    private static boolean isPathExists(String path) {
         if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
             try {
-                RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
+                RNFetchBlob.RCTContext.getAssets().open(path.replace(com.RNFetchBlob.RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
             } catch (IOException e) {
                 return false;
             }
     }
 
     static boolean isAsset(String path) {
-        if(path != null)
-            return path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET);
-        return false;
+        return path != null && path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET);
     }
 
     /**

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;
             // 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);
                             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);

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,
-    get SDCardDir() {
-      console.warn('SDCardDir as a constant is deprecated and will be removed in feature release. ' +
-                   'Use RNFetchBlob.android.getSDCardDir():Promise instead.');
-      return RNFetchBlob.SDCardDir;
-    },
-    get SDCardApplicationDir() {
-      console.warn('SDCardApplicationDir as a constant is deprecated and will be removed in feature release. ' +
-                   'Use RNFetchBlob.android.getSDCardApplicationDir():Promise instead. ' +
-                   'This variable can be empty on error in native code.');
-      return 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,
+  get SDCardDir() {
+    console.warn('SDCardDir as a constant is deprecated and will be removed in feature release. ' +
+                 'Use RNFetchBlob.android.getSDCardDir():Promise instead.');
+    return RNFetchBlob.SDCardDir;
+  },
+  get SDCardApplicationDir() {
+    console.warn('SDCardApplicationDir as a constant is deprecated and will be removed in feature release. ' +
+                 'Use RNFetchBlob.android.getSDCardApplicationDir():Promise instead. ' +
+                 'This variable can be empty on error in native code.');
+    return RNFetchBlob.SDCardApplicationDir;
+  },
+  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'
  * @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/RNFetchBlob.m

 }
 
 #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)
 {
       });
         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", @"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/RNFetchBlobFS.h

 // 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/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);

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/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}`
       }
     }