wip commit, complete Android form upload

src/android/build.gradle

 
 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/RNFetchBlobBody.java

 package com.RNFetchBlob;
 
+import android.util.Base64;
+
 import com.facebook.react.bridge.Arguments;
+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;
 
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
 
 import okhttp3.MediaType;
 import okhttp3.RequestBody;
 import okio.Buffer;
 import okio.BufferedSink;
+import okio.ByteString;
 import okio.ForwardingSink;
 import okio.Okio;
 import okio.Sink;
 
 /**
- * Created by wkh237on 2016/7/11.
+ * Created by wkh237 on 2016/7/11.
  */
 public class RNFetchBlobBody extends RequestBody{
 
     InputStream requestStream;
     long contentLength;
-    RequestBody originalBody;
+    long bytesWritten = 0;
+    ReadableArray form;
     String mTaskId;
     RNFetchBlobReq.RequestType requestType;
+    MediaType mime;
 
-    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, RequestBody body, InputStream stream, long size) {
+    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, ReadableArray form, InputStream stream, long size, MediaType contentType) {
         this.mTaskId = taskId;
-        originalBody = body;
+        this.form = form;
         requestStream = stream;
         contentLength = size;
         requestType = type;
+        mime = contentType;
     }
 
     @Override
     public MediaType contentType() {
-        return originalBody.contentType();
+        return mime;
     }
 
     @Override
         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);
+                String boundary = "RNFetchBlob-" + mTaskId;
+                ArrayList<FormField> fields = countFormDataLength();
+                ReactApplicationContext ctx = RNFetchBlob.RCTContext;
+                for(int i = 0;i < fields.size(); i++) {
+                    FormField field = fields.get(i);
+                    String data = field.data;
+                    String name = field.name;
+                    // skip invalid fields
+                    if(name == null || data == null)
+                        continue;
+                    // form begin
+                    String header = "--" + boundary + "\r\n";
+                    if (field.filename != null) {
+                        header += "Content-Disposition: form-data; name=" + name + "; filename=" + field.filename + "\r\n";
+                        header += "Content-Type: " + field.mime+ "\r\n\r\n";
+                        sink.write(header.getBytes());
+                        // file field header end
+                        // 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);
+                                    pipeStreamToSink(in, sink);
+                                } catch (IOException e) {
+
+                                }
+                            }
+                            // data from normal files
+                            else {
+                                File file = new File(RNFetchBlobFS.normalizePath(orgPath));
+                                if(file.exists()) {
+                                    FileInputStream fs = new FileInputStream(file);
+                                    pipeStreamToSink(fs, sink);
+                                }
+                            }
+                        }
+                        // base64 embedded file content
+                        else {
+                            byte[] b = Base64.decode(data, 0);
+                            sink.write(b);
+                            bytesWritten += b.length;
+                            emitUploadProgress(bytesWritten, contentLength);
+                        }
+
+                    }
+                    // data field
+                    else {
+                        header += "Content-Disposition: form-data; name=" + name + "\r\n";
+                        header += "Content-Type: " + field.mime + "\r\n\r\n";
+                        sink.write(header.getBytes());
+                        byte[] fieldData = field.data.getBytes();
+                        bytesWritten += fieldData.length;
+                        sink.write(fieldData);
+                    }
+                    // form end
+                    sink.write("\r\n".getBytes());
                 }
-                requestStream.close();
+                // close the form
+                byte[] end = ("--" + boundary + "--\r\n").getBytes();
+                sink.write(end);
                 break;
-            case Others:
-                originalBody.writeTo(buffer);
+            case SingleFile:
+                pipeStreamToSink(requestStream, sink);
+//                byte [] chunk = new byte[10240];
+//                int read = requestStream.read(chunk, 0, 10240);
+//                sink.write(chunk, 0, read);
+//                bytesWritten += read;
+//                while(read > 0) {
+//                    read = requestStream.read(chunk, 0, 10240);
+//                    if(read > 0) {
+//                        sink.write(chunk, 0, read);
+//                        bytesWritten += read;
+//                        emitUploadProgress(bytesWritten, contentLength);
+//                    }
+//
+//                }
+//                requestStream.close();
                 break;
         }
         buffer.flush();
     }
 
