Merge branch '0.9.2' into 0.10.0

.github/PULL_REQUEST_TEMPLATE

 Thank you for making a pull request ! Just a gentle reminder :)
 
-1. If the PR is offering a feature please make the request to our "Feature Branch" 0.7.0
-2. Bug fix request to "Bug Fix Branch" 0.6.4
+1. If the PR is offering a feature please make the request to our "Feature Branch" 0.10.0
+2. Bug fix request to "Bug Fix Branch" 0.9.2
 3. Correct README.md can directly to master

README.md

-# react-native-fetch-blob [![release](https://img.shields.io/github/release/wkh237/react-native-fetch-blob.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/releases) [![npm](https://img.shields.io/npm/v/react-native-fetch-blob.svg?style=flat-square)](https://www.npmjs.com/package/react-native-fetch-blob) ![](https://img.shields.io/badge/PR-Welcome-brightgreen.svg?style=flat-square) [![npm](https://img.shields.io/npm/l/react-native-fetch-blob.svg?maxAge=2592000&style=flat-square)]()
+# react-native-fetch-blob 
+[![release](https://img.shields.io/github/release/wkh237/react-native-fetch-blob.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/releases) [![npm](https://img.shields.io/npm/v/react-native-fetch-blob.svg?style=flat-square)](https://www.npmjs.com/package/react-native-fetch-blob) ![](https://img.shields.io/badge/PR-Welcome-brightgreen.svg?style=flat-square) [![](https://img.shields.io/badge/Wiki-Public-brightgreen.svg?style=flat-square)](https://github.com/wkh237/react-native-fetch-blob/wiki) [![npm](https://img.shields.io/npm/l/react-native-fetch-blob.svg?maxAge=2592000&style=flat-square)]()
 
 
-A project committed to make file acess and data transfer easier, effiecient for React Native developers.
+A project committed to make file acess and data transfer easier, efficient for React Native developers.
 
 ## Features
 - Transfer data directly from/to storage without BASE64 bridging
 
 ## About
 
-This project was initially for solving the issue [facebook/react-native#854](https://github.com/facebook/react-native/issues/854), because React Native lack of `Blob` implementation and it will cause some problem when transfering binary data. Now, this project is committed to make file access and transfer more easier, effiecient for React Native developers. We've implemented highly customizable filesystem and network module which plays well together. For example, upload and download data directly from/to storage which is much more efficient in some cases(especially for large ones). The file system supports file stream, so you don't have to worry about OOM problem when accessing large files.
+This project was initially for solving the issue [facebook/react-native#854](https://github.com/facebook/react-native/issues/854), because React Native lack of `Blob` implementation and it will cause some problem when transfering binary data. Now, this project is committed to make file access and transfer more easier, efficient for React Native developers. We've implemented highly customizable filesystem and network module which plays well together. For example, upload and download data directly from/to storage which is much more efficient in some cases(especially for large ones). The file system supports file stream, so you don't have to worry about OOM problem when accessing large files.
 
 In `0.8.0` we introduced experimential Web API polyfills that make it possible to use browser-based libraries in React Native, for example, [FireBase JS SDK](https://github.com/wkh237/rn-firebase-storage-upload-sample)
 
 
 | Version | |
 |---|---|
+| 0.9.2 | Add Blob.slice() method implementation #89 |
 | 0.9.1 | Fix Android Blob constructor asynchronous issue caused by 0.9.0 fs change |
 | 0.9.0 | Fix unicode response data format issue #73. Improve Android performance by using thread pool instead of async task. Add Fetch replacement #70. Add Android only API `actionViewIntent` to open file or install APK in app |
 | 0.8.1 | Remove Web API log and fix ios progress report function. |

package.json

 {
   "name": "fetchblob-dev",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "private": true,
   "scripts": {
     "start": "node node_modules/react-native/local-cli/cli.js start",

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

     }
 
     @ReactMethod
-    public void slice(String src, String dest, int start, int end, String encode, Callback callback) {
-        RNFetchBlobFS.slice(src, dest, start, end, encode, callback);
+    public void slice(String src, String dest, int start, int end, Promise promise) {
+        RNFetchBlobFS.slice(src, dest, start, end, "", promise);
     }
 
     @ReactMethod

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

 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.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
 import java.util.ArrayList;
 import java.util.HashMap;
 
 public class RNFetchBlobBody extends RequestBody{
 
     InputStream requestStream;
-    long contentLength;
+    long contentLength = 0;
     long bytesWritten = 0;
     ReadableArray form;
     String mTaskId;
     String rawBody;
     RNFetchBlobReq.RequestType requestType;
     MediaType mime;
+    File bodyCache;
+
 
     public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, ReadableArray form, MediaType contentType) {
         this.mTaskId = taskId;
         this.form = form;
         requestType = type;
         mime = contentType;
+        try {
+            bodyCache = createMultipartBodyCache();
+            contentLength = bodyCache.length();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 
     public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, String rawBody, MediaType contentType) {
         requestType = type;
         this.rawBody = rawBody;
         mime = contentType;
+        if(rawBody != null) {
+            if(requestType == RNFetchBlobReq.RequestType.AsIs)
+                contentLength = rawBody.length();
+            else
+                contentLength = caculateOctetContentLength();
+        }
     }
 
+    @Override
+    public long contentLength() {
+        return contentLength;
+    }
     @Override
     public MediaType contentType() {
         return mime;
         BufferedSink buffer = Okio.buffer(source);
         switch (requestType) {
             case Form:
-                writeFormData(sink);
+                pipeStreamToSink(new FileInputStream(bodyCache), sink);
                 break;
             case SingleFile:
-                writeOctetData(sink);
+                if(requestStream != null)
+                    pipeStreamToSink(requestStream, sink);
                 break;
             case AsIs:
 				writeRawData(sink);
         buffer.flush();
     }
 
-	private void writeFormData(BufferedSink sink) throws IOException {
+    boolean clearRequestBody() {
+        try {
+            if (bodyCache != null && bodyCache.exists()) {
+                bodyCache.delete();
+            }
+        } catch(Exception e) {
+            RNFetchBlobUtils.emitWarningEvent(e.getLocalizedMessage());
+            return false;
+        }
+        return true;
+    }
+
+    private long caculateOctetContentLength() {
+        long total = 0;
+        // upload from storage
+        if (rawBody.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
+            String orgPath = rawBody.substring(RNFetchBlobConst.FILE_PREFIX.length());
+            orgPath = RNFetchBlobFS.normalizePath(orgPath);
+            // upload file from assets
+            if (RNFetchBlobFS.isAsset(orgPath)) {
+                try {
+                    String assetName = orgPath.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
+                    total += RNFetchBlob.RCTContext.getAssets().openFd(assetName).getLength();
+                    requestStream = RNFetchBlob.RCTContext.getAssets().open(assetName);
+                } catch (IOException e) {
+                    RNFetchBlobUtils.emitWarningEvent(e.getLocalizedMessage());
+                }
+            } else {
+                File f = new File(RNFetchBlobFS.normalizePath(orgPath));
+                try {
+                    if(!f.exists())
+                        f.createNewFile();
+                    total += f.length();
+                    requestStream = new FileInputStream(f);
+                } catch (Exception e) {
+                    RNFetchBlobUtils.emitWarningEvent("RNetchBlob error when counting content length: " +e.getLocalizedMessage());
+                }
+            }
+        } else {
+            try {
+                byte[] bytes = Base64.decode(rawBody, 0);
+                requestStream = new ByteArrayInputStream(bytes);
+                total += requestStream.available();
+            } catch(Exception ex) {
+                RNFetchBlobUtils.emitWarningEvent("RNetchBlob error when counting content length: " +ex.getLocalizedMessage());
+            }
+        }
+        return total;
+    }
+
+    /**
+     * Create a temp file that contains content of multipart form data content
+     * @return The cache file object
+     * @throws IOException
+     */
+    private File createMultipartBodyCache() throws IOException {
         String boundary = "RNFetchBlob-" + mTaskId;
+
+        File outputDir = RNFetchBlob.RCTContext.getCacheDir(); // context being the Activity pointer
+        File outputFile = File.createTempFile("rnfb-form-tmp", "", outputDir);
+        FileOutputStream os = new FileOutputStream(outputFile);
+
         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;
             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());
+                os.write(header.getBytes());
                 // file field header end
                 // upload from storage
                 if (data.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
                         try {
                             String assetName = orgPath.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
                             InputStream in = ctx.getAssets().open(assetName);
-                            pipeStreamToSink(in, sink);
+                            pipeStreamToFileStream(in, os);
                         } catch (IOException e) {
-                            Log.e("RNFetchBlob", "Failed to create form data asset :" + orgPath + ", " + e.getLocalizedMessage() );
+                            RNFetchBlobUtils.emitWarningEvent("RNFetchBlob Failed to create form data asset :" + orgPath + ", " + e.getLocalizedMessage() );
                         }
                     }
                     // data from normal files
                         File file = new File(RNFetchBlobFS.normalizePath(orgPath));
                         if(file.exists()) {
                             FileInputStream fs = new FileInputStream(file);
-                            pipeStreamToSink(fs, sink);
+                            pipeStreamToFileStream(fs, os);
                         }
                         else {
-                            Log.e("RNFetchBlob", "Failed to create form data from path :" + orgPath + "file not exists.");
+                            RNFetchBlobUtils.emitWarningEvent("RNFetchBlob Failed to create form data from path :" + orgPath + ", file not exists.");
                         }
                     }
                 }
                 // base64 embedded file content
                 else {
                     byte[] b = Base64.decode(data, 0);
-                    sink.write(b);
+                    os.write(b);
                     bytesWritten += b.length;
                     emitUploadProgress();
                 }
             else {
                 header += "Content-Disposition: form-data; name=" + name + "\r\n";
                 header += "Content-Type: " + field.mime + "\r\n\r\n";
-                sink.write(header.getBytes());
+                os.write(header.getBytes());
                 byte[] fieldData = field.data.getBytes();
                 bytesWritten += fieldData.length;
-                sink.write(fieldData);
+                os.write(fieldData);
             }
             // form end
-            sink.write("\r\n".getBytes());
+            os.write("\r\n".getBytes());
         }
         // close the form
         byte[] end = ("--" + boundary + "--\r\n").getBytes();
-        sink.write(end);
+        os.write(end);
+        os.flush();
+        os.close();
+        return outputFile;
     }
 
-    /**
-     * Write octet stream data to request body
-     * @param sink
-     */
-    private void writeOctetData(BufferedSink sink) throws IOException {
-        // upload from storage
-        if (rawBody.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
-            String orgPath = rawBody.substring(RNFetchBlobConst.FILE_PREFIX.length());
-            orgPath = RNFetchBlobFS.normalizePath(orgPath);
-            // 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();
-                    requestStream = 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();
-                    requestStream = new FileInputStream(f);
-                } catch (Exception e) {
-//                        callback.invoke(e.getLocalizedMessage(), null);
-                }
-            }
-        } else {
-            try {
-                byte[] bytes = Base64.decode(rawBody, 0);
-                contentLength = bytes.length;
-                requestStream = new ByteArrayInputStream(bytes);
-            } catch(Exception ex) {
-
-                Log.e("error", ex.getLocalizedMessage());
-            }
-        }
-        if(requestStream != null)
-            pipeStreamToSink(requestStream, sink);
-
-    }
-
-
 	/**
      * Write data to request body as-is
      * @param sink
      */
 	private void writeRawData(BufferedSink sink) throws IOException {
-		sink.write(rawBody.getBytes());
+        byte[] bytes = rawBody.getBytes();
+        contentLength = bytes.length;
+		sink.write(bytes);
 	}
 
     /**
      */
     private void pipeStreamToSink(InputStream stream, BufferedSink sink) throws IOException {
         byte [] chunk = new byte[10240];
-        int read = stream.read(chunk, 0, 10240);
-        if(read > 0) {
-            sink.write(chunk, 0, read);
-        }
-        bytesWritten += read;
-        while(read > 0) {
-            read = stream.read(chunk, 0, 10240);
+        int read;
+        while((read = stream.read(chunk, 0, 10240)) > 0) {
             if(read > 0) {
                 sink.write(chunk, 0, read);
-                bytesWritten += read;
-                emitUploadProgress();
             }
-
         }
         stream.close();
     }
 
-    private void writeBufferToSink(byte [] bytes, BufferedSink sink) throws IOException {
-        bytesWritten += bytes.length;
-        sink.write(bytes);
-        emitUploadProgress();
+    /**
+     * Pipe input stream to a file
+     * @param is    The input stream
+     * @param os    The output stream to a file
+     * @throws IOException
+     */
+    private void pipeStreamToFileStream(InputStream is, FileOutputStream os) throws IOException {
+
+        byte[] buf = new byte[10240];
+        int len;
+        while ((len = is.read(buf)) > 0) {
+            os.write(buf, 0, len);
+        }
+        is.close();
     }
 
     /**
         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")) {
+            FormField field = new FormField(form.getMap(i));
+            list.add(field);
+            String data = field.data;
+            if(data == null) {
+                RNFetchBlobUtils.emitWarningEvent("RNFetchBlob multipart request builder has found a field without `data` property, the field `"+ field.name +"` will be removed implicitly.");
+            }
+            else if (field.filename != null) {
                 // upload from storage
                 if (data.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
                     String orgPath = data.substring(RNFetchBlobConst.FILE_PREFIX.length());
                             long length = ctx.getAssets().open(assetName).available();
                             total += length;
                         } catch (IOException e) {
-
+                            RNFetchBlobUtils.emitWarningEvent(e.getLocalizedMessage());
                         }
                     }
                     // general files
             }
             // data field
             else {
-                total += field.getString("data").length();
+                total += field.data != null ? field.data.getBytes().length : 0;
             }
         }
         contentLength = total;
             else {
                 mime = filename == null ? "text/plain" : "application/octet-stream";
             }
-            if(rawData.hasKey("data"))
+            if(rawData.hasKey("data")) {
                 data = rawData.getString("data");
+            }
         }
     }
 

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

     public static final String EVENT_UPLOAD_PROGRESS = "RNFetchBlobProgress-upload";
     public static final String EVENT_PROGRESS = "RNFetchBlobProgress";
     public static final String EVENT_HTTP_STATE = "RNFetchBlobState";
+    public static final String EVENT_MESSAGE = "RNFetchBlobMessage";
     public static final String FILE_PREFIX = "RNFetchBlob-file://";
     public static final String FILE_PREFIX_BUNDLE_ASSET = "bundle-assets://";
     public static final String FILE_PREFIX_CONTENT = "content://";

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

 import android.provider.MediaStore;
 import android.util.Base64;
 
+import com.RNFetchBlob.Utils.PathResolver;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.Promise;
             in = inputStreamFromPath(path);
             out = new FileOutputStream(dest);
 
-            byte[] buf = new byte[1024];
+            byte[] buf = new byte[10240];
             int len;
             while ((len = in.read(buf)) > 0) {
                 out.write(buf, 0, len);
      * @param start Start byte offset in source file
      * @param end   End byte offset
      * @param encode
-     * @param callback
      */
-    public static void slice(String src, String dest, int start, int end, String encode, Callback callback) {
+    public static void slice(String src, String dest, int start, int end, String encode, Promise promise) {
         try {
-            long expected = end - start;
+            File source = new File(src);
+            if(!source.exists()) {
+                promise.reject("RNFetchBlob.slice error", "source file : " + src + " not exists");
+            }
+            long size = source.length();
+            long max = Math.min(size, end);
+            long expected = max - start;
             long now = 0;
             FileInputStream in = new FileInputStream(new File(src));
             FileOutputStream out = new FileOutputStream(new File(dest));
             byte [] buffer = new byte[10240];
             while(now < expected) {
                 long read = in.read(buffer, 0, 10240);
+                long remain = expected - now;
                 if(read <= 0) {
                     break;
                 }
+                out.write(buffer, 0, (int) Math.min(remain, read));
                 now += read;
-                out.write(buffer, 0, (int) read);
             }
             in.close();
+            out.flush();
             out.close();
-            callback.invoke(null, dest);
+            promise.resolve(dest);
         } catch (Exception e) {
             e.printStackTrace();
+            promise.reject(e.getLocalizedMessage());
         }
     }
 
     }
 
     public static boolean isAsset(String path) {
-        return path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET);
+        if(path != null)
+            return path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET);
+        return false;
     }
 
     public static String normalizePath(String path) {
-        if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
+        if(path == null)
+            return null;
+        Uri uri = Uri.parse(path);
+        if(uri.getScheme() == null) {
             return path;
         }
-        else if (path.startsWith(RNFetchBlobConst.FILE_PREFIX_CONTENT)) {
-            String filePath = null;
-            Uri uri = Uri.parse(path);
-            if (uri != null && "content".equals(uri.getScheme())) {
-                ContentResolver resolver = RNFetchBlob.RCTContext.getContentResolver();
-                Cursor cursor = resolver.query(uri, new String[] { MediaStore.Images.ImageColumns.DATA }, null, null, null);
-                cursor.moveToFirst();
-                filePath = cursor.getString(0);
-                cursor.close();
-            } else {
-                filePath = uri.getPath();
-            }
-            return filePath;
+        if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
+            return path;
         }
-        return path;
+        else
+            return PathResolver.getRealPathFromURI(RNFetchBlob.RCTContext, uri);
     }
 
 }

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

 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
+import java.net.SocketException;
 import java.net.SocketTimeoutException;
 import java.net.URL;
 import java.nio.ByteBuffer;
     Callback callback;
     long contentLength;
     long downloadManagerId;
+    RNFetchBlobBody requestBody;
     RequestType requestType;
     ResponseType responseType;
     WritableMap respInfo;
 
         // find cached result if `key` property exists
         String cacheKey = this.taskId;
-		String ext = this.options.appendExt != "" ? "." + this.options.appendExt : "";
+		String ext = this.options.appendExt.isEmpty() ? "." + this.options.appendExt : "";
 
        	if (this.options.key != null) {
            cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
 
         if(this.options.path != null)
             this.destPath = this.options.path;
-        else if(this.options.fileCache == true)
+        else if(this.options.fileCache)
             this.destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext;
 
         OkHttpClient.Builder clientBuilder;
             if(method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put")) {
                 String cType = getHeaderIgnoreCases(mheaders, "Content-Type").toLowerCase();
 
-                if(cType == null) {
+                if(rawRequestBodyArray != null) {
+                    requestType = RequestType.Form;
+                }
+                else if(cType.isEmpty()) {
                     builder.header("Content-Type", "application/octet-stream");
                     requestType = RequestType.SingleFile;
                 }
             // set request body
             switch (requestType) {
                 case SingleFile:
-                    builder.method(method, new RNFetchBlobBody(
+                    requestBody = new RNFetchBlobBody(
                             taskId,
                             requestType,
                             rawRequestBody,
                             MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type"))
-                    ));
+                    );
+                    builder.method(method, requestBody);
                     break;
                 case AsIs:
-                    builder.method(method, new RNFetchBlobBody(
+                    requestBody = new RNFetchBlobBody(
                             taskId,
                             requestType,
                             rawRequestBody,
                             MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type"))
-                    ));
+                    );
+                    builder.method(method, requestBody);
                     break;
                 case Form:
-                    builder.method(method, new RNFetchBlobBody(
+                    String boundary = "RNFetchBlob-" + taskId;
+                    requestBody = new RNFetchBlobBody(
                             taskId,
                             requestType,
                             rawRequestBodyArray,
-                            MediaType.parse("multipart/form-data; boundary=RNFetchBlob-" + taskId)
-                    ));
+                            MediaType.parse("multipart/form-data; boundary="+ boundary)
+                    );
+                    builder.method(method, requestBody);
                     break;
 
                 case WithoutBody:
 
             final Request req = builder.build();
 
-            // Create response body depends on the responseType
+            // Add request interceptor for upload progress event
             clientBuilder.addInterceptor(new Interceptor() {
                 @Override
                 public Response intercept(Chain chain) throws IOException {
                                 break;
                         }
                         return originalResponse.newBuilder().body(extended).build();
-                    } catch(Exception ex) {
+                    }
+                    catch(SocketException e) {
+                        timeout = true;
+                    }
+                    catch (SocketTimeoutException e ){
                         timeout = true;
+                    } catch(Exception ex) {
+                        RNFetchBlobUtils.emitWarningEvent("RNFetchBlob error when sending request : " + ex.getLocalizedMessage());
                     }
                     return chain.proceed(chain.request());
                 }
                     }
                     else
                         callback.invoke(e.getLocalizedMessage(), null, null);
-                    removeTaskInfo();
+                    releaseTaskResource();
                 }
 
                 @Override
 
         } catch (Exception error) {
             error.printStackTrace();
-            taskTable.remove(taskId);
+            releaseTaskResource();
             callback.invoke("RNFetchBlob request error: " + error.getMessage() + error.getCause());
         }
     }
     /**
      * Remove cached information of the HTTP task
      */
-    private void removeTaskInfo() {
+    private void releaseTaskResource() {
         if(taskTable.containsKey(taskId))
             taskTable.remove(taskId);
         if(uploadProgressReport.containsKey(taskId))
             uploadProgressReport.remove(taskId);
         if(progressReport.containsKey(taskId))
             progressReport.remove(taskId);
+        if(requestBody != null)
+            requestBody.clearRequestBody();
     }
 
     /**
                     // It uses customized response body which is able to report download progress
                     // and write response data to destination path.
                     resp.body().bytes();
-                } catch (Exception ignored) {}
+                } catch (Exception ignored) {
+                    ignored.printStackTrace();
+                }
                 callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 break;
             default:
                 }
                 break;
         }
-        removeTaskInfo();
-//        resp.close();
+        if(!resp.isSuccessful())
+            resp.body().close();
+        releaseTaskResource();
     }
 
     /**
                         error = ex.getLocalizedMessage();
                     }
                 }
-                this.callback.invoke(error, RNFetchBlobConst.RNFB_RESPONSE_PATH, filePath);
-                c.close();
+                else
+                    this.callback.invoke("Download manager could not resolve downloaded file path.", RNFetchBlobConst.RNFB_RESPONSE_PATH, null);
             }
         }
     }

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

 package com.RNFetchBlob;
 
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
 import java.security.MessageDigest;
 import java.security.cert.CertificateException;
 
 
     }
 
+    public static void emitWarningEvent(String data) {
+        WritableMap args = Arguments.createMap();
+        args.putString("event", "warn");
+        args.putString("detail", data);
+
+        // emit event to js context
+        RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(RNFetchBlobConst.EVENT_MESSAGE, args);
+    }
+
     public static OkHttpClient.Builder getUnsafeOkHttpClient() {
         try {
             // Create a trust manager that does not validate certificate chains

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

+package com.RNFetchBlob.Utils;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+import android.content.ContentUris;
+import android.os.Environment;
+
+public class PathResolver {
+    public static String getRealPathFromURI(final Context context, final Uri uri) {
+
+        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
+
+        // DocumentProvider
+        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                if ("primary".equalsIgnoreCase(type)) {
+                    return Environment.getExternalStorageDirectory() + "/" + split[1];
+                }
+
+                // TODO handle non-primary volumes
+            }
+            // DownloadsProvider
+            else if (isDownloadsDocument(uri)) {
+
+                final String id = DocumentsContract.getDocumentId(uri);
+                final Uri contentUri = ContentUris.withAppendedId(
+                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
+
+                return getDataColumn(context, contentUri, null, null);
+            }
+            // MediaProvider
+            else if (isMediaDocument(uri)) {
+                final String docId = DocumentsContract.getDocumentId(uri);
+                final String[] split = docId.split(":");
+                final String type = split[0];
+
+                Uri contentUri = null;
+                if ("image".equals(type)) {
+                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+                } else if ("video".equals(type)) {
+                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+                } else if ("audio".equals(type)) {
+                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+                }
+
+                final String selection = "_id=?";
+                final String[] selectionArgs = new String[] {
+                        split[1]
+                };
+
+                return getDataColumn(context, contentUri, selection, selectionArgs);
+            }
+        }
+        // MediaStore (and general)
+        else if ("content".equalsIgnoreCase(uri.getScheme())) {
+
+            // Return the remote address
+            if (isGooglePhotosUri(uri))
+                return uri.getLastPathSegment();
+
+            return getDataColumn(context, uri, null, null);
+        }
+        // File
+        else if ("file".equalsIgnoreCase(uri.getScheme())) {
+            return uri.getPath();
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context The context.
+     * @param uri The Uri to query.
+     * @param selection (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     */
+    public static String getDataColumn(Context context, Uri uri, String selection,
+                                       String[] selectionArgs) {
+
+        Cursor cursor = null;
+        final String column = "_data";
+        final String[] projection = {
+                column
+        };
+
+        try {
+            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
+                    null);
+            if (cursor != null && cursor.moveToFirst()) {
+                final int index = cursor.getColumnIndexOrThrow(column);
+                return cursor.getString(index);
+            }
+        } finally {
+            if (cursor != null)
+                cursor.close();
+        }
+        return null;
+    }
+
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     */
+    public static boolean isExternalStorageDocument(Uri uri) {
+        return "com.android.externalstorage.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     */
+    public static boolean isDownloadsDocument(Uri uri) {
+        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     */
+    public static boolean isMediaDocument(Uri uri) {
+        return "com.android.providers.media.documents".equals(uri.getAuthority());
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Photos.
+     */
+    public static boolean isGooglePhotosUri(Uri uri) {
+        return "com.google.android.apps.photos.content".equals(uri.getAuthority());
+    }
+
+}

src/fs.js

 
 }
 
+function slice(src:string, dest:string, start:number, end:number):Promise {
+  let p = Promise.resolve()
+  let size = 0
+  function normalize(num, size) {
+    if(num < 0)
+      return Math.max(0, size + num)
+    if(!num && num !== 0)
+      return size
+    return num
+  }
+  if(start < 0 || end < 0 || !start || !end) {
+    p = p.then(() => stat(src))
+         .then((stat) => {
+           size = Math.floor(stat.size)
+           start = normalize(start || 0, size)
+           end = normalize(end, size)
+           return Promise.resolve()
+         })
+  }
+  return p.then(() => RNFetchBlob.slice(src, dest, start, end))
+}
+
 function isDir(path:string):Promise<bool, bool> {
 
   return new Promise((resolve, reject) => {
   lstat,
   scanFile,
   dirs,
+  slice,
   asset
 }

src/ios/RNFetchBlob/RNFetchBlob.m

     [RNFetchBlobNetwork enableUploadProgress:taskId];
 })
 
-RCT_EXPORT_METHOD(slice:(NSString *)src dest:(NSString *)dest start:(NSNumber *)start end:(NSNumber *)end resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(slice:(NSString *)src dest:(NSString *)dest start:(nonnull NSNumber *)start end:(nonnull NSNumber *)end resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
 {
     [RNFetchBlobFS slice:src dest:dest start:start end:end encode:@"" resolver:resolve rejecter:reject];
 })

src/ios/RNFetchBlobFS.h

 + (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject onComplete:(void (^)(NSData * content))onComplete;
 + (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
-+ (void) slice:(NSString *)path dest:(NSString *)dest start:(NSNumber *)start end:(NSNumber *)end encode:(NSString *)encode resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
++ (void)slice:(NSString *)path
+         dest:(NSString *)dest
+        start:(nonnull NSNumber *)start
+          end:(nonnull NSNumber *)end
+        encode:(NSString *)encode
+     resolver:(RCTPromiseResolveBlock)resolve
+     rejecter:(RCTPromiseRejectBlock)reject;
 //+ (void) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append;
 
 // constructor

src/ios/RNFetchBlobFS.m

 }
 
 // Slice a file into another file, generally for support Blob implementation.
-- (void)slice:(NSString *)path
++ (void)slice:(NSString *)path
          dest:(NSString *)dest
-        start:(NSNumber *)start
-          end:(NSNumber *)end
-        encod:(NSString *)encode
+        start:(nonnull NSNumber *)start
+          end:(nonnull NSNumber *)end
+        encode:(NSString *)encode
      resolver:(RCTPromiseResolveBlock)resolve
      rejecter:(RCTPromiseRejectBlock)reject
 {
     // abort for the source file not exists
     if([fm fileExistsAtPath:path] == NO)
     {
-        reject(@"RNFetchBlob slice failed", @"the file does not exists", path);
+        reject(@"RNFetchBlob slice failed : the file does not exists", path, nil);
         return;
     }
     long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
-    // abort for the file size is less than start
-    if(size < start)
-    {
-        reject(@"RNFetchBlob slice failed", @"start is greater than file size", @"");
-        return;
-    }
+    long max = MIN(size, [end longValue]);
+    
     if(![fm fileExistsAtPath:dest]) {
         [fm createFileAtPath:dest contents:@"" attributes:nil];
     }
-    [handle seekToFileOffset:start];
+    [handle seekToFileOffset:[start longValue]];
     while(read < expected)
     {
-        NSData * chunk = [handle readDataOfLength:10240];
+        
+        NSData * chunk;
+        long chunkSize = 0;
+        if([start longValue] + read + 10240 > max)
+        {
+            NSLog(@"read chunk %lu", max - read - [start longValue]);
+            chunkSize = max - read - [start longValue];
+            chunk = [handle readDataOfLength:chunkSize];
+        }
+        else
+        {
+            NSLog(@"read chunk %lu", 10240);
+            chunkSize = 10240;
+            chunk = [handle readDataOfLength:10240];
+        }
+        if([chunk length] <= 0)
+            break;
+        long remain = expected - read;
+    
+        [os write:[chunk bytes] maxLength:chunkSize];
         read += [chunk length];
-        [os write:[chunk bytes] maxLength:10240];
     }
     [handle closeFile];
     [os close];

src/ios/RNFetchBlobReqBuilder.m

 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
 #import "RNFetchBlobFS.h"
+#import "RCTLog.h"
 
 @interface RNFetchBlobReqBuilder()
 {
     {
         __block int i = 0;
         __block int count = [form count];
+        // a recursive block that builds multipart body asynchornously
         void __block (^getFieldData)(id field) = ^(id field)
         {
             NSString * name = [field valueForKey:@"name"];
             NSString * content = [field valueForKey:@"data"];
             NSString * contentType = [field valueForKey:@"type"];
+            // skip when the form field `name` or `data` is empty
+            if(content == nil || name == nil)
+            {
+                i++;
+                getFieldData([form objectAtIndex:i]);
+                RCTLogWarn(@"RNFetchBlob multipart request builder has found a field without `data` or `name` property, the field will be removed implicitly.", field);
+                return;
+            }
             contentType = contentType == nil ? @"application/octet-stream" : contentType;
             // field is a text field
             if([field valueForKey:@"filename"] == nil || content == [NSNull null]) {

src/package.json

 {
   "name": "react-native-fetch-blob",
-  "version": "0.9.1",
+  "version": "0.9.2-beta.4",
   "description": "A module provides upload, download, and files access API. Supports file stream read/write for process large files.",
   "main": "index.js",
   "scripts": {

src/polyfill/Blob.js

       this.multipartBoundary = boundary
       let parts = data.getParts()
       let formArray = []
-      for(let i in parts) {
-        formArray.push('\r\n--'+boundary+'\r\n')
-        let part = parts[i]
-        for(let j in part.headers) {
-          formArray.push(j + ': ' +part.headers[j] + ';\r\n')
+      if(!parts) {
+        p = fs.writeFile(this._ref, '', 'utf8')
+      }
+      else {
+        for(let i in parts) {
+          formArray.push('\r\n--'+boundary+'\r\n')
+          let part = parts[i]
+          for(let j in part.headers) {
+            formArray.push(j + ': ' +part.headers[j] + ';\r\n')
+          }
+          formArray.push('\r\n')
+          if(part.isRNFetchBlobPolyfill)
+            formArray.push(part)
+          else
+            formArray.push(part.string)
         }
-        formArray.push('\r\n')
-        if(part.isRNFetchBlobPolyfill)
-          formArray.push(part)
-        else
-          formArray.push(part.string)
+        log.verbose('FormData array', formArray)
+        formArray.push('\r\n--'+boundary+'--\r\n')
+        p = createMixedBlobData(this._ref, formArray)
       }
-      log.verbose('FormData array', formArray)
-      formArray.push('\r\n--'+boundary+'--\r\n')
-      p = createMixedBlobData(this._ref, formArray)
     }
     // if the data is a string starts with `RNFetchBlob-file://`, append the
     // Blob data from file path
     return this
   }
 
+  markAsDerived() {
+    this._isDerived = true
+  }
+
+  get isDerived() {
+    return this._isDerived || false
+  }
+
   /**
    * Get file reference of the Blob object.
    * @nonstandard
    * @param  {string} contentType Optional, content type of new Blob object
    * @return {Blob}
    */
-  slice(start:?number, end:?number, encoding:?string):Blob {
+  slice(start:?number, end:?number, contentType='':?string):Blob {
     if(this._closed)
       throw 'Blob has been released.'
-    log.verbose('slice called', start, end, encoding)
-    console.warn('RNFB#Blob.slice() is not implemented yet, to read Blob content, use Blob.readBlob(encoding:string) instead.')
-    // TODO : fs.slice
-    // return fs.slice(this.cacheName, getBlobName(), contentType, start, end)
+    log.verbose('slice called', start, end, contentType)
+    let resPath = blobCacheDir + getBlobName()
+    let pass = false
+    log.debug('fs.slice new blob will at', resPath)
+    let result = new Blob(RNFetchBlob.wrap(resPath), { type : contentType })
+    fs.slice(this._ref, resPath, start, end).then((dest) => {
+      log.debug('fs.slice done', dest)
+      result._invokeOnCreateEvent()
+      pass = true
+    })
+    .catch((err) => {
+      pass = true
+    })
+    log.debug('slice returning new Blob')
+
+    return result
   }
 
   /**
   let size = 0
   for(let i in dataArray) {
     let part = dataArray[i]
+    if(!part)
+      continue
     if(part.isRNFetchBlobPolyfill) {
       args.push([ref, part._ref, 'uri'])
     }
       args.push([ref, part, 'ascii'])
   }
   // start write blob data
-  // return p.then(() => {
-    for(let i in args) {
-      p = p.then(function(written){
-        let arg = this
-        if(written)
-          size += written
-        log.verbose('mixed blob write', args[i], written)
-        return fs.appendFile(...arg)
-      }.bind(args[i]))
-    }
-    return p.then(() => Promise.resolve(size))
-    // let promises = args.map((p) => {
-    //   log.verbose('mixed blob write', ...p)
-    //   return fs.appendFile.call(this, ...p)
-    // })
-    // return Promise.all(promises).then((sizes) => {
-    //   log.verbose('blob write size', sizes)
-    //   for(let i in sizes) {
-    //     size += sizes[i]
-    //   }
-    //   return Promise.resolve(size)
-    // })
-  // })
+  for(let i in args) {
+    p = p.then(function(written){
+      let arg = this
+      if(written)
+        size += written
+      log.verbose('mixed blob write', args[i], written)
+      return fs.appendFile(...arg)
+    }.bind(args[i]))
+  }
+  return p.then(() => Promise.resolve(size))
 }

src/polyfill/Fetch.js

     this.rnfbResp = resp
   }
 
+  rawResp() {
+    return Promise.resolve(this.rnfbResp)
+  }
+
   arrayBuffer(){
     log.verbose('to arrayBuffer', this.rnfbRespInfo)
     this.bodyUsed = true

src/polyfill/XMLHttpRequest.js

 const log = new Log('XMLHttpRequest')
 
 log.disable()
-// log.level(3)
+// log.level(2)
 
 const UNSENT = 0
 const OPENED = 1
   }
 
   constructor() {
-    super()
     log.verbose('XMLHttpRequest constructor called')
+    super()
   }
 
 
    * @param  {any} body Body in RNfetchblob flavor
    */
   send(body) {
-
+    this._body = body
     if(this._readyState !== XMLHttpRequest.OPENED)
       throw 'InvalidStateError : XMLHttpRequest is not opened yet.'
     let promise = Promise.resolve()
     log.verbose(typeof body, body instanceof FormData)
 
     if(body instanceof Blob) {
+      log.debug('sending blob body', body._blobCreated)
       promise = new Promise((resolve, reject) => {
           body.onCreated((blob) => {
-            body = RNFetchBlob.wrap(body.getRNFetchBlobRef())
-            resolve()
+              log.debug('body created send request')
+              body = RNFetchBlob.wrap(blob.getRNFetchBlobRef())
+              resolve()
           })
         })
     }
     }
 
     promise.then(() => {
+      log.debug('send request invoke', body)
+      for(let h in _headers) {
+        _headers[h] = _headers[h].toString()
+      }
       this._task = RNFetchBlob
                     .config({
                       auto: true,
   }
 
   getResponseHeader(field:string):string | null {
-    log.verbose('XMLHttpRequest get header', field)
+    log.verbose('XMLHttpRequest get header', field, this._responseHeaders)
     if(!this._responseHeaders)
       return null
-    return this.responseHeaders[field] || null
+    return (this._responseHeaders[field] || this._responseHeaders[field.toLowerCase()]) || null
 
   }
 
     let result = ''
     let respHeaders = this.responseHeaders
     for(let i in respHeaders) {
-      result += `${i}:${respHeaders[i]}\r\n`
+      result += `${i}: ${respHeaders[i]}${String.fromCharCode(0x0D,0x0A)}`
     }
-    return result
+    return result.substr(0, result.length-2)
   }
 
   _headerReceived(e) {
     }
     if(resp) {
       let info = resp.respInfo || {}
+      log.debug(this._url, info, info.respType)
       switch(info.respType) {
         case 'json' :
+        try{
           this._responseText = resp.text()
           this._response = resp.json()
           responseDataReady()
+        } catch(err) {
+        }
         break;
         case 'blob' :
           resp.blob().then((b) => {
           })
         break;
         default :
-        console.log(resp, resp.text())
           this._responseText = resp.text()
           this._response = this.responseText
           responseDataReady()
   }
 
   set onreadystatechange(fn:() => void) {
-    log.verbose('XMLHttpRequest set onreadystatechange', fn.toString())
+    log.verbose('XMLHttpRequest set onreadystatechange', fn)
     this._onreadystatechange = fn
   }
 
     return this._responseType
   }
 
+  get isRNFBPolyfill() {
+    return true
+  }
+
 }

test-server/server.js

     console.log('SSL test server running at port ',8124)
 })
 
+app.disable('etag')
+
 // http
 app.listen(8123, function(err){
   if(!err)
   res.status(Math.floor(req.params.code)).send()
 })
 
+app.all('/content-length', (req, res) => {
+  console.log(req.headers)
+  res.send(req.headers['Content-Length'])
+})
+
 app.all('/xhr-header', (req, res) => {
   console.log(req.headers)
   // res.header('Content-Type', 'application/json')

test/test-0.5.2.js

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

test/test-0.6.2.js

   .config({fileCache : true})
   .fetch('GET', `${TEST_SERVER_URL}/public/beethoven.mp3`)
   .then((resp) => {
-    return RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/mime`, null, [
+    return RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/mime`, {
+      'Content-Type' : 'multipart/form-data'
+    }, [
       { name : 'image', filename : 'image', type : 'image/jpeg', data : RNFetchBlob.base64.encode('123456') },
       { name : 'mp3', filename : 'mp3', type : 'application/mp3', data : RNFetchBlob.base64.encode('123456') },
       { name : 'mp3', filename : 'mp3', data : RNFetchBlob.base64.encode('123456') },

test/test-0.7.0.js

   RNFetchBlob.config({
     fileCache : true
   })
-  .fetch('GET', `${TEST_SERVER_URL}/public/22mb-dummy`)
+  .fetch('GET', `${TEST_SERVER_URL}/public/1mb-dummy`)
   .progress((now, total) => {
     if(begin === -1)
       begin = Date.now()
       report(<Assert key="task cancelled rejection should be catachable"
         expect={true}
         actual={true}/>)
+      done()
     })
 
 })

test/test-0.9.0.js

 const describe = RNTest.config({
   group : '0.9.0',
   run : true,
-  expand : true,
+  expand : false,
   timeout : 20000,
 })
 const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, FILENAME, DROPBOX_TOKEN, styles } = prop()

test/test-0.9.2.js

+import RNTest from './react-native-testkit/'
+import React from 'react'
+import RNFetchBlob from 'react-native-fetch-blob'
+import {
+  StyleSheet,
+  Text,
+  View,
+  ScrollView,
+  Platform,
+  Dimensions,
+  Image,
+} from 'react-native';
+
+window.XMLHttpRequest = RNFetchBlob.polyfill.XMLHttpRequest
+window.Blob = RNFetchBlob.polyfill.Blob
+window.fetch = new RNFetchBlob.polyfill.Fetch({
+  auto : true,
+  binaryContentTypes : ['image/', 'video/', 'audio/']
+}).build()
+
+const fs = RNFetchBlob.fs
+const { Assert, Comparer, Info, prop } = RNTest
+const describe = RNTest.config({
+  group : '0.9.2',
+  run : true,
+  expand : true,
+  timeout : 20000,
+})
+const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, FILENAME, DROPBOX_TOKEN, styles } = prop()
+const dirs = RNFetchBlob.fs.dirs
+
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
+
+describe('content-length header test', (report, done) => {
+  RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/content-length`, {
+    'Content-Type' : 'text/plain',
+    'Content-Length' : '5'
+  }, 'hello')
+  .then((res) => {
+    report(
+      <Info key="response data">
+        <Text>{res.text()}</Text>
+      </Info>)
+    done()
+  })
+})
+
+describe('slice test', (report, done) => {
+  let str = "PASSSTRING"
+  let tmp = fs.dirs.DocumentDir + '/slice-tmp-'
+  let testData = [
+       {start:   4, contents: "STRING"},
+       {start:  12, contents: ""},
+       {start: 0, end:   4, contents: "PASS"},
+       {start: 0, end:  12, contents: "PASSSTRING"},
+       {start: 7, end:   4, contents: ""},
+       {start:  -6, contents: "STRING"},
+       {start: -12, contents: "PASSSTRING"},
+       {start: 0, end:  -6, contents: "PASS"},
+       {start: 0, end: -12, contents: ""},
+     ]
+  fs.writeFile(tmp, str, 'utf8')
+    .then(() => {
+      let promises = []
+      for(let t in testData) {
+        let p = fs.slice(tmp, tmp + t, testData[t].start, testData[t].end)
+        .then(function(num) {
+          console.log('slice finished', num)
+          return fs.readFile(tmp + num, 'utf8')
+          .then((data) => {
+            report(<Assert key={`assertion-${num}`} expect={testData[num].contents} actual={data}/>)
+            return Promise.resolve()
+          })
+        }.bind(this, t))
+        promises.push(p)
+      }
+      Promise.all(promises).then((res) => {
+        done()
+      })
+
+    })
+})
+
+describe('Upload multipart/form-data', (report, done) => {
+  let image = RNTest.prop('image')
+  RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/upload-form`, {
+      Authorization : "Bearer fsXcpmKPrHgAAAAAAAAAEGxFXwhejXM_E8fznZoXPhHbhbNhA-Lytbe6etp1Jznz",
+      'Content-Type' : 'multipart/form-data',
+    }, [
+      { name : 'test-img', filename : 'test-img.png', data: image},
+      { name : 'test-text', filename : 'test-text.txt', data: RNFetchBlob.base64.encode('hello.txt')},
+      { name : 'field1', data : 'hello !!'},
+      { 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}/>,
+    )
+    done()
+  })
+})
+
+describe('app should not crash when sending formdata without data field', (report, done) => {
+
+  RNFetchBlob.fetch('POST', `${TEST_SERVER_URL}/upload-form`, {
+      Authorization : "Bearer fsXcpmKPrHgAAAAAAAAAEGxFXwhejXM_E8fznZoXPhHbhbNhA-Lytbe6etp1Jznz",
+      'Content-Type' : 'multipart/form-data',
+    }, [
+      { name : 'empty-file', filename : 'test-img.png'},
+      { name : 'empty-data'},
+      { name : 'field2', data : 'hello2 !!'}
+    ])
+  .then((resp) => {
+    console.log(resp.json())
+    resp = resp.json()
+
+    report(
+      <Assert key="check posted form data #1" expect={undefined} actual={resp.fields['empty-file']}/>,
+      <Assert key="check posted form data #2" expect={undefined} actual={resp.fields['empty-data']}/>,
+      <Assert key="check posted form data #3" expect="hello2 !!" actual={resp.fields.field2}/>,
+    )
+    done()
+  })
+})

test/test-blob.js

         done()
       })
 })
+
+// since 0.9.2
+// test case from :
+// https://github.com/w3c/web-platform-tests/blob/master/FileAPI/blob/Blob-slice.html
+describe('#89 Blob.slice test', (report, done) => {
+
+  let blob1, blob2
+  let count = 0
+  let testData
+
+  Blob
+    .build(["squiggle"])
+    .then((b) => {
+      blob1 = b
+      return Blob.build(["steak"], {type: "content/type"})
+    })
+    .then((b) => {
+      blob2 = b
+      setTestData()
+      startTest()
+    })
+
+  function setTestData() {
+    testData = [
+      [
+        ["PASSSTRING"],
+        [{start:  -6, contents: "STRING"},
+         {start: -12, contents: "PASSSTRING"},
+         {start:   4, contents: "STRING"},
+         {start:  12, contents: ""},
+         {start: 0, end:  -6, contents: "PASS"},
+         {start: 0, end: -12, contents: ""},
+         {start: 0, end:   4, contents: "PASS"},
+         {start: 0, end:  12, contents: "PASSSTRING"},
+         {start: 7, end:   4, contents: ""}]
+      ],
+      // Test 3 strings
+      [
+        ["foo", "bar", "baz"],
+        [{start:  0, end:  9, contents: "foobarbaz"},
+         {start:  0, end:  3, contents: "foo"},
+         {start:  3, end:  9, contents: "barbaz"},
+         {start:  6, end:  9, contents: "baz"},
+         {start:  6, end: 12, contents: "baz"},
+         {start:  0, end:  9, contents: "foobarbaz"},
+         {start:  0, end: 11, contents: "foobarbaz"},
+         {start: 10, end: 15, contents: ""}]
+      ],
+      // Test string, Blob, string
+      [
+        ["foo", blob1, "baz"],
+        [{start:  0, end:  3, contents: "foo"},
+         {start:  3, end: 11, contents: "squiggle"},
+         {start:  2, end:  4, contents: "os"},
+         {start: 10, end: 12, contents: "eb"}]
+      ],
+      // Test blob, string, blob
+      [
+        [blob1, "foo", blob1],
+        [{start:  0, end:  8, contents: "squiggle"},
+         {start:  7, end:  9, contents: "ef"},
+         {start: 10, end: 12, contents: "os"},
+         {start:  1, end:  4, contents: "qui"},
+         {start: 12, end: 15, contents: "qui"},
+         {start: 40, end: 60, contents: ""}]
+      ],
+      // Test blobs all the way down
+      [
+        [blob2, blob1, blob2],
+        [{start: 0,  end:  5, contents: "steak"},
+         {start: 5,  end: 13, contents: "squiggle"},
+         {start: 13, end: 18, contents: "steak"},
+         {start:  1, end:  3, contents: "te"},
+         {start:  6, end: 10, contents: "quig"}]
+      ]
+    ]
+  }
+
+  function startTest() {
+    Promise.all(testData.map(assert)).then(done)
+  }
+
+  function assert(d):Promise {
+    let content = d[0]
+    let assertions = d[1]
+    console.log('create blob content = ', content)
+    Blob.build(content).then((b) => {
+      for(let i in assertions) {
+        let args = assertions[i]
+        let target = b.slice(args.start, args.end)
+        target.onCreated((b2) => {
+          let raw = null
+          fs.readFile(b.blobPath, 'utf8').then((data) => {
+            raw = data
+            fs.readFile(b2.blobPath, 'utf8')
+              .then(function(actual){
+                console.log('---')
+                console.log('raw',data)
+                console.log('expect', this.contents)
+                console.log('actual', actual)
+                report(<Assert key={`assertion ${++count}`} expect={this.contents} actual={actual}/>)
+              }.bind(args))
+          })
+
+        })
+      }
+    })
+
+  }
+
+})

test/test-firebase.js

 } from 'react-native';
 
 const fs = RNFetchBlob.fs
-const Blob = RNFetchBlob.polyfill.Blob
 
 window.XMLHttpRequest = RNFetchBlob.polyfill.XMLHttpRequest
-window.Blob = Blob
+window.Blob = RNFetchBlob.polyfill.Blob
 
 const { Assert, Comparer, Info, prop } = RNTest
 const describe = RNTest.config({
   group : 'firebase',
   run : true,
-  expand : false,
+  expand : true,
   timeout : 300000000,
 })
 const { TEST_SERVER_URL, TEST_SERVER_URL_SSL, DROPBOX_TOKEN, styles } = prop()
   databaseURL: "https://rnfb-test-app.firebaseio.com",
   storageBucket: "rnfb-test-app.appspot.com",
 };
-firebase.initializeApp(config);
+
 
 describe('firebase login', (report, done) => {
 
+  firebase.initializeApp(config);
   firebase.auth().signInWithEmailAndPassword('xeiyan@gmail.com', 'rnfbtest1024')
     .catch((err) => {
       console.log('firebase sigin failed', err)
 describe('upload using file path', (report, done) => {
   RNFetchBlob
     .config({ fileCache : true, appendExt : 'jpg' })
-    .fetch('GET', `${TEST_SERVER_URL}/public/github2.jpg`)
+    .fetch('GET', `${TEST_SERVER_URL}/public/500k-img-dummy.jpg`)
     .then((resp) => {
       report(<Info key="test image">
         <Image style={styles.image} source={{uri : prefix + resp.path()}}/>

test/test-fs.js

   Text,
   View,
   ScrollView,
+  Platform,
   Dimensions,
   Image,
 } from 'react-native';
 
 let { TEST_SERVER_URL, FILENAME, DROPBOX_TOKEN, styles, image } = prop()
 let dirs = RNFetchBlob.fs.dirs
+let prefix = ((Platform.OS === 'android') ? 'file://' : '')
 
 describe('Get storage folders', (report, done) => {
   report(
 
 })
 
+describe('fs.slice test', (report, done) => {
+
+  let source = null
+  let parts = fs.dirs.DocumentDir + '/tmp-source-'
+  let dests = []
+  let combined = fs.dirs.DocumentDir + '/combined-' + Date.now() + '.jpg'
+  let size = 0
+
+  window.fetch = new RNFetchBlob.polyfill.Fetch({
+    auto : true,
+    binaryContentTypes : ['image/', 'video/', 'audio/']
+  }).build()
+
+  fetch(`${TEST_SERVER_URL}/public/github2.jpg`)
+  .then((res) => res.rawResp())
+  .then((res) => {
+    source = res.path()
+    return fs.stat(source)
+  })
+  // separate file into 4kb chunks
+  .then((stat) => {
+    size = stat.size
+    let promise = Promise.resolve()
+    let cursor = 0
+    while(cursor < size) {
+      promise = promise.then(function(start) {
+        console.log('slicing part ', start , start + 40960)
+        let offset = 0
+        return fs.slice(source, parts + start, start + offset, start + 40960)
+                .then((dest) => {
+                  console.log('slicing part ', start + offset, start + 40960, 'done')
+                  dests.push(dest)
+                  return Promise.resolve()
+                })
+      }.bind(this, cursor))
+      cursor += 40960
+    }
+    console.log('loop end')
+    return promise
+  })
+  // combine chunks and verify the result
+  .then(() => {
+    console.log('combinding files')
+    let p = Promise.resolve()
+    for(let d in dests) {
+      p = p.then(function(chunk){
+        return fs.appendFile(combined, chunk, 'uri').then((write) => {
+          console.log(write, 'bytes write')
+        })
+      }.bind(this, dests[d]))
+    }
+    return p.then(() => fs.stat(combined))
+  })
+  .then((stat) => {
+    report(
+      <Assert key="verify file size" expect={size} actual={stat.size}/>,
+      <Info key="image viewer">
+        <Image key="combined image" style={styles.image} source={{ uri : prefix + combined}}/>
+      </Info>)
+    done()
+  })
+
+})
+
+
 function getASCIIArray(str) {
   let r = []
   for(let i=0;i<str.length;i++) {

test/test-init.js

 require('./test-0.5.2')
 require('./test-0.6.0')
 require('./test-0.6.2')
-require('./test-0.6.3')
 require('./test-0.7.0')
 require('./test-0.8.0')
 require('./test-0.9.0')
+require('./test-0.9.2')
 require('./test-fetch')
 require('./test-fs')
 require('./test-xmlhttp')
 require('./test-blob')
 require('./test-firebase')
 require('./test-android')
+// require('./test-stress')
 // require('./benchmark')

test/test-0.6.3.js → test/test-stress.js

 const fs = RNFetchBlob.fs
 const { Assert, Comparer, Info, prop } = RNTest
 const describe = RNTest.config({
-  group : '0.6.3',
+  group : 'stress test',
   run : true,
   expand : true,
   timeout : 300000000,

test/test-xmlhttp.js

   let xhr = new XMLHttpRequest()
   xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
   xhr.setRequestHeader('value', '100')
+  xhr.setRequestHeader('cache-control', 'no-store')
   xhr.open('GET', `${TEST_SERVER_URL}/xhr-header`)
   xhr.setRequestHeader('value', '200')
   xhr.send()
   xhr.onreadystatechange = function() {
     if(this.readyState == 4) {
       report(<Assert key="headers should be cleared by open()"
-        expect={'200'}
+        expect={"200"}
         actual={this.response.value}/>)
       done()
     }