0.7.0 Android code refactor

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

     }
 
     @ReactMethod
-    public void cancel(String taskId) {
-        RNFetchBlobReq.cancelTask(taskId);
+    public void cancelRequest(String taskId, Callback callback) {
+        try {
+            RNFetchBlobReq.cancelTask(taskId);
+            callback.invoke(null, taskId);
+        } catch (Exception ex) {
+            callback.invoke(ex.getLocalizedMessage(), null);
+        }
     }
 
     @ReactMethod

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

 package com.RNFetchBlob;
 
-import android.net.Uri;
 import android.util.Base64;
 import android.util.Log;
 
 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.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import okhttp3.RequestBody;
 import okio.Buffer;
 import okio.BufferedSink;
-import okio.ByteString;
 import okio.ForwardingSink;
 import okio.Okio;
 import okio.Sink;
     long bytesWritten = 0;
     ReadableArray form;
     String mTaskId;
+    String rawBody;
     RNFetchBlobReq.RequestType requestType;
     MediaType mime;
 
-    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, ReadableArray form, InputStream stream, long size, MediaType contentType) {
+    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, ReadableArray form, MediaType contentType) {
         this.mTaskId = taskId;
         this.form = form;
-        requestStream = stream;
-        contentLength = size;
         requestType = type;
         mime = contentType;
     }
 
+    public RNFetchBlobBody(String taskId, RNFetchBlobReq.RequestType type, String rawBody, MediaType contentType) {
+        this.mTaskId = taskId;
+        requestType = type;
+        this.rawBody = rawBody;
+        mime = contentType;
+    }
+
     @Override
     public MediaType contentType() {
         return mime;
     @Override
     public void writeTo(BufferedSink sink) throws IOException {
 
-        ProgressReportingSource source = new ProgressReportingSource(sink, mTaskId, contentLength());
+        ProgressReportingSource source = new ProgressReportingSource(sink, mTaskId);
         BufferedSink buffer = Okio.buffer(source);
         switch (requestType) {
             case Form:
-                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) {
-                                    Log.e("RNFetchBlob", "Failed to create form data asset :" + orgPath + ", " + e.getLocalizedMessage() );
-                                }
-                            }
-                            // data from normal files
-                            else {
-                                File file = new File(RNFetchBlobFS.normalizePath(orgPath));
-                                if(file.exists()) {
-                                    FileInputStream fs = new FileInputStream(file);
-                                    pipeStreamToSink(fs, sink);
-                                }
-                                else {
-                                    Log.e("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);
-                            bytesWritten += b.length;
-                            emitUploadProgress(bytesWritten, contentLength);
-                        }
+                writeFormData(sink);
+                break;
+            case SingleFile:
+                writeOctetData(sink);
+                break;
+        }
+        buffer.flush();
+    }
 
+    private void writeFormData(BufferedSink sink) throws IOException {
+        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) {
+                            Log.e("RNFetchBlob", "Failed to create form data asset :" + orgPath + ", " + e.getLocalizedMessage() );
+                        }
                     }
-                    // data field
+                    // data from normal files
                     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);
+                        File file = new File(RNFetchBlobFS.normalizePath(orgPath));
+                        if(file.exists()) {
+                            FileInputStream fs = new FileInputStream(file);
+                            pipeStreamToSink(fs, sink);
+                        }
+                        else {
+                            Log.e("RNFetchBlob", "Failed to create form data from path :" + orgPath + "file not exists.");
+                        }
                     }
-                    // form end
-                    sink.write("\r\n".getBytes());
                 }
-                // close the form
-                byte[] end = ("--" + boundary + "--\r\n").getBytes();
-                sink.write(end);
-                break;
-            case SingleFile:
-                pipeStreamToSink(requestStream, sink);
-                break;
+                // base64 embedded file content
+                else {
+                    byte[] b = Base64.decode(data, 0);
+                    sink.write(b);
+                    bytesWritten += b.length;
+                    emitUploadProgress();
+                }
+
+            }
+            // 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());
         }