+    private void pipeStreamToSink(InputStream stream, BufferedSink sink) throws IOException {
+        byte [] chunk = new byte[10240];
+        int read = stream.read(chunk, 0, 10240);
+        sink.write(chunk, 0, read);
+        bytesWritten += read;
+        while(read > 0) {
+            read = stream.read(chunk, 0, 10240);
+            if(read > 0) {
+                sink.write(chunk, 0, read);
+                bytesWritten += read;
+                emitUploadProgress(bytesWritten, contentLength);
+            }
+
+        }
+        stream.close();
+    }
+
+    private void emitUploadProgress(long current, long total) {
+        WritableMap args = Arguments.createMap();
+        args.putString("taskId", mTaskId);
+        args.putString("written", String.valueOf(bytesWritten));
+        args.putString("total", String.valueOf(contentLength));
+
+        // emit event to js context
+        RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+    }
+
+    /**
+     * Compute a proximate content length for form data
+     * @return
+     */
+    private ArrayList<FormField> countFormDataLength() {
+        long total = 0;
+        ArrayList<FormField> list = new ArrayList<>();
+        ReactApplicationContext ctx = RNFetchBlob.RCTContext;
+        for(int i = 0;i < form.size(); i++) {
+            ReadableMap field = form.getMap(i);
+            list.add(new FormField(field));
+            String data = field.getString("data");
+            if (field.hasKey("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, "");
+                            long length = ctx.getAssets().openFd(assetName).getLength();
+                            total += length;
+                        } catch (IOException e) {
+
+                        }
+                    } else {
+                        File file = new File(RNFetchBlobFS.normalizePath(orgPath));
+                        total += file.length();
+                    }
+                }
+                // base64 embedded file content
+                else {
+                    byte[] bytes = Base64.decode(data, 0);
+                    total += bytes.length;
+                }
+            }
+            // data field
+            else {
+                total += field.getString("data").length();
+            }
+        }
+        contentLength = total;
+        return list;
+    }
+
+    private class FormField {
+        public String name;
+        public String filename;
+        public String mime;
+        public String data;
+
+        public FormField(ReadableMap rawData) {
+            if(rawData.hasKey("name"))
+                name = rawData.getString("name");
+            if(rawData.hasKey("filename"))
+                filename = rawData.getString("filename");
+            if(rawData.hasKey("type"))
+                mime = rawData.getString("type");
+            else {
+                mime = filename == null ? "text/plain" : "application/octet-stream";
+            }
+            if(rawData.hasKey("data"))
+                data = rawData.getString("data");
+        }
+    }
+
     private final class ProgressReportingSource extends ForwardingSink {
 
         private long bytesWritten = 0;
         private String mTaskId;
         private long mContentLength ;
+        private Sink delegate;
 
         public ProgressReportingSource (Sink delegate, String taskId, long contentLength) {
             super(delegate);
             this.mTaskId = taskId;
             this.mContentLength = contentLength;
+            this.delegate = delegate;
         }
 
         @Override
         public void write(Buffer source, long byteCount) throws IOException {
-            super.write(source, byteCount);
+            delegate.write(source, byteCount);
             // on progress, emit RNFetchBlobProgress upload progress event with ticketId,
             // bytesWritten, and totalSize
             bytesWritten += byteCount;

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

 import android.os.AsyncTask;
 import android.os.Environment;
 import android.provider.MediaStore;
+import android.util.Base64;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.loopj.android.http.Base64;
 
 import java.io.File;
 import java.io.FileInputStream;
 
                     switch (encoding.toLowerCase()) {
                         case "base64" :
-                            promise.resolve(Base64.encodeToString(bytes, 0));
+                            promise.resolve(Base64.encodeToString(bytes, Base64.NO_WRAP));
                             break;
                         case "ascii" :
                             WritableArray asciiResult = Arguments.createArray();
             return data.getBytes(Charset.forName("US-ASCII"));
         }
         else if(encoding.equalsIgnoreCase("base64")) {
-            return Base64.decode(data, 0);
+            return Base64.decode(data, Base64.NO_WRAP);
         }
         else if(encoding.equalsIgnoreCase("utf8")) {
             return data.getBytes(Charset.forName("UTF-8"));

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

 import android.content.IntentFilter;
 import android.database.Cursor;
 import android.net.Uri;
+import android.util.Base64;
 
-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.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
-import com.loopj.android.http.Base64;
 
 import java.io.ByteArrayInputStream;
 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.net.MalformedURLException;
+import java.net.URL;
 
 import okhttp3.Call;
 import okhttp3.Interceptor;
 import okhttp3.Request;
 import okhttp3.RequestBody;
 import okhttp3.Response;
+import okhttp3.ResponseBody;
 
 /**
  * Created by wkh237 on 2016/6/21.
     enum RequestType  {
         Form,
         SingleFile,
+        WithoutBody,
         Others
     };
 
     enum ResponseType {
-        MemoryCache,
-        FileCache
+        KeepInMemory,
+        FileStorage
     };
 
     MediaType contentType = RNFetchBlobConst.MIME_OCTET;
         this.rawRequestBody = body;
         this.rawRequestBodyArray = arrayBody;
 
-        if(this.options.fileCache != null || this.options.path != null)
-            responseType = ResponseType.FileCache;
+        if(this.options.fileCache == true || this.options.path != null)
+            responseType = ResponseType.FileStorage;
         else
-            responseType = ResponseType.MemoryCache;
+            responseType = ResponseType.KeepInMemory;
 
         if (body != null)
             requestType = RequestType.SingleFile;
         else if (arrayBody != null)
             requestType = RequestType.Form;
         else
-            requestType = RequestType.Others;
+            requestType = RequestType.WithoutBody;
     }
 
     @Override
 
         // find cached result if `key` property exists
         String cacheKey = this.taskId;
-        if (this.options.key != null) {
-            cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
-            if (cacheKey == null) {
-                cacheKey = this.taskId;
-            }
-
-            File file = new File(RNFetchBlobFS.getTmpPath(ctx, cacheKey));
-            if (file.exists()) {
-                callback.invoke(null, file.getAbsolutePath());
-                return;
-            }
-        }
+//        if (this.options.key != null) {
+//            cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
+//            if (cacheKey == null) {
+//                cacheKey = this.taskId;
+//            }
+//
+//            File file = new File(RNFetchBlobFS.getTmpPath(ctx, cacheKey));
+//            if (file.exists()) {
+//                callback.invoke(null, file.getAbsolutePath());
+//                return;
+//            }
+//        }
 
         if(this.options.path != null)
-            destPath = this.options.path;
-        else if(this.options.fileCache)
-            destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey);
+            this.destPath = this.options.path;
+        else if(this.options.fileCache == true)
+            this.destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey);
 
-        OkHttpClient client;
-        try {
+        OkHttpClient.Builder client;
 
+//        try {
             // use trusty SSL socket
             if (this.options.trusty) {
                 client = RNFetchBlobUtils.getUnsafeOkHttpClient();
             } else {
-                client = new OkHttpClient();
+                client = new OkHttpClient.Builder();
             }
 
             final Request.Builder builder = new Request.Builder();
-
+            try {
+                builder.url(new URL(url));
+            } catch (MalformedURLException e) {
+                e.printStackTrace();
+            }
             // set headers
             if (headers != null) {
                 ReadableMapKeySetIterator it = headers.keySetIterator();
                 while (it.hasNextKey()) {
                     String key = it.nextKey();
-                    builder.addHeader(key, headers.getString(key));
+                    String value = headers.getString(key);
+                    builder.header(key, value);
                 }
             }
 
             // set request body
             switch (requestType) {
                 case SingleFile:
+                    InputStream dataStream= buildOctetBody(rawRequestBody);
                     builder.method(method, new RNFetchBlobBody(
                             taskId,
                             RequestType.SingleFile,
                             null,
-                            buildOctetBody(rawRequestBody),
-                            contentLength
+                            dataStream,
+                            contentLength,
+                            RNFetchBlobConst.MIME_OCTET
                     ));
                     break;
                 case Form:
                     builder.method(method, new RNFetchBlobBody(
                             taskId,
                             RequestType.Form,
-                            buildFormBody(rawRequestBodyArray),
+                            rawRequestBodyArray,
                             null,
-                            contentLength
-                    ));
-                case Others:
-                    builder.method(method, new RNFetchBlobBody(
-                            taskId,
-                            RequestType.Others,
-                            buildRawBody(rawRequestBody),
-                            null,
-                            contentLength
+                            0,
+                            MediaType.parse("multipart/form-data; boundary=RNFetchBlob-" + taskId)
                     ));
                     break;
+                case WithoutBody:
+                    builder.method(method, null);
+                    break;
             }
 
             final Request req = builder.build();
 
-            // create response handler
-            client.networkInterceptors().add(new Interceptor() {
+//             create response handler
+            client.addInterceptor(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();
+                Response originalResponse = chain.proceed(req);
+                    ResponseBody extended;
+                switch (responseType) {
+                    case KeepInMemory:
+                        extended = new RNFetchBlobDefaultResp(
+                                RNFetchBlob.RCTContext,
+                                taskId,
+                                originalResponse.body());
+                        break;
+                    case FileStorage:
+                        extended = new RNFetchBlobFileResp(
+                                RNFetchBlob.RCTContext,
+                                taskId,
+                                originalResponse.body(),
+                                destPath);
+                        break;
+                    default:
+                        extended = new RNFetchBlobDefaultResp(
+                                RNFetchBlob.RCTContext,
+                                taskId,
+                                originalResponse.body());
+                        break;
+                }
+                return originalResponse.newBuilder().body(extended).build();
                 }
             });
 
-            client.newCall(req).enqueue(new okhttp3.Callback() {
+            client.build().newCall(req).enqueue(new okhttp3.Callback() {
                 @Override
                 public void onFailure(Call call, IOException e) {
                     callback.invoke(e.getLocalizedMessage(), null);
             });
 
 
-        } catch (Exception error) {
-            callback.invoke("RNFetchBlob request error: " + error.getMessage() + error.getCause());
-        }
+//        } catch (Exception error) {
+//            error.printStackTrace();
+//            callback.invoke("RNFetchBlob request error: " + error.getMessage() + error.getCause());
+//        }
     }
 
     /**
      */
     private void done(Response resp) {
         switch (responseType) {
-            case MemoryCache:
+            case KeepInMemory:
                 try {
-                    callback.invoke(null, android.util.Base64.encode(resp.body().bytes(), 0));
+                    byte [] b = resp.body().bytes();
+                    callback.invoke(null, android.util.Base64.encodeToString(b,Base64.NO_WRAP));
                 } catch (IOException e) {
                     callback.invoke("RNFetchBlob failed to encode response data to BASE64 string.", null);
                 }
                 break;
-            case FileCache:
-                callback.invoke(null, destPath);
+            case FileStorage:
+                // write chunk
+                try {
+                    resp.body().bytes();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                callback.invoke(null, this.destPath);
                 break;
             default:
                 try {
     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);
-            }
-            return formBuilder.build();
+            return RequestBody.create(this.contentType, body);
         }
         return null;
+
     }
 
     /**
             if (body.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
                 String orgPath = body.substring(RNFetchBlobConst.FILE_PREFIX.length());
                 orgPath = RNFetchBlobFS.normalizePath(orgPath);
-                // handle
+                // upload file from assets
                 if (RNFetchBlobFS.isAsset(orgPath)) {
                     try {
                         String assetName = orgPath.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
+                        contentLength = RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
                         return RNFetchBlob.RCTContext.getAssets().open(assetName);
                     } catch (IOException e) {
 //                        e.printStackTrace();
                 } else {
                     File f = new File(RNFetchBlobFS.normalizePath(orgPath));
                     try {
+                        if(!f.exists())
+                            f.createNewFile();
+                        contentLength = f.length();
                         return new FileInputStream(f);
-                    } catch (FileNotFoundException e) {
+                    } catch (Exception e) {
                         callback.invoke(e.getLocalizedMessage(), null);
                     }
                 }
             } else {
-                return new ByteArrayInputStream(Base64.decode(body, 0));
+                byte[] bytes = Base64.decode(body, 0);
+                contentLength = bytes.length;
+                return new ByteArrayInputStream(bytes);
             }
         }
         return null;

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

 
     }
 
-    public static OkHttpClient getUnsafeOkHttpClient() {
+    public static OkHttpClient.Builder getUnsafeOkHttpClient() {
         try {
             // Create a trust manager that does not validate certificate chains
             final TrustManager[] trustAllCerts = new TrustManager[]{
                 }
             });
 
-            OkHttpClient okHttpClient = builder.build();
-            return okHttpClient;
+            return builder;
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

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

-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/RNFetchBlobFileResp.java

 import java.io.FileOutputStream;
 import java.io.IOException;
 
+import okhttp3.MediaType;
 import okhttp3.ResponseBody;
 import okio.Buffer;
 import okio.BufferedSource;
 /**
  * Created by wkh237 on 2016/7/11.
  */
-public class RNFetchBlobFileResp extends RNFetchBlobDefaultResp {
+public class RNFetchBlobFileResp extends ResponseBody {
 
+    String mTaskId;
+    ResponseBody originalBody;
     String mPath;
+    long bytesUploaded = 0;
     ReactApplicationContext rctContext;
     FileOutputStream ofStream;
 
     public RNFetchBlobFileResp(ReactApplicationContext ctx, String taskId, ResponseBody body, String path) throws IOException {
-        super(ctx, taskId, body);
+        super();
         this.rctContext = ctx;
         this.mTaskId = taskId;
         this.originalBody = body;
+        assert path != null;
         this.mPath = path;
-        File f = new File(path);
-        if(f.exists() == false)
-            f.createNewFile();
-        ofStream = new FileOutputStream(new File(path));
+        if (path != null) {
+            File f = new File(path);
+            if(f.exists() == false)
+                f.createNewFile();
+            ofStream = new FileOutputStream(new File(path));
+        }
     }
 
+    @Override
+    public MediaType contentType() {
+        return originalBody.contentType();
+    }
+
+    @Override
+    public long contentLength() {
+        return originalBody.contentLength();
+    }
 
     @Override
     public BufferedSource source() {
-        ProgressReportingSource source = new ProgressReportingSource(originalBody.source());
-        return Okio.buffer(source);
+        ProgressReportingSource countable = new ProgressReportingSource();
+        return Okio.buffer(countable);
     }
 
     private class ProgressReportingSource implements Source {
-
-        BufferedSource mOriginalSource;
-        long bytesRead = 0;
-
-        ProgressReportingSource(BufferedSource originalSource) {
-            mOriginalSource = originalSource;
-        }
-
+        int count = 0;
         @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);
+            count++;
+            byte [] bytes = new byte[(int) byteCount];
+            long read = originalBody.byteStream().read(bytes, 0, (int) byteCount);
+            if(read > 0) {
+                bytesUploaded += read;
+                ofStream.write(bytes, 0, (int) read);
+                WritableMap args = Arguments.createMap();
+                args.putString("taskId", mTaskId);
+                args.putString("written", String.valueOf(bytesUploaded));
+                args.putString("total", String.valueOf(contentLength()));
+                rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                        .emit("RNFetchBlobProgress", args);
+            }
             return read;
         }
 

src/index.js

       }
     })
 
-    let subscription = emitter.addListener('RNFetchBlobProgress-upload', (e) => {
-      if(e.taskId === taskId && promise.onProgress) {
+    let subscriptionUpload = emitter.addListener('RNFetchBlobProgress-upload', (e) => {
+      if(e.taskId === taskId && promise.onUploadProgress) {
         promise.onUploadProgress(e.written, e.total)
       }
     })
 
       // task done, remove event listener
       subscription.remove()
+      subscriptionUpload.remove()
       if(err)
         reject(new Error(err, data))
       else {

test-server/.gitignore

 !public/github2.jpg
 !public/22mb-dummy
 !public/1mb-dummy
+!public/chunk-dummy
 !public/beethoven.mp3
 !public/cat-fu.mp4
 !uploads/readme

test-server/public/chunk-dummy

+12345678910abcdefg

test-server/server.js

     console.log('test server running at port ',8123)
 })
 
-var count = 0
 
 app.use(function(req,res,next){
-  console.log(chalk.green('request url=') + chalk.magenta(req.url), ++count)
+  console.log(chalk.green('request url=') + chalk.magenta(req.url))
   next()
 })
 

test/test-0.1.x-0.4.x.js

       { name : 'field2', data : 'hello2 !!'}
     ])
   .then((resp) => {
+    console.log(resp.json())
     resp = resp.json()
+
     report(
       <Assert key="check posted form data #1" expect="hello !!" actual={resp.fields.field1}/>,
       <Assert key="check posted form data #2" expect="hello2 !!" actual={resp.fields.field2}/>,

test/test-0.5.1.js

     })
 })
 
