Change native network module logic and improve Android fs performance

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

 import com.facebook.react.bridge.ReadableMap;
 
 import java.util.Map;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
     static ReactApplicationContext RCTContext;
+    static LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
+    static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
 
     }
 
     @ReactMethod
-    public void createFile(String path, String content, String encode, Callback callback) {
-        RNFetchBlobFS.createFile(path, content, encode, callback);
+    public void createFile(final String path, final String content, final String encode, final Callback callback) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.createFile(path, content, encode, callback);
+            }
+        });
+
     }
 
     @ReactMethod
-    public void createFileASCII(String path, ReadableArray dataArray, Callback callback) {
-        RNFetchBlobFS.createFileASCII(path, dataArray, callback);
+    public void createFileASCII(final String path, final ReadableArray dataArray, final Callback callback) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.createFileASCII(path, dataArray, callback);
+            }
+        });
+
     }
 
     @ReactMethod
-    public void writeArrayChunk(String streamId, ReadableArray dataArray, Callback callback) {
+    public void writeArrayChunk(final String streamId, final ReadableArray dataArray, final Callback callback) {
         RNFetchBlobFS.writeArrayChunk(streamId, dataArray, callback);
     }
 
     }
 
     @ReactMethod
-    public void cp(String path, String dest, Callback callback) {
-        RNFetchBlobFS.cp(path, dest, callback);
+    public void cp(final String path, final String dest, final Callback callback) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.cp(path, dest, callback);
+            }
+        });
+
     }
 
     @ReactMethod
     }
 
     @ReactMethod
-    public void readFile(String path, String encoding, Promise promise) {
-        RNFetchBlobFS.readFile(path, encoding, promise);
+    public void readFile(final String path, final String encoding, final Promise promise) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.readFile(path, encoding, promise);
+            }
+        });
     }
 
     @ReactMethod
-    public void writeFileArray(String path, ReadableArray data, boolean append, Promise promise) {
-        RNFetchBlobFS.writeFile(path, data, append, promise);
+    public void writeFileArray(final String path, final ReadableArray data, final boolean append, final Promise promise) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.writeFile(path, data, append, promise);
+            }
+        });
     }
 
     @ReactMethod
-    public void writeFile(String path, String encoding, String data, boolean append, Promise promise) {
-        RNFetchBlobFS.writeFile(path, encoding, data, append, promise);
+    public void writeFile(final String path, final String encoding, final String data, final boolean append, final Promise promise) {
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                RNFetchBlobFS.writeFile(path, encoding, data, append, promise);
+            }
+        });
+
     }
 
     @ReactMethod
     }
 
     @ReactMethod
