Change Android HTTP library to OkHttp #25, implement Android upload progress #49

src/android/build.gradle

@@ -35,4 +35,5 @@ android {
 dependencies {
     compile 'com.facebook.react:react-native:+'
     compile 'com.loopj.android:android-async-http:1.4.9'
+    compile 'com.squareup.okhttp3:okhttp:3.4.1'
 }

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

@@ -152,12 +152,12 @@ public class RNFetchBlob extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void fetchBlob(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
-        new RNFetchBlobReq(this.getReactApplicationContext(), options, taskId, method, url, headers, body, callback).run();
+        new RNFetchBlobReq(options, taskId, method, url, headers, body, null, callback).run();
     }
 
     @ReactMethod
     public void fetchBlobForm(ReadableMap options, String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
-        new RNFetchBlobReq(this.getReactApplicationContext(), options, taskId, method, url, headers, body, callback).run();
+        new RNFetchBlobReq(options, taskId, method, url, headers, null, body, callback).run();
     }
 
 }

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

@@ -1,55 +0,0 @@
-package com.RNFetchBlob;
-
-import com.facebook.react.bridge.Callback;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.loopj.android.http.AsyncHttpResponseHandler;
-import com.loopj.android.http.Base64;
-import com.loopj.android.http.FileAsyncHttpResponseHandler;
-
-import java.io.File;
-
-import cz.msebera.android.httpclient.Header;
-
-public class RNFetchBlobBinaryHandler extends AsyncHttpResponseHandler {
-
-    Callback onResponse;
-    ReactContext mCtx;
-    String mTaskId;
-
-    RNFetchBlobBinaryHandler(ReactContext ctx, String taskId, Callback onResponse) {
-
-        this.onResponse = onResponse;
-        this.mTaskId = taskId;
-        this.mCtx = ctx;
-    }
-
-    @Override
-    public void onSuccess(int statusCode, Header[] headers, byte[] binaryData) {
-        String value = Base64.encodeToString(binaryData, Base64.NO_WRAP);
-        this.onResponse.invoke(null, value);
-    }
-
-    @Override
-    public void onProgress(long bytesWritten, long totalSize) {
-        super.onProgress(bytesWritten, totalSize);
-
-        // on progress, emit RNFetchBlobProgress event with ticketId, bytesWritten, and totalSize
-        WritableMap args = Arguments.createMap();
-        args.putString("taskId", this.mTaskId);
-        args.putString("written", String.valueOf(bytesWritten));
-        args.putString("total", String.valueOf(totalSize));
-
-        // emit event to js context
-        this.mCtx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit("RNFetchBlobProgress", args);
-    }
-
-    @Override
-    public void onFailure(final int statusCode, final Header[] headers, byte[] binaryData, final Throwable error) {
-        this.onResponse.invoke(statusCode, error.getMessage()+ ", "+ error.getCause());
-    }
-
-}

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

@@ -0,0 +1,95 @@
+package com.RNFetchBlob;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.ForwardingSink;
+import okio.Okio;
+import okio.Sink;
+
+/**
+ * Created by wkh237on 2016/7/11.
+ */
+public class RNFetchBlobBody extends RequestBody{
+
+    InputStream requestStream;
+    long contentLength;
+    RequestBody originalBody;
+    String mTaskId;
+    RNFetchBlobReq.RequestType requestType;
+
+    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, RequestBody body, InputStream stream, long size) {
+        this.mTaskId = taskId;
+        originalBody = body;
+        requestStream = stream;
+        contentLength = size;
+        requestType = type;
+    }
+
+    @Override
+    public MediaType contentType() {
+        return originalBody.contentType();
+    }
+
+    @Override
+    public void writeTo(BufferedSink sink) throws IOException {
+
+        ProgressReportingSource source = new ProgressReportingSource(sink, mTaskId, contentLength());
+        BufferedSink buffer = Okio.buffer(source);
+        switch (requestType) {
+            case Form:
+                originalBody.writeTo(buffer);
+                break;
+            case SingleFile:
+                byte [] chunk = new byte[10240];
+                int cursor = requestStream.read(chunk, 0, 10240);
+                while(cursor > 0) {
+                    cursor = requestStream.read(chunk, 0, 10240);
+                    buffer.write(chunk);
+                }
+                requestStream.close();
+                break;
+            case Others:
+                originalBody.writeTo(buffer);
+                break;
+        }
+        buffer.flush();
+    }
+
+    private final class ProgressReportingSource extends ForwardingSink {
+
+        private long bytesWritten = 0;
+        private String mTaskId;
+        private long mContentLength ;
+
+        public ProgressReportingSource (Sink delegate, String taskId, long contentLength) {
+            super(delegate);
+            this.mTaskId = taskId;
+            this.mContentLength = contentLength;
+        }
+
+        @Override
+        public void write(Buffer source, long byteCount) throws IOException {
+            super.write(source, byteCount);
+            // on progress, emit RNFetchBlobProgress upload progress event with ticketId,
+            // bytesWritten, and totalSize
+            bytesWritten += byteCount;
+            WritableMap args = Arguments.createMap();
+            args.putString("taskId", mTaskId);
+            args.putString("written", String.valueOf(bytesWritten));
+            args.putString("total", String.valueOf(mContentLength ));
+
+            // emit event to js context
+            RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+        }
+    }
+}

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