-        buffer.flush();
+        // close the form
+        byte[] end = ("--" + boundary + "--\r\n").getBytes();
+        sink.write(end);
+    }
+
+    /**
+     * 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 {
+            byte[] bytes = Base64.decode(rawBody, 0);
+            contentLength = bytes.length;
+            requestStream = new ByteArrayInputStream(bytes);
+        }
+        if(requestStream != null)
+            pipeStreamToSink(requestStream, sink);
+
     }
 
+    /**
+     * Pipe input stream to request body output stream
+     * @param stream    The input stream
+     * @param sink      The request body buffer sink
+     * @throws IOException
+     */
     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;
-                emitUploadProgress(bytesWritten, contentLength);
+                emitUploadProgress();
             }
 
         }
         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);
+    private void writeBufferToSink(byte [] bytes, BufferedSink sink) throws IOException {
+        bytesWritten += bytes.length;
+        sink.write(bytes);
+        emitUploadProgress();
     }
 
-
-
     /**
-     * Compute a proximate content length for form data
+     * Compute approximate content length for form data
      * @return
      */
     private ArrayList<FormField> countFormDataLength() {
         return list;
     }
 
+    /**
+     * Since ReadableMap could only be access once, we have to store the field into a map for
+     * repeatedly access.
+     */
     private class FormField {
         public String name;
         public String filename;
         }
     }
 
+    private void emitUploadProgress() {
+        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);
+    }
+
     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) {
+        public ProgressReportingSource (Sink delegate, String taskId) {
             super(delegate);
             this.mTaskId = taskId;
-            this.mContentLength = contentLength;
             this.delegate = delegate;
         }
 
             WritableMap args = Arguments.createMap();
             args.putString("taskId", mTaskId);
             args.putString("written", String.valueOf(bytesWritten));
-            args.putString("total", String.valueOf(mContentLength ));
+            args.putString("total", String.valueOf(contentLength));
 
             // emit event to js context
             RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)

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

             // set request body
             switch (requestType) {
                 case SingleFile:
-                    InputStream dataStream = buildOctetBody(rawRequestBody);
                     builder.method(method, new RNFetchBlobBody(
                             taskId,
                             RequestType.SingleFile,
-                            null,
-                            dataStream,
-                            contentLength,
+                            rawRequestBody,
                             RNFetchBlobConst.MIME_OCTET
                     ));
                     break;
                             taskId,
                             RequestType.Form,
                             rawRequestBodyArray,
-                            null,
-                            0,
                             MediaType.parse("multipart/form-data; boundary=RNFetchBlob-" + taskId)
                     ));
                     break;
 
     }
 
-    /**
-     * Get InputStream of request body when request body contains a single file.
-     *
-     * @param body Body in string format
-     * @return InputStream When there's no request body, returns null
-     */
-    InputStream buildOctetBody(String body) {
-        // set body for POST and PUT
-        if (body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
-            this.contentType = RNFetchBlobConst.MIME_OCTET;
-            byte[] blob;
-            // upload from storage
-            if (body.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
-                String orgPath = body.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();
-                        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 (Exception e) {
-                        callback.invoke(e.getLocalizedMessage(), null);
-                    }
-                }
-            } else {
-                byte[] bytes = Base64.decode(body, 0);
-                contentLength = bytes.length;
-                return new ByteArrayInputStream(bytes);
-            }
-        }
-        return null;
-
-    }
-
     @Override
     public void onReceive(Context context, Intent intent) {
         String action = intent.getAction();

src/index.js

 
   })
 
-  // extend Promise object, add a `progress` method for register progress event
-  // handler.
+  // extend Promise object, add `progress`, `uploadProgress`, and `cancel`
+  // method for register progress event handler and cancel request.
   promise.progress = (fn) => {
     promise.onProgress = fn
     return promise
   }
-
   promise.uploadProgress = (fn) => {
     promise.onUploadProgress = fn
     return promise
   }
+  promise.cancel = (fn) => {
+    RNFetchBlob.cancelRequest(taskId, fn)
+  }
 
   return promise
 

test/test-0.6.3.js

   })
 
 })
-
-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', '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()
-  })
-})