-    public void scanFile(ReadableArray pairs, Callback callback) {
-        int size = pairs.size();
-        String [] p = new String[size];
-        String [] m = new String[size];
-        for(int i=0;i<size;i++) {
-            ReadableMap pair = pairs.getMap(i);
-            if(pair.hasKey("path")) {
-                p[i] = pair.getString("path");
-                if(pair.hasKey("mime"))
-                    m[i] = pair.getString("mime");
-                else
-                    m[i] = null;
+    public void scanFile(final ReadableArray pairs, final Callback callback) {
+        final ReactApplicationContext ctx = this.getReactApplicationContext();
+        threadPool.execute(new Runnable() {
+            @Override
+            public void run() {
+                int size = pairs.size();
+                String [] p = new String[size];
+                String [] m = new String[size];
+                for(int i=0;i<size;i++) {
+                    ReadableMap pair = pairs.getMap(i);
+                    if(pair.hasKey("path")) {
+                        p[i] = pair.getString("path");
+                        if(pair.hasKey("mime"))
+                            m[i] = pair.getString("mime");
+                        else
+                            m[i] = null;
+                    }
+                }
+                new RNFetchBlobFS(ctx).scanFile(p, m, callback);
             }
-        }
-        new RNFetchBlobFS(this.getReactApplicationContext()).scanFile(p, m, callback);
+        });
+
     }
 
     @ReactMethod

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

     public static final String EVENT_PROGRESS = "RNFetchBlobProgress";
     public static final String EVENT_HTTP_STATE = "RNFetchBlobState";
     public static final String FILE_PREFIX = "RNFetchBlob-file://";
-    public static final MediaType MIME_OCTET = MediaType.parse("application/octet-stream");
-    public static final MediaType MIME_MULTIPART = MediaType.parse("multipart/form-data");
-	public static final MediaType MIME_ENCODED = MediaType.parse("application/x-www-form-urlencoded");
     public static final String FILE_PREFIX_BUNDLE_ASSET = "bundle-assets://";
     public static final String FILE_PREFIX_CONTENT = "content://";
     public static final String DATA_ENCODE_URI = "uri";
-    public static final String DATA_ENCODE_BASE64 = "base64";
-    public static final String DATA_ENCODE_UTF8 = "utf8";
+    public static final String RNFB_RESPONSE_BASE64 = "base64";
+    public static final String RNFB_RESPONSE_UTF8  = "utf8";
+    public static final String RNFB_RESPONSE_PATH  = "path";
+
 }

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

 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
+import java.util.concurrent.BlockingDeque;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Created by wkh237 on 2016/5/26.
      * @param promise
      */
     static public void writeFile(String path, String encoding, String data, final boolean append, final Promise promise) {
-        AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
-            @Override
-            protected Integer doInBackground(String... args) {
-                try {
-                    String path = args[0];
-                    String encoding = args[1];
-                    String data = args[2];
-                    int written = 0;
-                    File f = new File(path);
-                    File dir = f.getParentFile();
-                    if(!dir.exists())
-                        dir.mkdirs();
-                    FileOutputStream fout = new FileOutputStream(f, append);
-                    // write data from a file
-                    if(encoding.equalsIgnoreCase(RNFetchBlobConst.DATA_ENCODE_URI)) {
-                        File src = new File(data);
-                        if(!src.exists()) {
-                            promise.reject("RNfetchBlob writeFileError", "source file : " + data + "not exists");
-                            fout.close();
-                            return null;
-                        }
-                        FileInputStream fin = new FileInputStream(src);
-                        byte [] buffer = new byte [10240];
-                        int read;
-                        written = 0;
-                        while((read = fin.read(buffer)) > 0) {
-                            fout.write(buffer, 0, read);
-                            written += read;
-                        }
-                        fin.close();
-                    }
-                    else {
-                        byte[] bytes = stringToBytes(data, encoding);
-                        fout.write(bytes);
-                        written = bytes.length;
-                    }
+        try {
+            int written = 0;
+            File f = new File(path);
+            File dir = f.getParentFile();
+            if(!dir.exists())
+                dir.mkdirs();
+            FileOutputStream fout = new FileOutputStream(f, append);
+            // write data from a file
+            if(encoding.equalsIgnoreCase(RNFetchBlobConst.DATA_ENCODE_URI)) {
+                File src = new File(data);
+                if(!src.exists()) {
+                    promise.reject("RNfetchBlob writeFileError", "source file : " + data + "not exists");
                     fout.close();
-                    promise.resolve(written);
-                } catch (Exception e) {
-                    promise.reject("RNFetchBlob writeFileError", e.getLocalizedMessage());
+                    return ;
                 }
-                return null;
+                FileInputStream fin = new FileInputStream(src);
+                byte [] buffer = new byte [10240];
+                int read;
+                written = 0;
+                while((read = fin.read(buffer)) > 0) {
+                    fout.write(buffer, 0, read);
+                    written += read;
+                }
+                fin.close();
             }
-        };
-        task.execute(path, encoding, data);
+            else {
+                byte[] bytes = stringToBytes(data, encoding);
+                fout.write(bytes);
+                written = bytes.length;
+            }
+            fout.close();
+            promise.resolve(written);
+        } catch (Exception e) {
+            promise.reject("RNFetchBlob writeFileError", e.getLocalizedMessage());
+        }
     }
 
     /**
      * @param promise
      */
     static public void writeFile(String path, ReadableArray data, final boolean append, final Promise promise) {
-        AsyncTask<Object, Void, Void> task = new AsyncTask<Object, Void, Void>() {
-            @Override
-            protected Void doInBackground(Object... args) {
-                try {
-                    String path = (String)args[0];
-                    ReadableArray data = (ReadableArray) args[1];
-                    File f = new File(path);
-                    File dir = f.getParentFile();
-                    if(!dir.exists())
-                        dir.mkdirs();
-                    FileOutputStream os = new FileOutputStream(f, append);
-                    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 (Exception e) {
-                    promise.reject("RNFetchBlob writeFileError", e.getLocalizedMessage());
-                }
-                return null;
+
+        try {
+
+            File f = new File(path);
+            File dir = f.getParentFile();
+            if(!dir.exists())
+                dir.mkdirs();
+            FileOutputStream os = new FileOutputStream(f, append);
+            byte [] bytes = new byte[data.size()];
+            for(int i=0;i<data.size();i++) {
+                bytes[i] = (byte) data.getInt(i);
             }
-        };
-        task.execute(path, data);
+            os.write(bytes);
+            os.close();
+            promise.resolve(data.size());
+        } catch (Exception e) {
+            promise.reject("RNFetchBlob writeFileError", e.getLocalizedMessage());
+        }
     }
 
     /**
      */
     static public void readFile(String path, String encoding, final Promise promise ) {
         path = normalizePath(path);
-        AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
-            @Override
-            protected Integer doInBackground(String... strings) {
-
-                try {
-                    String path = strings[0];
-                    String encoding = strings[1];
-                    byte[] bytes;
-
-                    if(path.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];
-                        InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
-                        in.read(bytes, 0, (int) length);
-                        in.close();
-                    }
-                    else {
-                        File f = new File(path);
-                        int length = (int) f.length();
-                        bytes = new byte[length];
-                        FileInputStream in = new FileInputStream(f);
-                        in.read(bytes);
-                        in.close();
-                    }
+        try {
+            byte[] bytes;
+
+            if(path.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];
+                InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
+                in.read(bytes, 0, (int) length);
+                in.close();
+            }
+            else {
+                File f = new File(path);
+                int length = (int) f.length();
+                bytes = new byte[length];
+                FileInputStream in = new FileInputStream(f);
+                in.read(bytes);
+                in.close();
+            }
 
-                    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);
-                            }
-                            promise.resolve(asciiResult);
-                            break;
-                        case "utf8" :
-                            promise.resolve(new String(bytes));
-                            break;
-                        default:
-                            promise.resolve(new String(bytes));
-                            break;
+            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);
                     }
-                }
-                catch(Exception err) {
-                    promise.reject("ReadFile Error", err.getLocalizedMessage());
-                }
-                return null;
+                    promise.resolve(asciiResult);
+                    break;
+                case "utf8" :
+                    promise.resolve(new String(bytes));
+                    break;
+                default:
+                    promise.resolve(new String(bytes));
+                    break;
             }
