Add android #2 implementation

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

 package com.RNFetchBlob;
 
 import android.net.Uri;
-import android.text.style.AlignmentSpan;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.loopj.android.http.AsyncHttpClient;
 import com.loopj.android.http.AsyncHttpResponseHandler;
 import com.loopj.android.http.Base64;
-import com.loopj.android.http.BinaryHttpResponseHandler;
 import com.loopj.android.http.RequestParams;
 
 import java.io.ByteArrayOutputStream;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
+import java.io.File;
 
-import cz.msebera.android.httpclient.Header;
-import cz.msebera.android.httpclient.entity.BufferedHttpEntity;
 import cz.msebera.android.httpclient.entity.ByteArrayEntity;
-import cz.msebera.android.httpclient.entity.ContentType;
-import cz.msebera.android.httpclient.entity.StringEntity;
-import cz.msebera.android.httpclient.message.BasicHeader;
-import cz.msebera.android.httpclient.protocol.HTTP;
 
 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
     }
 
     @ReactMethod
-    public void fetchBlob(String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
+    public void flush(String taskId) {
+        try {
+            new File(RNFetchBlobFS.TempFilePath + taskId).delete();
+        } catch(Exception err) {
+            WritableMap args = Arguments.createMap();
+            args.putString("event", "error");
+            args.putString("detail", err.getMessage());
+            this.getReactApplicationContext()
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit("RNFetchBlobMessage", args);
+        }
+    }
+
+    @ReactMethod
+    public void readStream(String taskId, String encoding) {
+        RNFetchBlobFS fs = new RNFetchBlobFS(this.getReactApplicationContext());
+        fs.readStream(taskId, encoding);
+    }
+
+    @ReactMethod
+    public void fetchBlob(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
 
         try {
             Uri uri = Uri.parse(url);
                 entity.setContentType(headers.getString("Content-Type"));
             }
 
+            AsyncHttpResponseHandler handler;
+
             // create handler
-            AsyncHttpResponseHandler handler = new RNFetchBlobHandler(this.getReactApplicationContext(), taskId, callback);
+            if(options.getBoolean("fileCache") || options.getString("path") != null)
+                handler = new RNFetchBlobFileHandler(this.getReactApplicationContext(), taskId, callback);
+            else
+                handler = new RNFetchBlobBinaryHandler(this.getReactApplicationContext(), taskId, callback);
 
             // send request
             switch(method.toLowerCase()) {
     }
 
     @ReactMethod
-    public void fetchBlobForm(String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
+    public void fetchBlobForm(ReadableMap options, String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
 
         try {
             Uri uri = Uri.parse(url);
                 req.addHeader("Content-Type", headers.getString("Content-Type") + "; charset=utf8; boundary=" + boundary);
             }
 
+            AsyncHttpResponseHandler handler;
+
             // create handler
-            AsyncHttpResponseHandler handler = new RNFetchBlobHandler(this.getReactApplicationContext(), taskId, callback);
+            if(options.getBoolean("fileCache") || options.getString("path") != null)
+                handler = new RNFetchBlobFileHandler(this.getReactApplicationContext(), taskId, callback);
+            else
+                handler = new RNFetchBlobBinaryHandler(this.getReactApplicationContext(), taskId, callback);
 
             // send request
             switch(method.toLowerCase()) {

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

 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.loopj.android.http.AsyncHttpResponseHandler;
 import com.loopj.android.http.Base64;
+import com.loopj.android.http.FileAsyncHttpResponseHandler;
+
+import java.io.File;
 
 import cz.msebera.android.httpclient.Header;
 
-public class RNFetchBlobHandler extends AsyncHttpResponseHandler {
+public class RNFetchBlobBinaryHandler extends AsyncHttpResponseHandler {
 
     Callback onResponse;
     ReactContext mCtx;
     String mTaskId;
 
-    RNFetchBlobHandler(ReactContext ctx, String taskId, Callback onResponse) {
+    RNFetchBlobBinaryHandler(ReactContext ctx, String taskId, Callback onResponse) {
 
         this.onResponse = onResponse;
         this.mTaskId = taskId;
 
         // emit event to js context
         this.mCtx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                 .emit("RNFetchBlobProgress", args);
+                .emit("RNFetchBlobProgress", args);
     }
 
     @Override
     public void onFailure(final int statusCode, final Header[] headers, byte[] binaryData, final Throwable error) {
         this.onResponse.invoke(statusCode, error.getMessage()+ ", "+ error.getCause());
     }
+
 }

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

+package com.RNFetchBlob;
+
+import android.os.Environment;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.loopj.android.http.Base64;
+
+import java.io.FileInputStream;
+
+import cz.msebera.android.httpclient.util.EncodingUtils;
+
+/**
+ * Created by wkh237 on 2016/5/26.
+ */
+public class RNFetchBlobFS {
+
+    static String DocumentDir = Environment.getExternalStorageDirectory().toString();
+    static String TempFilePath = Environment.getExternalStorageDirectory().toString() + "/RNFetchBlobCache/dltmp";
+
+    ReactApplicationContext mCtx;
+    DeviceEventManagerModule.RCTDeviceEventEmitter emitter;
+
+
+    RNFetchBlobFS(ReactApplicationContext ctx) {
+        this.mCtx = ctx;
+        this.emitter = ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    }
+
+    public void readStream(String taskId, String encoding) {
+        try {
+
+            FileInputStream fs = mCtx.openFileInput(RNFetchBlobFS.TempFilePath + taskId);
+            byte[] buffer = new byte[1024];
+            int cursor = 0;
+            boolean error = false;
+
+            if (encoding.toLowerCase() == "utf8") {
+                while ((cursor = fs.read(buffer)) != -1) {
+                    String chunk = new String(buffer, 0, cursor, "UTF-8");
+                    emitFSData(taskId, "data", chunk);
+                }
+            } else if (encoding.toLowerCase() == "ascii") {
+                while ((cursor = fs.read(buffer)) != -1) {
+                    String chunk = EncodingUtils.getAsciiString(buffer, 0, cursor);
+                    emitFSData(taskId, "data", chunk);
+                }
+            } else if (encoding.toLowerCase() == "base64") {
+                while ((cursor = fs.read(buffer)) != -1) {
+                    emitFSData(taskId, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
+                }
+            } else {
+                String msg = "unrecognized encoding `" + encoding + "`";
+                emitFSData(taskId, "error", msg);
+                error = true;
+            }
+
+            if(!error)
+                emitFSData(taskId, "end", "");
+
+        } catch (Exception err) {
+            emitFSData(taskId, "error", err.getLocalizedMessage());
+        }
+
+    }
+
+    void emitFSData(String taskId, String event, String data) {
+        WritableMap eventData = Arguments.createMap();
+        eventData.putString("event", event);
+        eventData.putString("detail", data);
+        this.emitter.emit("RNFetchBlobStream" + taskId, eventData);
+    }
+}
+
+

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

+package com.RNFetchBlob;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.loopj.android.http.FileAsyncHttpResponseHandler;
+
+import java.io.File;
+
+import cz.msebera.android.httpclient.Header;
+
+/**
+ * Created by wkh237 on 2016/5/26.
+ */
+public class RNFetchBlobFileHandler extends FileAsyncHttpResponseHandler {
+
+    Callback onResponse;
+    ReactContext mCtx;
+    String mTaskId;
+
+    RNFetchBlobFileHandler(ReactContext ctx, String taskId, Callback onResponse) {
+        // save temp file to RNFetchBlobCache/dltmp${taskId}
+        super(new File(RNFetchBlobFS.TempFilePath + taskId), false, false);
+        this.onResponse = onResponse;
+        this.mTaskId = taskId;
+        this.mCtx = ctx;
+    }
+
+    @Override
+    public void onFailure(int statusCode, Header[] headers, Throwable throwable, File file) {
+        this.onResponse.invoke(statusCode, throwable.getMessage()+ ", "+ throwable.getCause());
+    }
+
+    @Override
+    public void onProgress(long bytesWritten, long totalSize) {
+        super.onProgress(bytesWritten, totalSize);
+
+        // on progress, emit RNFetchBlobProgress event with ticketId, bytesWritten, and totalSize
+        WritableMap args = Arguments.createMap();
+        args.putString("taskId", this.mTaskId);
+        args.putString("written", String.valueOf(bytesWritten));
+        args.putString("total", String.valueOf(totalSize));
+
+        // emit event to js context
+        this.mCtx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("RNFetchBlobProgress", args);
+    }
+
+    @Override
+    public void onSuccess(int statusCode, Header[] headers, File file) {
+        this.onResponse.invoke(null, file.getAbsolutePath());
+    }
+}