@@ -15,6 +15,7 @@ public class RNFetchBlobConfig {
     public ReadableMap addAndroidDownloads;
     public Boolean trusty;
     public String key;
+    public String mime;
 
     RNFetchBlobConfig(ReadableMap options) {
         if(options == null)
@@ -27,6 +28,7 @@ public class RNFetchBlobConfig {
             this.addAndroidDownloads = options.getMap("addAndroidDownloads");
         }
         this.key = options.hasKey("key") ? options.getString("key") : null;
+        this.mime = options.hasKey("contentType") ? options.getString("contentType") : null;
     }
 
 }

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

@@ -0,0 +1,17 @@
+package com.RNFetchBlob;
+
+import okhttp3.MediaType;
+
+/**
+ * Created by wkh237 on 2016/7/11.
+ */
+public class RNFetchBlobConst {
+    public static final String EVENT_UPLOAD_PROGRESS = "RNFetchBlobProgress-upload";
+    public static final String EVENT_PROGRESS = "RNFetchBlobProgress";
+    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 String FILE_PREFIX_BUNDLE_ASSET = "bundle-assets://";
+    public static final String FILE_PREFIX_CONTENT = "content://";
+
+}

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

@@ -1,10 +1,7 @@
 package com.RNFetchBlob;
 
-import android.app.Application;
 import android.content.CursorLoader;
-import android.content.Intent;
 import android.content.res.AssetFileDescriptor;
-import android.content.res.AssetManager;
 import android.database.Cursor;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
@@ -17,7 +14,6 @@ import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
@@ -25,21 +21,14 @@ import com.loopj.android.http.Base64;
 
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.io.OutputStreamWriter;
 import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