-        };
-        task.execute(path, encoding);
+        }
+        catch(Exception err) {
+            promise.reject("ReadFile Error", err.getLocalizedMessage());
+        }
+
     }
 
     /**
      */
     static void writeArrayChunk(String streamId, ReadableArray data, Callback callback) {
 
-        RNFetchBlobFS fs = fileStreams.get(streamId);
-        OutputStream stream = fs.writeStreamInstance;
-        byte [] chunk = new byte[data.size()];
-        for(int i =0; i< data.size();i++) {
-            chunk[i] = (byte) data.getInt(i);
-        }
         try {
+            RNFetchBlobFS fs = fileStreams.get(streamId);
+            OutputStream stream = fs.writeStreamInstance;
+            byte [] chunk = new byte[data.size()];
+            for(int i =0; i< data.size();i++) {
+                chunk[i] = (byte) data.getInt(i);
+            }
             stream.write(chunk);
             callback.invoke();
-            chunk = null;
         } catch (Exception e) {
             callback.invoke(e.getLocalizedMessage());
         }
         }
         else if(encoding.toLowerCase().contains("base64")) {
             byte [] b = Base64.decode(data, Base64.NO_WRAP);
-            if(encoding.toLowerCase().contains("urlencode")) {
-                try {
-                    String encoded = URLDecoder.decode(new String(b), "UTF-8");
-                    b = encoded.getBytes();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
             return b;
         }
         else if(encoding.equalsIgnoreCase("utf8")) {

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

 import android.database.Cursor;
 import android.net.Uri;
 import android.util.Base64;
-import android.util.Log;
 
 import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
 import com.RNFetchBlob.Response.RNFetchBlobFileResp;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
-import java.io.ByteArrayInputStream;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.CharBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
-import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 import java.util.HashMap;
 import java.util.concurrent.TimeUnit;
 import okhttp3.RequestBody;
 import okhttp3.Response;
 import okhttp3.ResponseBody;
-import okhttp3.FormBody;
-import okhttp3.internal.framed.Header;
-import okhttp3.internal.http.OkHeaders;
 
 /**
  * Created by wkh237 on 2016/6/21.
                     // check if this error caused by socket timeout
                     if(e.getClass().equals(SocketTimeoutException.class)) {
                         respInfo.putBoolean("timeout", true);
-                        callback.invoke("request timed out.", respInfo, null);
+                        callback.invoke("request timed out.", null, null);
                     }
                     else
-                        callback.invoke(e.getLocalizedMessage(), respInfo, null);
+                        callback.invoke(e.getLocalizedMessage(), null, null);
                     removeTaskInfo();
                 }
 
                         ins.close();
                         os.flush();
                         os.close();
-                        callback.invoke(null, null, dest);
+                        callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, dest);
                     }
+                    // response data directly pass to JS context as string.
                     else {
                         // #73 Check if the response data contains valid UTF8 string, since BASE64
                         // encoding will somehow break the UTF8 string format, to encode UTF8
                         CharsetEncoder encoder = Charset.forName("UTF-8").newEncoder();
                         try {
                             encoder.encode(ByteBuffer.wrap(b).asCharBuffer());
-                            // if the data can be encoded to UTF8 append URL encode
-                            b = URLEncoder.encode(new String(b), "UTF-8").replace("+", "%20").getBytes();
+                            // if the data contains invalid characters the following lines will be
+                            // skipped.
+                            String utf8 = new String(b);
+                            callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_UTF8, utf8);
                         }
                         // This usually mean the data is contains invalid unicode characters, it's
                         // binary data
-                        catch(CharacterCodingException ignored) {}
-                        finally {
-                            callback.invoke(null, null, android.util.Base64.encodeToString(b, Base64.NO_WRAP));
+                        catch(CharacterCodingException ignored) {
+                            callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_BASE64, android.util.Base64.encodeToString(b, Base64.NO_WRAP));
                         }
                     }
                 } catch (IOException e) {
                     // and write response data to destination path.
                     resp.body().bytes();
                 } catch (Exception ignored) {}
-                callback.invoke(null, null, this.destPath);
+                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 break;
             default:
                 try {
-                    callback.invoke(null, null, new String(resp.body().bytes(), "UTF-8"));
+                    callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_UTF8, new String(resp.body().bytes(), "UTF-8"));
                 } catch (IOException e) {
                     callback.invoke("RNFetchBlob failed to encode response data to UTF8 string.", null);
                 }
         return uploadProgressReport.get(taskId);
     }
 
+    /**
+     * Create response information object, conatins status code, headers, etc.
+     * @param resp
+     * @param isBlobResp
+     * @return
+     */
     private WritableMap getResponseInfo(Response resp, boolean isBlobResp) {
         WritableMap info = Arguments.createMap();
         info.putInt("status", resp.code());
         return info;
     }
 
+    /**
+     * Check if response data is binary data.
+     * @param resp OkHttp response.
+     * @return
+     */
     private boolean isBlobResponse(Response resp) {
         Headers h = resp.headers();
         String ctype = getHeaderIgnoreCases(h, "Content-Type");

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

 package com.RNFetchBlob.Response;
 
 import com.RNFetchBlob.RNFetchBlob;
+import com.RNFetchBlob.RNFetchBlobConst;
 import com.RNFetchBlob.RNFetchBlobReq;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
                 args.putString("written", String.valueOf(bytesRead));
                 args.putString("total", String.valueOf(contentLength()));
                 rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                        .emit("RNFetchBlobProgress", args);
+                        .emit(RNFetchBlobConst.EVENT_PROGRESS, args);
             }
             return read;
         }

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

 
 import android.util.Log;
 
+import com.RNFetchBlob.RNFetchBlobConst;
 import com.RNFetchBlob.RNFetchBlobReq;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
                 args.putString("written", String.valueOf(bytesDownloaded));
                 args.putString("total", String.valueOf(contentLength()));
                 rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                        .emit("RNFetchBlobProgress", args);
+                        .emit(RNFetchBlobConst.EVENT_PROGRESS, args);
             }
             return read;
         }