-RNTest.config({
-  group : '0.5.1',
-  run : true,
-  expand : false,
-  timeout : 600000,
-})('Upload and download large file', (report, done) => {
-  let filename = '22mb-dummy-' + Date.now()
-  let begin = -1
-  let begin2 = -1
-  let deb = Date.now()
-  RNFetchBlob.config({
-    fileCache : true
-  })
-  .fetch('GET', `${TEST_SERVER_URL}/public/22mb-dummy`)
-  .progress((now, total) => {
-    if(begin === -1)
-      begin = Date.now()
-    if(Date.now() - deb < 1000)
-      return
-    deb = Date.now()
-    report(<Info uid="200" key="progress">
-      <Text>
-        {`download ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s)`}
-      </Text>
-    </Info>)
-  })
-  .then((res) => {
-    try {
-    deb = Date.now()
-    let promise =  RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
-      Authorization : `Bearer ${DROPBOX_TOKEN}`,
-      'Dropbox-API-Arg': '{\"path\": \"/rn-upload/'+filename+'\",\"mode\": \"add\",\"autorename\": true,\"mute\": false}',
-      'Content-Type' : 'application/octet-stream',
-    }, RNFetchBlob.wrap(res.path()))
-    if(Platform.OS === 'ios') {
-      promise.progress((now, total) => {
-        if(Date.now() - deb < 1000)
-          return
-        deb = Date.now()
-        if(begin2 === -1)
-          begin2 = Date.now()
-        let speed = Math.floor(now / (Date.now() - begin2))
-        report(<Info uid="100"  key="progress">
-          <Text>
-            {`upload ${now} / ${total} bytes (${speed} kb/s)`}
-            {` ${Math.floor((total-now)/speed/1000)} seconds left`}
-          </Text>
-        </Info>)
-      })
-    }
-    return promise
-  } catch(err) { console.log(err) }
-  })
-  .then((res) => {
-    report(<Assert
-      key="upload should success without crashing app"
-      expect={filename}
-      actual={res.json().name}/>)
-    done()
-  })
-})
-
 describe('Session create mechanism test', (report, done) => {
   let sessionName = 'foo-' + Date.now()
   testSessionName = sessionName

test/test-0.5.2.js

 describe('POST request with params', (report, done) => {
   let time = Date.now()
   RNFetchBlob.config({ fileCache : true })
-    .fetch('POST', `${TEST_SERVER_URL}/params?time=${time}&name=RNFetchBlobParams&lang=中文`)
+    .fetch('POST', `${TEST_SERVER_URL}/params?time=${time}&name=RNFetchBlobParams&lang=中文`, {}, RNFetchBlob.base64.encode('123'))
     .then((resp) => {
       let file = resp.path()
       return RNFetchBlob.fs.readStream(resp.path(), 'utf8')

test/test-0.6.3.js

 
 let prefix = ((Platform.OS === 'android') ? 'file://' : '')
 
-describe('massive HTTP request', (report, done) => {
-  try {
+false && describe('massive HTTP request', (report, done) => {
+  return
   let promises = []
   let progress = []
   let begin = Date.now()
     // Timer.clearInterval(it)
     done()
   })
-} catch(err) {
-  console.log(err)
-}
 
 })
+
+RNTest.config({
+  group : '0.7.0',
+  run : true,
+  expand : false,
+  timeout : 600000,
+})('Upload and download large file', (report, done) => {
+  let filename = '22mb-dummy-' + Date.now()
+  let begin = -1
+  let begin2 = -1
+  let deb = Date.now()
+  RNFetchBlob.config({
+    fileCache : true
+  })
+  .fetch('GET', `${TEST_SERVER_URL}/public/22mb-dummy`)
+  .progress((now, total) => {
+    if(begin === -1)
+      begin = Date.now()
+    if(Date.now() - deb < 1000)
+      return
+    deb = Date.now()
+    report(<Info uid="200" key="progress">
+      <Text>
+        {`download ${now} / ${total} bytes (${Math.floor(now / (Date.now() - begin))} kb/s)`}
+      </Text>
+    </Info>)
+  })
+  .then((res) => {
+    try {
+    deb = Date.now()
+    // let promise =  RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/raw`, {
+    let promise =  RNFetchBlob.fetch('POST', 'https://content.dropboxapi.com/2/files/upload', {
+      Authorization : `Bearer ${DROPBOX_TOKEN}`,
+      'Dropbox-API-Arg': '{\"path\": \"/rn-upload/'+filename+'\",\"mode\": \"add\",\"autorename\": true,\"mute\": false}',
+      'Content-Type' : 'application/octet-stream',
+    }, RNFetchBlob.wrap(res.path()))
+    promise.uploadProgress((now, total) => {
+      if(Date.now() - deb < 1000)
+        return
+      deb = Date.now()
+      if(begin2 === -1)
+        begin2 = Date.now()
+      let speed = Math.floor(now / (Date.now() - begin2))
+      report(<Info uid="100"  key="progress">
+        <Text>
+          {`upload ${now} / ${total} bytes (${speed} kb/s)`}
+          {` ${Math.floor((total-now)/speed/1000)} seconds left`}
+        </Text>
+      </Info>)
+    })
+    return promise
+  } catch(err) { console.log(err) }
+  })
+  .then((res) => {
+    report(<Assert
+      key="upload should success without crashing app"
+      expect={filename}
+      actual={res.json().name}/>)
+    done()
+  })
+})

test/test-init.js

   Image,
 } from 'react-native';
 
-const { Assert, Comparer, Info, describe, prop } = RNTest
+const { Assert, Comparer, Info, prop } = RNTest
 
 // test environment variables
 
   image : {
     width: Dimensions.get('window').width*0.9,
     height : Dimensions.get('window').width*0.9,
-    margin :16
+    margin : 16
   }
 })
 
 const { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles, image } = prop()
 
+const describe = RNTest.config({
+  run : true,
+  expand : false,
+  timeout : 5000,
+})
+
 // init
 
 describe('GET image from server', (report, done) => {
 
 
 require('./test-0.1.x-0.4.x')
-require('./test-0.5.1')
-require('./test-0.5.2')
-require('./test-0.6.0')
-require('./test-0.6.2')
-require('./test-0.6.3')
-require('./test-fs')
-require('./test-android')
+// require('./test-0.5.1')
+// require('./test-0.5.2')
+// require('./test-0.6.0')
+// require('./test-0.6.2')
+// require('./test-0.6.3')
+// require('./test-fs')
+// require('./test-android')