Add Android fixed length request implementation #94

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) {
         mime = contentType;
     }
 
+    @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 {
+    private void 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, "");
+                    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());
+            }
+        }
+    }
+
+    /**
+     * 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() );
                         }
                         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.");
                 // 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);
-    }
-
-    /**
-     * 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);
-
+        os.write(end);
+        os.flush();
+        os.close();
+        return outputFile;
     }
 
-
 	/**
      * 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();
     }
 
     /**
             }
             // data field
             else {
-                total += field.data != null ? field.data.length() : 0;
+                total += field.data != null ? field.data.getBytes().length : 0;
             }
         }
         contentLength = total;

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

                     ));
                     break;
                 case Form:
+                    String boundary = "RNFetchBlob-" + taskId;
                     builder.method(method, new RNFetchBlobBody(
                             taskId,
                             requestType,
                             rawRequestBodyArray,
-                            MediaType.parse("multipart/form-data; boundary=RNFetchBlob-" + taskId)
+                            MediaType.parse("multipart/form-data; boundary="+ boundary)
                     ));
                     break;
 
                         }
                         return originalResponse.newBuilder().body(extended).build();
                     } catch(Exception ex) {
-                        timeout = true;
+                        RNFetchBlobUtils.emitWarningEvent(ex.getLocalizedMessage());
                     }
                     return chain.proceed(chain.request());
                 }
                     // 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:

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