src/index.js

  *                   If it exists, the absolute path is returned (no network
  *                   activity takes place )
  *                   If it doesn't exist, the file is downloaded as usual
+ *         @property {number} timeout
+ *                   Request timeout in millionseconds, by default it's 30000ms.
  *
  * @return {function} This method returns a `fetch` method instance.
  */
 
     let req = RNFetchBlob[nativeMethodName]
 
-    req(options, taskId, method, url, headers || {}, body, (err, unsused, data) => {
+    /**
+     * Send request via native module, the response callback accepts three arguments
+     * @callback
+     * @param err {any} Error message or object, when the request success, this
+     *                  parameter should be `null`.
+     * @param rawType { 'utf8' | 'base64' | 'path'} RNFB request will be stored
+     *                  as UTF8 string, BASE64 string, or a file path reference
+     *                  in JS context, and this parameter indicates which one
+     *                  dose the response data presents.
+     * @param data {string} Response data or its reference.
+     */
+    req(options, taskId, method, url, headers || {}, body, (err, rawType, data) => {
 
-      // task done, remove event listener
+      // task done, remove event listeners
       subscription.remove()
       subscriptionUpload.remove()
       stateEvent.remove()
       if(err)
         reject(new Error(err, respInfo))
       else {
-        let rnfbEncode = 'base64'
-        // response data is saved to storage
+        // response data is saved to storage, create a session for it
         if(options.path || options.fileCache || options.addAndroidDownloads
           || options.key || options.auto && respInfo.respType === 'blob') {
-          rnfbEncode = 'path'
           if(options.session)
             session(options.session).add(data)
         }
-        respInfo.rnfbEncode = rnfbEncode
+        respInfo.rnfbEncode = rawType
         resolve(new FetchBlobResponse(taskId, respInfo, data))
       }
 
 
   taskId : string;
   path : () => string | null;
-  type : 'base64' | 'path';
+  type : 'base64' | 'path' | 'utf8';
   data : any;
   blob : (contentType:string, sliceSize:number) => null;
   text : () => string;
      * @return {Promise<Blob>} Return a promise resolves Blob object.
      */
     this.blob = ():Promise<Blob> => {
+      let Blob = polyfill.Blob
+      let cType = info.headers['Content-Type'] || info.headers['content-type']
       return new Promise((resolve, reject) => {
-        if(this.type === 'base64') {
-          try {
-            let b = new polyfill.Blob(this.data, 'application/octet-stream;BASE64')
-            b.onCreated(() => {
-              resolve(b)
-            })
-          } catch(err) {
-            reject(err)
-          }
-        }
-        else {
-          polyfill.Blob.build(wrap(this.data))
-          .then((b) => {
-            resolve(b)
-          })
+        switch(this.type) {
+          case 'base64':
+            Blob.build(this.data, { type : cType + ';BASE64' }).then(resolve)
+          break
+          case 'path':
+            polyfill.Blob.build(wrap(this.data), { type : cType }).then(resolve)
+          break
+          default:
+            polyfill.Blob.build(this.data, { type : 'text/plain' }).then(resolve)
+          break
         }
       })
     }
      */
     this.text = ():string => {
       let res = this.data
-      try {
-        res = base64.decode(this.data)
-        res = decodeURIComponent(res)
-      } catch(err) {
-        console.warn(err)
-        res = ''
+      switch(this.type) {
+        case 'base64':
+          return base64.decode(this.data)
+        break
+        case 'path':
+          return fs.readFile(this.data, 'utf8')
+        break
+        default:
+          return this.data
+        break
       }
-      return res
     }
     /**
      * Convert result to JSON object.
      * @return {object} Parsed javascript object.
      */
     this.json = ():any => {
-      let res = this.data
-      try {
-        res = base64.decode(this.data)
-        res = decodeURIComponent(res)
-        res = JSON.parse(res)
-      } catch(err) {
-        console.warn(err)
-        res = {}
+      switch(this.type) {
+        case 'base64':
+          return JSON.parse(base64.decode(this.data))
+        break
+        case 'path':
+          return fs.readFile(this.data, 'utf8')
+                   .then((text) => Promise.resolve(JSON.parse(text)))
+        break
+        default:
+          return JSON.parse(this.data)
+        break
       }
-      return res
     }
     /**
      * Return BASE64 string directly.
      * @return {string} BASE64 string of response body.
      */
     this.base64 = ():string => {
-      return this.data
+      switch(this.type) {
+        case 'base64':
+          return this.data
+        break
+        case 'path':
+          return fs.readFile(this.data, 'base64')
+        break
+        default:
+          return base64.encode(this.data)
+        break
+      }
     }
     /**
      * Remove cahced file
      */
     this.flush = () => {
       let path = this.path()
-      if(!path)
+      if(!path || this.type !== 'path')
         return
       return unlink(path)
     }
         return this.data
       return null
     }
+
     this.session = (name:string):RNFetchBlobSession | null => {
       if(this.type === 'path')
         return session(name).add(this.data)

src/ios/RNFetchBlobConst.h

 extern NSString *const KEY_REPORT_PROGRESS;
 extern NSString *const KEY_REPORT_UPLOAD_PROGRESS;
 
+// response type
+extern NSString *const RESP_TYPE_BASE64;
+extern NSString *const RESP_TYPE_UTF8;
+extern NSString *const RESP_TYPE_PATH;
+
 
 
 #endif /* RNFetchBlobConst_h */

src/ios/RNFetchBlobConst.m

 
 extern NSString *const KEY_REPORT_PROGRESS = @"reportProgress";
 extern NSString *const KEY_REPORT_UPLOAD_PROGRESS = @"reportUploadProgress";
+
+// response type
+extern NSString *const RESP_TYPE_BASE64 = @"base64";
+extern NSString *const RESP_TYPE_UTF8 = @"utf8";
+extern NSString *const RESP_TYPE_PATH = @"path";

src/ios/RNFetchBlobNetwork.m

     self.error = error;
     NSString * errMsg = [NSNull null];
     NSString * respStr = [NSNull null];
+    NSString * rnfbRespType = @"";
     
     [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
     
         if(respFile == YES)
         {
             [writeStream close];
+            rnfbRespType = RESP_TYPE_PATH;
             respStr = destPath;
         }
         // base64 response
             // when response type is BASE64, we should first try to encode the response data to UTF8 format
             // if it turns out not to be `nil` that means the response data contains valid UTF8 string,
             // in order to properly encode the UTF8 string, use URL encoding before BASE64 encoding.
-            NSString * urlEncoded = [[[NSString alloc] initWithData:respData encoding:NSUTF8StringEncoding]
-                                     stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLQueryAllowedCharacterSet]];
-            NSString * base64 = @"";
-            if(urlEncoded != nil)
-                base64 = [[urlEncoded dataUsingEncoding:NSUTF8StringEncoding] base64EncodedStringWithOptions:0];
+            NSString * utf8 = [[NSString alloc] initWithData:respData encoding:NSUTF8StringEncoding];
+            
+            if(utf8 != nil)
+            {
+                rnfbRespType = RESP_TYPE_UTF8;
+                respStr = utf8;
+            }
             else
-                base64 = [respData base64EncodedStringWithOptions:0];
-            respStr = base64;
+            {
+                rnfbRespType = RESP_TYPE_BASE64;
+                respStr = [respData base64EncodedStringWithOptions:0];
+            }
             
         }
     }
     
-    callback(@[ errMsg, respInfo, respStr ]);
+    callback(@[ errMsg, rnfbRespType, respStr]);
     
     @synchronized(taskTable, uploadProgressTable, progressTable)
     {

src/polyfill/Blob.js

       // when content type contains application/octet* or *;base64, RNFetchBlob
       // fs will treat it as BASE64 encoded string binary data
       if(/(application\/octet|\;base64)/i.test(mime))
-        encoding = 'base64+urlencode'
+        encoding = 'base64'
       else
         data = data.toString()
       // create cache file

src/polyfill/Fetch.js

       return Promise.resolve(resp.text())
       break
     case 'path':
-      return resp.readFile('utf8').then((data) => {
-        return Promise.resolve(data)
-      })
+      return resp.text()
       break
     default:
       return Promise.resolve(resp.text())
  */
 function readBlob(resp, info):Promise<Blob> {
   log.verbose('readBlob', resp, info)
-  let cType = info.headers['Content-Type']
-  switch (info.rnfbEncode) {
-    case 'base64':
-      return Blob.build(resp.data, { type : `${cType};BASE64` })
-    case 'path':
-      return Blob.build(RNFetchBlob.wrap(resp.data), { type : `${cType}`})
-    default:
-      return Blob.build(resp.data, { type : `${cType}`})
-  }
+  return resp.blob()
 }
 
 /**
     case 'base64':
       return Promise.resolve(resp.json())
     case 'path':
-      return resp.readFile('utf8').then((data) => {
-        return Promise.resolve(JSON.parse(data))
-      })
+      return resp.json()
     default:
-      return Promise.resolve(JSON.parse(resp.data))
+      return Promise.resolve(resp.json())
   }
 }

src/polyfill/XMLHttpRequest.js

 
 const log = new Log('XMLHttpRequest')
 
-log.level(0)
+log.level(2)
 
 const UNSENT = 0
 const OPENED = 1
   }
 
   _headerReceived(e) {
-    log.verbose('header received ', this._task.taskId, e)
+    log.debug('header received ', this._task.taskId, e)
     this.responseURL = this._url
     if(e.state === "2") {
       this._responseHeaders = e.headers
     if(statusCode >= 100 && statusCode !== 408) {
       return
     }
-    log.verbose('XMLHttpRequest error', err)
+    log.debug('XMLHttpRequest error', err)
     this._statusText = err
     this._status = String(err).match(/\d+/)
     this._status = this._status ? Math.floor(this.status) : 404
   }
 
   _onDone(resp) {
-    log.verbose('XMLHttpRequest done', this._url, resp)
+    log.debug('XMLHttpRequest done', this._url, resp, this)
     this._statusText = this._status
+    let responseDataReady = () => {
+      this.dispatchEvent('load')
+      this.dispatchEvent('loadend')
+      this._dispatchReadStateChange(XMLHttpRequest.DONE)
+      this.clearEventListeners()
+    }
     if(resp) {
-      switch(resp.type) {
-        case 'base64' :
-          if(this._responseType === 'json') {
-              this._responseText = resp.text()
-              this._response = resp.json()
-          }
-          else {
-            this._responseText = resp.text()
-            this._response = this.responseText
-          }
+      let info = resp.respInfo || {}
+      switch(info.respType) {
+        case 'json' :
+          this._response = resp.json()
+          responseDataReady()
         break;
-        case 'path' :
-          this.response = resp.blob()
+        case 'blob' :
+          resp.blob().then((b) => {
+            this.response = b
+            responseDataReady()
+          })
         break;
         default :
           this._responseText = resp.text()
           this._response = this.responseText
+          responseDataReady()
         break;
       }
-      this.dispatchEvent('load')
-      this.dispatchEvent('loadend')
-      this._dispatchReadStateChange(XMLHttpRequest.DONE)
     }
-    this.clearEventListeners()
+
   }
 
   _dispatchReadStateChange(state) {