-import java.util.concurrent.ExecutionException;
-
-import cz.msebera.android.httpclient.util.EncodingUtils;
 
 /**
  * Created by wkh237 on 2016/5/26.
@@ -49,7 +38,6 @@ public class RNFetchBlobFS {
     ReactApplicationContext mCtx;
     DeviceEventManagerModule.RCTDeviceEventEmitter emitter;
     String encoding = "base64";
-    static final String assetPrefix = "bundle-assets://";
     boolean append = false;
     OutputStream writeStreamInstance = null;
     static HashMap<String, RNFetchBlobFS> fileStreams = new HashMap<>();
@@ -151,8 +139,8 @@ public class RNFetchBlobFS {
                     String encoding = strings[1];
                     byte[] bytes;
 
-                    if(path.startsWith(assetPrefix)) {
-                        String assetName = path.replace(assetPrefix, "");
+                    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);
@@ -245,8 +233,8 @@ public class RNFetchBlobFS {
                         chunkSize = bufferSize;
 
                     InputStream fs;
-                    if(path.startsWith(assetPrefix)) {
-                        fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(assetPrefix, ""));
+                    if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
+                        fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
                     }
                     else {
                         fs = new FileInputStream(new File(path));
@@ -486,7 +474,7 @@ public class RNFetchBlobFS {
         path = normalizePath(path);
         if(isAsset(path)) {
             try {
-                String filename = path.replace(assetPrefix, "");
+                String filename = path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
                 AssetFileDescriptor fd = RNFetchBlob.RCTContext.getAssets().openFd(filename);
                 callback.invoke(true, false);
             } catch (IOException e) {
@@ -575,7 +563,7 @@ public class RNFetchBlobFS {
             path = normalizePath(path);
             WritableMap stat = Arguments.createMap();
             if(isAsset(path)) {
-                String name = path.replace(assetPrefix, "");
+                String name = path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
                 AssetFileDescriptor fd = RNFetchBlob.RCTContext.getAssets().openFd(name);
                 stat.putString("filename", name);
                 stat.putString("path", path);
@@ -756,8 +744,8 @@ public class RNFetchBlobFS {
      * @throws IOException
      */
     static InputStream inputStreamFromPath(String path) throws IOException {
-        if (path.startsWith(assetPrefix)) {
-            return RNFetchBlob.RCTContext.getAssets().open(path.replace(assetPrefix, ""));
+        if (path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
+            return RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
         }
         return new FileInputStream(new File(path));
     }
@@ -768,9 +756,9 @@ public class RNFetchBlobFS {
      * @return
      */
     static boolean isPathExists(String path) {
-        if(path.startsWith(assetPrefix)) {
+        if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
             try {
-                RNFetchBlob.RCTContext.getAssets().open(path.replace(assetPrefix, ""));
+                RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
             } catch (IOException e) {
                 return false;
             }
@@ -782,15 +770,15 @@ public class RNFetchBlobFS {
 
     }
 
-    static boolean isAsset(String path) {
-        return path.startsWith(assetPrefix);
+    public static boolean isAsset(String path) {
+        return path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET);
     }
 
-    static String normalizePath(String path) {
-        if(path.startsWith(assetPrefix)) {
+    public static String normalizePath(String path) {
+        if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
             return path;
         }
-        else if (path.startsWith("content://")) {
+        else if (path.startsWith(RNFetchBlobConst.FILE_PREFIX_CONTENT)) {
             String[] proj = { MediaStore.Images.Media.DATA };
             Uri contentUri = Uri.parse(path);
             CursorLoader loader = new CursorLoader(RNFetchBlob.RCTContext, contentUri, proj, null, null, null);

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

@@ -1,95 +0,0 @@
-package com.RNFetchBlob;
-
-import android.app.DownloadManager;
-import android.content.Context;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.Callback;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.loopj.android.http.FileAsyncHttpResponseHandler;
-
-import java.io.File;
-
-import cz.msebera.android.httpclient.Header;
-
-/**
- * Created by wkh237 on 2016/5/26.
- */
-public class RNFetchBlobFileHandler extends FileAsyncHttpResponseHandler {
-
-    public boolean isValid;
-    Callback onResponse;
-    ReactContext mCtx;
-    String mTaskId;
-    RNFetchBlobConfig mConfig;
-
-    RNFetchBlobFileHandler(ReactApplicationContext ctx, String taskId, String key, RNFetchBlobConfig config, Callback onResponse) {
-        super(new File( RNFetchBlobFileHandler.getFilePath(ctx, taskId, key, config)), false, false);
-        this.onResponse = onResponse;
-        this.mTaskId = taskId;
-        this.mConfig = config;
-        this.mCtx = ctx;
-        if(!new File(RNFetchBlobFileHandler.getFilePath(ctx, taskId, key, config)).isFile()) {
-            this.isValid = false;
-        }
-        this.isValid = true;
-    }
-
-    static String getFilePath(ReactApplicationContext ctx, String taskId, String key, RNFetchBlobConfig config) {
-        if(config.path != null)
-            return config.path;
-        else if(config.fileCache && config.appendExt != null)
-            return RNFetchBlobFS.getTmpPath(ctx, key) + "." + config.appendExt;
-        else
-            return RNFetchBlobFS.getTmpPath(ctx, key);
-    }
-
-    @Override
-    public void onFailure(int statusCode, Header[] headers, Throwable throwable, File file) {
-        this.onResponse.invoke(statusCode, throwable.getMessage()+ ", "+ throwable.getCause());
-    }
-
-    @Override
-    public void onProgress(long bytesWritten, long totalSize) {
-        super.onProgress(bytesWritten, totalSize);
-
-        // on progress, emit RNFetchBlobProgress event with ticketId, bytesWritten, and totalSize
-        WritableMap args = Arguments.createMap();
-        args.putString("taskId", this.mTaskId);
-        args.putString("written", String.valueOf(bytesWritten));
-        args.putString("total", String.valueOf(totalSize));
-
-        // emit event to js context
-        this.mCtx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit("RNFetchBlobProgress", args);
-    }
-
-    @Override
-    public void onSuccess(int statusCode, Header[] headers, File file) {
-        ReadableMap notifyConfig = mConfig.addAndroidDownloads;
-
-        // Download manager settings
-        if(notifyConfig != null ) {
-            String title = "", desc = "", mime = "text/plain";
-            boolean scannable = false, notification = false;
-            if(notifyConfig.hasKey("title"))
-                title = mConfig.addAndroidDownloads.getString("title");
-            if(notifyConfig.hasKey("description"))
-                desc = notifyConfig.getString("description");
-            if(notifyConfig.hasKey("mime"))
-                mime = notifyConfig.getString("mime");
-            if(notifyConfig.hasKey("mediaScannable"))
-                scannable = notifyConfig.getBoolean("mediaScannable");
-            if(notifyConfig.hasKey("notification"))
-                notification = notifyConfig.getBoolean("notification");
-            DownloadManager dm = (DownloadManager)mCtx.getSystemService(mCtx.DOWNLOAD_SERVICE);
-            dm.addCompletedDownload(title, desc, scannable, mime, file.getAbsolutePath(), file.length(), notification);
-        }
-
-        this.onResponse.invoke(null, file.getAbsolutePath());
-    }
-}

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

@@ -8,114 +8,102 @@ import android.content.IntentFilter;
 import android.database.Cursor;
 import android.net.Uri;
 
+import com.RNFetchBlob.Request.FormPartBody;
+import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
+import com.RNFetchBlob.Response.RNFetchBlobFileResp;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.loopj.android.http.AsyncHttpClient;
-import com.loopj.android.http.AsyncHttpResponseHandler;
 import com.loopj.android.http.Base64;
-import com.loopj.android.http.MySSLSocketFactory;
 
+import java.io.ByteArrayInputStream;
 import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
-import java.security.KeyStore;
-import java.security.MessageDigest;
 
-import cz.msebera.android.httpclient.HttpEntity;
-import cz.msebera.android.httpclient.entity.ByteArrayEntity;
-import cz.msebera.android.httpclient.entity.ContentType;
-import cz.msebera.android.httpclient.entity.FileEntity;
-import cz.msebera.android.httpclient.entity.mime.MultipartEntityBuilder;
+import okhttp3.Call;
+import okhttp3.Interceptor;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
 
 /**
  * Created by wkh237 on 2016/6/21.
  */
 public class RNFetchBlobReq extends BroadcastReceiver implements Runnable {
 
-    final String filePathPrefix = "RNFetchBlob-file://";
+    enum RequestType  {
+        Form,
+        SingleFile,
+        Others
+    };
+
+    enum ResponseType {
+        MemoryCache,
+        FileCache
+    };
+
+    MediaType contentType = RNFetchBlobConst.MIME_OCTET;
     ReactApplicationContext ctx;
     RNFetchBlobConfig options;
     String taskId;
     String method;
     String url;
-    String boundary;
+    String rawRequestBody;
+    String destPath;
+    ReadableArray rawRequestBodyArray;
     ReadableMap headers;
     Callback callback;
-    HttpEntity entity;
+    long contentLength;
     long downloadManagerId;
-    AsyncHttpClient req;
-    String type;
+    RequestType requestType;
+    ResponseType responseType;
 
-    public RNFetchBlobReq(ReactApplicationContext ctx, ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
-        this.ctx = ctx;
+    public RNFetchBlobReq(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, ReadableArray arrayBody, final Callback callback) {
         this.method = method;
-        this.options= new RNFetchBlobConfig(options);
+        this.options = new RNFetchBlobConfig(options);
         this.taskId = taskId;
         this.url = url;
         this.headers = headers;
         this.callback = callback;
-        this.req = new AsyncHttpClient();
-        if(body != null) {
-            type = "octet";
-            buildEntity(body);
-        }
-    }
-
-    public RNFetchBlobReq(ReactApplicationContext ctx, ReadableMap options, String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
-        this.ctx = ctx;
-        this.method = method;
-        this.options= new RNFetchBlobConfig(options);
-        this.taskId = taskId;
-        this.url = url;
-        this.headers = headers;
-        this.callback = callback;
-        this.req = new AsyncHttpClient();
-        if(body != null) {
-            type = "form";
-            buildFormEntity(body);
-        }
-    }
-
-    public static String getMD5(String input) {
-        String result = null;
-
-        try {
-            MessageDigest md = MessageDigest.getInstance("MD5");
-            md.update(input.getBytes());
-            byte[] digest = md.digest();
-            
-            StringBuffer sb = new StringBuffer();
-            
-            for (byte b : digest) {
-                sb.append(String.format("%02x", b & 0xff));
-            }
-
-            result = sb.toString();
-        } catch(Exception ex) {
-            ex.printStackTrace();
-        }
-
-        return result;
+        this.rawRequestBody = body;
+        this.rawRequestBodyArray = arrayBody;
+
+        if(this.options.fileCache != null || this.options.path != null)
+            responseType = ResponseType.FileCache;
+        else
+            responseType = ResponseType.MemoryCache;
+
+        if (body != null)
+            requestType = RequestType.SingleFile;
+        else if (arrayBody != null)
+            requestType = RequestType.Form;
+        else
+            requestType = RequestType.Others;
     }
 
     @Override
     public void run() {
 
         // use download manager instead of default HTTP implementation
-        if(options.addAndroidDownloads != null && options.addAndroidDownloads.hasKey("useDownloadManager")) {
+        if (options.addAndroidDownloads != null && options.addAndroidDownloads.hasKey("useDownloadManager")) {
 
-            if(options.addAndroidDownloads.getBoolean("useDownloadManager")) {
+            if (options.addAndroidDownloads.getBoolean("useDownloadManager")) {
                 Uri uri = Uri.parse(url);
                 DownloadManager.Request req = new DownloadManager.Request(uri);
                 req.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
 
-                if(options.addAndroidDownloads.hasKey("title")) {
+                if (options.addAndroidDownloads.hasKey("title")) {
                     req.setTitle(options.addAndroidDownloads.getString("title"));
                 }
-                if(options.addAndroidDownloads.hasKey("description")) {
+                if (options.addAndroidDownloads.hasKey("description")) {
                     req.setDescription(options.addAndroidDownloads.getString("description"));
                 }
                 // set headers
@@ -132,186 +120,244 @@ public class RNFetchBlobReq extends BroadcastReceiver implements Runnable {
 
         }
 
+        // find cached result if `key` property exists
         String cacheKey = this.taskId;
         if (this.options.key != null) {
-            cacheKey = RNFetchBlobReq.getMD5(this.options.key);
+            cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
             if (cacheKey == null) {
                 cacheKey = this.taskId;
             }
 
-            File file = new File(RNFetchBlobFileHandler.getFilePath(ctx, taskId, cacheKey, this.options));
+            File file = new File(RNFetchBlobFS.getTmpPath(ctx, cacheKey));
             if (file.exists()) {
-               callback.invoke(null, file.getAbsolutePath());
-               return;
+                callback.invoke(null, file.getAbsolutePath());
+                return;
             }
         }
 
-        try {
-
-            req = new AsyncHttpClient();
+        if(this.options.path != null)
+            destPath = this.options.path;
+        else if(this.options.fileCache)
+            destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey);
 
-            req.setLoggingEnabled(false);
+        OkHttpClient client;
+        try {
 
             // use trusty SSL socket
-            if(this.options.trusty) {
-                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
-                trustStore.load(null, null);
-                MySSLSocketFactory sf = new MySSLSocketFactory(trustStore);
-                sf.setHostnameVerifier(MySSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
-                req.setSSLSocketFactory(sf);
+            if (this.options.trusty) {
+                client = RNFetchBlobUtils.getUnsafeOkHttpClient();
+            } else {
+                client = new OkHttpClient();
             }
 
+            final Request.Builder builder = new Request.Builder();
+
             // set headers
-            if(headers != null) {
+            if (headers != null) {
                 ReadableMapKeySetIterator it = headers.keySetIterator();
                 while (it.hasNextKey()) {
                     String key = it.nextKey();
-                    req.addHeader(key, headers.getString(key));
+                    builder.addHeader(key, headers.getString(key));
                 }
             }
 
-            if(type != null)
-            {
-                if(type == "octet")
-                    req.addHeader("Content-Type", "application/octet-stream");
-                else if(type == "form")
-                    req.addHeader("Content-Type", "multipart/form-data; charset=utf8; boundary="+boundary);
+            // set request body
+            switch (requestType) {
+                case SingleFile:
+                    builder.method(method, new RNFetchBlobBody(
+                            taskId,
+                            RequestType.SingleFile,
+                            null,
+                            buildOctetBody(rawRequestBody),
+                            contentLength
+                    ));
+                    break;
+                case Form:
+                    builder.method(method, new RNFetchBlobBody(
+                            taskId,
+                            RequestType.Form,
+                            buildFormBody(rawRequestBodyArray),
+                            null,
+                            contentLength
+                    ));
+                case Others:
+                    builder.method(method, new RNFetchBlobBody(
+                            taskId,
+                            RequestType.Others,
+                            buildRawBody(rawRequestBody),
+                            null,
+                            contentLength
+                    ));
+                    break;
             }
 
-            AsyncHttpResponseHandler handler;
+            final Request req = builder.build();
+
+            // create response handler
+            client.networkInterceptors().add(new Interceptor() {
+                @Override
+                public Response intercept(Chain chain) throws IOException {
+                    Response originalResponse = chain.proceed(req);
+                    RNFetchBlobDefaultResp exetneded;
+                    switch (responseType) {
+                        case MemoryCache:
+                            exetneded = new RNFetchBlobDefaultResp(
+                                    RNFetchBlob.RCTContext,
+                                    taskId,
+                                    originalResponse.body());
+                            break;
+                        case FileCache:
+                            exetneded = new RNFetchBlobFileResp(
+                                    RNFetchBlob.RCTContext,
+                                    taskId,
+                                    originalResponse.body(),
+                                    destPath);
+                            break;
+                        default:
+                            exetneded = new RNFetchBlobDefaultResp(
+                                    RNFetchBlob.RCTContext,
+                                    taskId,
+                                    originalResponse.body());
+                            break;
+                    }
+                    return originalResponse.newBuilder().body(exetneded).build();
+                }
+            });
 
-            // create handler
-            if(options.fileCache || options.path != null) {
-                handler = new RNFetchBlobFileHandler(ctx, taskId, cacheKey, options, callback);
-                // if path format invalid, throw error
-                if (!((RNFetchBlobFileHandler)handler).isValid) {
-                    callback.invoke("RNFetchBlob fetch error, configuration path `"+ options.path  +"` is not a valid path.");
-                    return;
+            client.newCall(req).enqueue(new okhttp3.Callback() {
+                @Override
+                public void onFailure(Call call, IOException e) {
+                    callback.invoke(e.getLocalizedMessage(), null);
                 }
-            }
-            else
-                handler = new RNFetchBlobBinaryHandler(this.ctx, taskId, callback);
 
-            // send request
-            switch(method.toLowerCase()) {
-                case "get" :
-                    req.get(url, handler);
-                    break;
-                case "post" :
-                    if(this.type == null || this.type.equalsIgnoreCase("octet"))
-                        req.post(ctx, url, entity, "application/octet-stream", handler);
-                    else
-                        req.post(ctx, url, entity, "multipart/form-data", handler);
-                    break;
-                case "put" :
-                    if(this.type == null || this.type.equalsIgnoreCase("octet"))
-                        req.put(ctx, url, entity, "application/octet-stream", handler);
-                    else
-                        req.put(ctx, url, entity, "multipart/form-data", handler);
-                    break;
-                case "delete" :
-                    req.delete(url, handler);
-                    break;
-            }
-        } catch(Exception error) {
-            callback.invoke( "RNFetchBlob serialize request data failed: " + error.getMessage() + error.getCause());
+                @Override
+                public void onResponse(Call call, Response response) throws IOException {
+                    ReadableMap notifyConfig = options.addAndroidDownloads;
+                    // Download manager settings
+                    if(notifyConfig != null ) {
+                        String title = "", desc = "", mime = "text/plain";
+                        boolean scannable = false, notification = false;
+                        if(notifyConfig.hasKey("title"))
+                            title = options.addAndroidDownloads.getString("title");
+                        if(notifyConfig.hasKey("description"))
+                            desc = notifyConfig.getString("description");
+                        if(notifyConfig.hasKey("mime"))
+                            mime = notifyConfig.getString("mime");
+                        if(notifyConfig.hasKey("mediaScannable"))
+                            scannable = notifyConfig.getBoolean("mediaScannable");
+                        if(notifyConfig.hasKey("notification"))
+                            notification = notifyConfig.getBoolean("notification");
+                        DownloadManager dm = (DownloadManager)RNFetchBlob.RCTContext.getSystemService(RNFetchBlob.RCTContext.DOWNLOAD_SERVICE);
+                        dm.addCompletedDownload(title, desc, scannable, mime, destPath, contentLength, notification);
+                    }
+                    done(response);
+                }
+            });
+
+
+        } catch (Exception error) {
+            callback.invoke("RNFetchBlob request error: " + error.getMessage() + error.getCause());
         }
     }
 
     /**
-     * Build Mutipart body
-     * @param body  Body in array format
+     * Send response data back to javascript context.
+     * @param resp OkHttp response object
      */
-    void buildFormEntity(ReadableArray body) {
-        if(body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
-            Long tsLong = System.currentTimeMillis()/1000;
-            String ts = tsLong.toString();
-            boundary = "RNFetchBlob".concat(ts);
-            MultipartEntityBuilder form = MultipartEntityBuilder.create();
-            form.setBoundary(boundary);
-            for( int i = 0; i< body.size(); i++) {
-                ReadableMap map = body.getMap(i);
-                String name = map.getString("name");
-                if(!map.hasKey("data"))
-                    continue;
-                String data = map.getString("data");
-                // file field
-                if(map.hasKey("filename")) {
-                    String mime = map.hasKey("type") ? map.getString("type") : ContentType.APPLICATION_OCTET_STREAM.getMimeType();
-                    String filename = map.getString("filename");
-                    // upload from storage
-                    if(data.startsWith(filePathPrefix)) {
-                        String orgPath = data.substring(filePathPrefix.length());
-                        orgPath = RNFetchBlobFS.normalizePath(orgPath);
-                        // path starts with content://
-                        if(RNFetchBlobFS.isAsset(orgPath)) {
-                            try {
-                                String assetName = orgPath.replace(RNFetchBlobFS.assetPrefix, "");
-                                InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
-                                long length = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
-                                byte [] bytes = new byte[(int) length];
-                                in.read(bytes, 0, (int) length);
-                                in.close();
-                                form.addBinaryBody(name, bytes, ContentType.create(mime), filename);
-                            } catch (IOException e) {
-//                                e.printStackTrace();
-                            }
-                        }
-                        else {
-                            File file = new File(RNFetchBlobFS.normalizePath(orgPath));
-                            form.addBinaryBody(name, file, ContentType.create(mime), filename);
-                        }
-                    }
-                    // base64 embedded file content
-                    else {
-                        form.addBinaryBody(name, Base64.decode(data, 0), ContentType.create(mime), filename);
-                    }
+    private void done(Response resp) {
+        switch (responseType) {
+            case MemoryCache:
+                try {
+                    callback.invoke(null, android.util.Base64.encode(resp.body().bytes(), 0));
+                } catch (IOException e) {
+                    callback.invoke("RNFetchBlob failed to encode response data to BASE64 string.", null);
                 }
-                // data field
-                else {
-                    form.addTextBody(name, map.getString("data"));
+                break;
+            case FileCache:
+                callback.invoke(null, destPath);
+                break;
+            default:
+                try {
+                    callback.invoke(null, new String(resp.body().bytes(), "UTF-8"));
+                } catch (IOException e) {
+                    callback.invoke("RNFetchBlob failed to encode response data to UTF8 string.", null);
                 }
+                break;
+        }
+    }
+
+    /**
+     * Build request body by given string
+     * @param body Content of request body in UTF8 string format.
+     * @return
+     */
+    RequestBody buildRawBody(String body) {
+        if(body != null) {
+            this.contentType = MediaType.parse(options.mime);
+        }
+        return RequestBody.create(this.contentType, body);
+    }
+
+    /**
+     * When request body is a multipart form data, build a MultipartBody object.
+     * @param body Body in array format
+     * @return
+     */
+    MultipartBody buildFormBody(ReadableArray body) {
+        if (body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
+            this.contentType = RNFetchBlobConst.MIME_MULTIPART;
+            MultipartBody.Builder formBuilder = new MultipartBody.Builder();
+            formBuilder.setType(MultipartBody.FORM);
+
+            for (int i = 0; i < body.size(); i++) {
+                ReadableMap map = body.getMap(i);
+                FormPartBody fieldData = new FormPartBody(RNFetchBlob.RCTContext, map);
+                if(fieldData.filename == null)
+                    formBuilder.addFormDataPart(fieldData.fieldName, fieldData.stringBody);
+                else
+                    formBuilder.addFormDataPart(fieldData.fieldName, fieldData.filename, fieldData.partBody);
             }
-            entity = form.build();
+            return formBuilder.build();
         }
+        return null;
     }
 
     /**
-     * Build Octet-Stream body
-     * @param body  Body in string format
+     * Get InputStream of request body when request body contains a single file.
+     *
+     * @param body Body in string format
+     * @return InputStream When there's no request body, returns null
      */
-    void buildEntity(String body) {
+    InputStream buildOctetBody(String body) {
         // set body for POST and PUT
-        if(body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
-
-            byte [] blob;
+        if (body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
+            this.contentType = RNFetchBlobConst.MIME_OCTET;
+            byte[] blob;
             // upload from storage
-            if(body.startsWith(filePathPrefix)) {
-                String orgPath = body.substring(filePathPrefix.length());
+            if (body.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
+                String orgPath = body.substring(RNFetchBlobConst.FILE_PREFIX.length());
                 orgPath = RNFetchBlobFS.normalizePath(orgPath);
                 // handle
-                if(RNFetchBlobFS.isAsset(orgPath)) {
+                if (RNFetchBlobFS.isAsset(orgPath)) {
                     try {
-                        String assetName = orgPath.replace(RNFetchBlobFS.assetPrefix, "");
-                        InputStream in = RNFetchBlob.RCTContext.getAssets().open(assetName);
-                        long length = 0;
-                        length = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
-                        byte [] bytes = new byte[(int) length];
-                        in.read(bytes, 0, (int) length);
-                        in.close();
-                        entity = new ByteArrayEntity(bytes);
+                        String assetName = orgPath.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
+                        return RNFetchBlob.RCTContext.getAssets().open(assetName);
                     } catch (IOException e) {
 //                        e.printStackTrace();
                     }
+                } else {
+                    File f = new File(RNFetchBlobFS.normalizePath(orgPath));
+                    try {
+                        return new FileInputStream(f);
+                    } catch (FileNotFoundException e) {
+                        callback.invoke(e.getLocalizedMessage(), null);
+                    }
                 }
-                else
-                    entity = new FileEntity(new File(RNFetchBlobFS.normalizePath(orgPath)));
-            }
-            else {
-                blob = Base64.decode(body, 0);
-                entity = new ByteArrayEntity(blob);
+            } else {
+                return new ByteArrayInputStream(Base64.decode(body, 0));
             }
         }
+        return null;
 
     }
 
@@ -320,7 +366,7 @@ public class RNFetchBlobReq extends BroadcastReceiver implements Runnable {
         String action = intent.getAction();
         if (DownloadManager.ACTION_DOWNLOAD_COMPLETE.equals(action)) {
             long id = intent.getExtras().getLong(DownloadManager.EXTRA_DOWNLOAD_ID);
-            if(id == this.downloadManagerId) {
+            if (id == this.downloadManagerId) {
                 DownloadManager.Query query = new DownloadManager.Query();
                 query.setFilterById(downloadManagerId);
                 DownloadManager dm = (DownloadManager) ctx.getSystemService(Context.DOWNLOAD_SERVICE);
@@ -329,13 +375,19 @@ public class RNFetchBlobReq extends BroadcastReceiver implements Runnable {
                 if (c.moveToFirst()) {
                     String contentUri = c.getString(c.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
                     Uri uri = Uri.parse(contentUri);
-                    Cursor cursor = ctx.getContentResolver().query(uri, new String[] { android.provider.MediaStore.Images.ImageColumns.DATA }, null, null, null);
-                    cursor.moveToFirst();
-                    String filePath = cursor.getString(0);
-                    cursor.close();
-                    this.callback.invoke(null, filePath);
+                    Cursor cursor = ctx.getContentResolver().query(uri, new String[]{android.provider.MediaStore.Images.ImageColumns.DATA}, null, null, null);
+                    if (cursor != null) {
+                        cursor.moveToFirst();
+                        String filePath = cursor.getString(0);
+                        cursor.close();
+                        this.callback.invoke(null, filePath);
+                    }
+                    else
+                        this.callback.invoke(null, null);
                 }
             }
         }
     }
+
+
 }

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

@@ -0,0 +1,83 @@
+package com.RNFetchBlob;
+
+import java.security.MessageDigest;
+import java.security.cert.CertificateException;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+
+import okhttp3.OkHttpClient;
+
+/**
+ * Created by wkh237 on 2016/7/11.
+ */
+public class RNFetchBlobUtils {
+    public static String getMD5(String input) {
+        String result = null;
+
+        try {
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            md.update(input.getBytes());
+            byte[] digest = md.digest();
+
+            StringBuffer sb = new StringBuffer();
+
+            for (byte b : digest) {
+                sb.append(String.format("%02x", b & 0xff));
+            }
+
+            result = sb.toString();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return result;
+        }
+
+    }
+
+    public static OkHttpClient getUnsafeOkHttpClient() {
+        try {
+            // Create a trust manager that does not validate certificate chains
+            final TrustManager[] trustAllCerts = new TrustManager[]{
+                    new X509TrustManager() {
+                        @Override
+                        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+                        }
+
+                        @Override
+                        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+                        }
+
+                        @Override
+                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+                            return new java.security.cert.X509Certificate[]{};
+                        }
+                    }
+            };
+
+            // Install the all-trusting trust manager
+            final SSLContext sslContext = SSLContext.getInstance("SSL");
+            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
+            // Create an ssl socket factory with our all-trusting manager
+            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
+
+            OkHttpClient.Builder builder = new OkHttpClient.Builder();
+            builder.sslSocketFactory(sslSocketFactory);
+            builder.hostnameVerifier(new HostnameVerifier() {
+                @Override
+                public boolean verify(String hostname, SSLSession session) {
+                    return true;
+                }
+            });
+
+            OkHttpClient okHttpClient = builder.build();
+            return okHttpClient;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+package com.RNFetchBlob.Request;
+
+import com.RNFetchBlob.RNFetchBlobConst;
+import com.RNFetchBlob.RNFetchBlobFS;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.loopj.android.http.Base64;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+
+/**
+ * Created by wkh237 on 2016/7/12.
+ */
+public class FormPartBody {
+
+    public String fieldName;
+    public String filename;
+    public RequestBody partBody;
+    public String stringBody;
+
+    public FormPartBody(ReactApplicationContext ctx, ReadableMap field) {
+        String data = field.getString("data");
+        String name = field.getString("name");
+        RequestBody partBody;
+        if (field.hasKey("filename")) {
+            MediaType mime = field.hasKey("type") ?
+                    MediaType.parse(field.getString("type")) : RNFetchBlobConst.MIME_OCTET;
+            String filename = field.getString("filename");
+            // upload from storage
+            if (data.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
+                String orgPath = data.substring(RNFetchBlobConst.FILE_PREFIX.length());
+                orgPath = RNFetchBlobFS.normalizePath(orgPath);
+                // path starts with content://
+                if (RNFetchBlobFS.isAsset(orgPath)) {
+                    try {
+                        String assetName = orgPath.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
+                        InputStream in = ctx.getAssets().open(assetName);
+                        long length = ctx.getAssets().openFd(assetName).getLength();
+                        byte[] bytes = new byte[(int) length];
+                        in.read(bytes, 0, (int) length);
+                        in.close();
+                        partBody = RequestBody.create(mime, bytes, 0, (int) length);
+                    } catch (IOException e) {
+                        partBody = null;
+                    }
+                } else {
+                    File file = new File(RNFetchBlobFS.normalizePath(orgPath));
+                    partBody = RequestBody.create(mime, file);
+                }
+            }
+            // base64 embedded file content
+            else {
+                byte[] bytes = Base64.decode(data, 0);
+                partBody = RequestBody.create(mime, bytes, 0, bytes.length);
+            }
+            this.filename = filename;
+            this.fieldName = name;
+            this.partBody = partBody;
+        }
+        // data field
+        else {
+            this.fieldName = name;
+            this.stringBody = field.getString("data");
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.RNFetchBlob.Response;
+
+import com.RNFetchBlob.RNFetchBlob;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.io.IOException;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.MediaType;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ForwardingSource;
+import okio.Okio;
+import okio.Source;
+import okio.Timeout;
+
+/**
+ * Created by wkh237 on 2016/7/11.
+ */
+public class RNFetchBlobDefaultResp extends ResponseBody {
+
+    String mTaskId;
+    ReactApplicationContext rctContext;
+    ResponseBody originalBody;
+
+    public RNFetchBlobDefaultResp(ReactApplicationContext ctx, String taskId, ResponseBody body) {
+        this.rctContext = ctx;
+        this.mTaskId = taskId;
+        this.originalBody = body;
+    }
+
+    @Override
+    public MediaType contentType() {
+        return originalBody.contentType();
+    }
+
+    @Override
+    public long contentLength() {
+        return originalBody.contentLength();
+    }
+
+    @Override
+    public BufferedSource source() {
+        return Okio.buffer(new ProgressReportingSource(originalBody.source()));
+    }
+
+    private class ProgressReportingSource implements Source {
+
+        BufferedSource mOriginalSource;
+        long bytesRead = 0;
+
+        ProgressReportingSource(BufferedSource originalSource) {
+            mOriginalSource = originalSource;
+        }
+
+        @Override
+        public long read(Buffer sink, long byteCount) throws IOException {
+            bytesRead += byteCount;
+            long read =  mOriginalSource.read(sink, byteCount);
+            WritableMap args = Arguments.createMap();
+            args.putString("taskId", mTaskId);
+            args.putString("written", String.valueOf(bytesRead));
+            args.putString("total", String.valueOf(contentLength()));
+            rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit("RNFetchBlobProgress", args);
+            return read;
+        }
+
+        @Override
+        public Timeout timeout() {
+            return null;
+        }
+
+        @Override
+        public void close() throws IOException {
+
+        }
+    }
+
+}

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

@@ -0,0 +1,84 @@
+package com.RNFetchBlob.Response;
+
+import com.RNFetchBlob.RNFetchBlob;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import okhttp3.ResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.Okio;
+import okio.Source;
+import okio.Timeout;
+
+/**
+ * Created by wkh237 on 2016/7/11.
+ */
+public class RNFetchBlobFileResp extends RNFetchBlobDefaultResp {
+
+    String mPath;
+    ReactApplicationContext rctContext;
+    FileOutputStream ofStream;
+
+    public RNFetchBlobFileResp(ReactApplicationContext ctx, String taskId, ResponseBody body, String path) throws IOException {
+        super(ctx, taskId, body);
+        this.rctContext = ctx;
+        this.mTaskId = taskId;
+        this.originalBody = body;
+        this.mPath = path;
+        File f = new File(path);
+        if(f.exists() == false)
+            f.createNewFile();
+        ofStream = new FileOutputStream(new File(path));
+    }
+
+
+    @Override
+    public BufferedSource source() {
+        ProgressReportingSource source = new ProgressReportingSource(originalBody.source());
+        return Okio.buffer(source);
+    }
+
+    private class ProgressReportingSource implements Source {
+
+        BufferedSource mOriginalSource;
+        long bytesRead = 0;
+
+        ProgressReportingSource(BufferedSource originalSource) {
+            mOriginalSource = originalSource;
+        }
+
+        @Override
+        public long read(Buffer sink, long byteCount) throws IOException {
+            bytesRead += byteCount;
+            byte [] bytes = new byte[10240];
+            long read = mOriginalSource.read(bytes);
+            ofStream.write(bytes);
+            WritableMap args = Arguments.createMap();
+            args.putString("taskId", mTaskId);
+            args.putString("written", String.valueOf(bytesRead));
+            args.putString("total", String.valueOf(contentLength()));
+            rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit("RNFetchBlobProgress", args);
+            return read;
+        }
+
+        @Override
+        public Timeout timeout() {
+            return null;
+        }
+
+        @Override
+        public void close() throws IOException {
+            ofStream.close();
+
+        }
+    }
+
+}

src/index.js

@@ -82,7 +82,7 @@ function wrap(path:string):string {
  *         @property {string} key
  *                   If this property is set, it will be converted to md5, to
  *                   check if a file with this name exists.
- *                   If it exists, the absolute path is returned (no network 
+ *                   If it exists, the absolute path is returned (no network
  *                   activity takes place )
  *                   If it doesn't exist, the file is downloaded as usual
  *
@@ -121,6 +121,12 @@ function fetch(...args:any):Promise {
       }
     })
 
+    let subscription = emitter.addListener('RNFetchBlobProgress-upload', (e) => {
+      if(e.taskId === taskId && promise.onProgress) {
+        promise.onUploadProgress(e.written, e.total)
+      }
+    })
+
     let req = RNFetchBlob[nativeMethodName]
     req(options, taskId, method, url, headers || {}, body, (err, data) => {
 
@@ -149,6 +155,11 @@ function fetch(...args:any):Promise {
     return promise
   }
 
+  promise.uploadProgress = (fn) => {
+    promise.onUploadProgress = fn
+    return promise
+  }
+
   return promise
 
 }