Add #29 Android implementation

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

 import com.loopj.android.http.AsyncHttpClient;
 import com.loopj.android.http.AsyncHttpResponseHandler;
 import com.loopj.android.http.Base64;
+import com.loopj.android.http.MySSLSocketFactory;
 import com.loopj.android.http.RequestParams;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
+import java.security.KeyStore;
 import java.util.HashMap;
 import java.util.Map;
 
 
     @ReactMethod
     public void fetchBlob(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
-
-        RNFetchBlobConfig config = new RNFetchBlobConfig(options);
-
-        try {
-            AsyncHttpClient req = new AsyncHttpClient();
-
-            AbstractHttpEntity entity = null;
-
-            // set headers
-            ReadableMapKeySetIterator it = headers.keySetIterator();
-            while (it.hasNextKey()) {
-                String key = it.nextKey();
-                req.addHeader(key, headers.getString(key));
-            }
-
-            // set body for POST and PUT
-            if(body != null && method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put")) {
-
-                byte [] blob;
-                // upload from storage
-                if(body.startsWith(filePathPrefix)) {
-                    String filePath = body.substring(filePathPrefix.length());
-                    entity = new FileEntity(new File(filePath));
-                }
-                else {
-                    blob = Base64.decode(body, 0);
-                    entity = new ByteArrayEntity(blob);
-                }
-                entity.setContentType(headers.getString("Content-Type"));
-            }
-
-            AsyncHttpResponseHandler handler;
-
-            // create handler
-            if(config.fileCache || config.path != null) {
-                handler = new RNFetchBlobFileHandler(this.getReactApplicationContext(), taskId, config, callback);
-                // if path format invalid, throw error
-                if (!((RNFetchBlobFileHandler)handler).isValid) {
-                    callback.invoke("RNFetchBlob fetch error, configuration path `"+ config.path  +"` is not a valid path.");
-                    return;
-                }
-            }
-            else
-                handler = new RNFetchBlobBinaryHandler(this.getReactApplicationContext(), taskId, callback);
-
-            // send request
-            switch(method.toLowerCase()) {
-                case "get" :
-                    req.get(url, handler);
-                    break;
-                case "post" :
-                    req.post(this.getReactApplicationContext(), url, entity, "octet-stream", handler);
-                    break;
-                case "put" :
-                    req.put(this.getReactApplicationContext(), url, entity, "octet-stream",handler);
-                    break;
-                case "delete" :
-                    req.delete(url, handler);
-                    break;
-            }
-        } catch(Exception error) {
-            callback.invoke( "RNFetchBlob serialize request data failed: " + error.getMessage() + error.getCause());
-        }
-
+        new RNFetchBlobReq(this.getReactApplicationContext(), options, taskId, method, url, headers, body, callback).run();
     }
 
     @ReactMethod
     public void fetchBlobForm(ReadableMap options, String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
-
-        RNFetchBlobConfig config = new RNFetchBlobConfig(options);
-        try {
-
-            AsyncHttpClient req = new AsyncHttpClient();
-
-            HttpEntity entity = null;
-
-            // set headers
-            if(headers != null) {
-                ReadableMapKeySetIterator it = headers.keySetIterator();
-                while (it.hasNextKey()) {
-                    String key = it.nextKey();
-                    req.addHeader(key, headers.getString(key));
-                }
-            }
-
-            // set body for POST and PUT
-            if(body != null && method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put")) {
-                Long tsLong = System.currentTimeMillis()/1000;
-                String ts = tsLong.toString();
-                String boundary = "RNFetchBlob".concat(ts);
-                MultipartEntityBuilder form = MultipartEntityBuilder.create();
-                form.setBoundary(boundary);
-                for( int i = 0; i< body.size(); i++) {
-                    ReadableMap map = body.getMap(i);
-                    String name = map.getString("name");
-                    if(!map.hasKey("data"))
-                        continue;
-                    String data = map.getString("data");
-                    // file field
-                    if(map.hasKey("filename")) {
-                        String filename = map.getString("filename");
-                        // upload from storage
-                        if(data.startsWith(filePathPrefix)) {
-                            File file = new File(data.substring(filePathPrefix.length()));
-                            form.addBinaryBody(name, file, ContentType.APPLICATION_OCTET_STREAM, filename);
-                        }
-                        // base64 embedded file content
-                        else {
-                            form.addBinaryBody(name, Base64.decode(data, 0), ContentType.APPLICATION_OCTET_STREAM, filename);
-                        }
-                    }
-                    // data field
-                    else {
-                        form.addTextBody(name, map.getString("data"));
-                    }
-                }
-                entity = form.build();
-                req.addHeader("Content-Type", headers.getString("Content-Type") + "; charset=utf8; boundary=" + boundary);
-            }
-
-            AsyncHttpResponseHandler handler;
-
-            // create handler
-            if(config.fileCache || config.path != null) {
-                handler = new RNFetchBlobFileHandler(this.getReactApplicationContext(), taskId, config, callback);
-                // if path format invalid, throw error
-                if (!((RNFetchBlobFileHandler)handler).isValid) {
-                    callback.invoke("RNFetchBlob fetch error, configuration path `"+ config.path  +"` is not a valid path.");
-                    return;
-                }
-            }
-            else
-                handler = new RNFetchBlobBinaryHandler(this.getReactApplicationContext(), taskId, callback);
-
-            // send request
-            switch(method.toLowerCase()) {
-                case "get" :
-                    req.get(url, handler);
-                    break;
-                case "post" :
-                    req.post(this.getReactApplicationContext(), url, entity, "multipart/form-data; charset=utf8", handler);
-                    break;
-                case "put" :
-                    req.put(this.getReactApplicationContext(), url, entity, "multipart/form-data",handler);
-                    break;
-                case "delete" :
-                    req.delete(url, handler);
-                    break;
-            }
-        } catch(Exception error) {
-            callback.invoke( "RNFetchBlob serialize request data failed: " + error.getMessage() + error.getCause());
-        }
-
+        new RNFetchBlobReq(this.getReactApplicationContext(), options, taskId, method, url, headers, body, callback).run();
     }
 
 }

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

     public String path;
     public String appendExt;
     public ReadableMap addAndroidDownloads;
+    public Boolean trusty;
 
     RNFetchBlobConfig(ReadableMap options) {
         if(options == null)
         this.fileCache = options.hasKey("fileCache") ? options.getBoolean("fileCache") : false;
         this.path = options.hasKey("path") ? options.getString("path") : null;
         this.appendExt = options.hasKey("appendExt") ? options.getString("appendExt") : "";
+        this.trusty = options.hasKey("trusty") ? options.getBoolean("trusty") : false;
         if(options.hasKey("addAndroidDownloads")) {
             this.addAndroidDownloads = options.getMap("addAndroidDownloads");
         }

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

 import java.util.List;
 
 /**
- * Created by xeiyan on 2016/4/29.
+ * Created by wkh237 on 2016/4/29.
  */
 public class RNFetchBlobPackage implements ReactPackage {
 

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

+package com.RNFetchBlob;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.loopj.android.http.AsyncHttpClient;
+import com.loopj.android.http.AsyncHttpResponseHandler;
+import com.loopj.android.http.Base64;
+import com.loopj.android.http.MySSLSocketFactory;
+
+import java.io.File;
+import java.nio.charset.Charset;
+import java.security.KeyStore;
+
+import cz.msebera.android.httpclient.HttpEntity;
+import cz.msebera.android.httpclient.entity.AbstractHttpEntity;
+import cz.msebera.android.httpclient.entity.ByteArrayEntity;
+import cz.msebera.android.httpclient.entity.ContentType;
+import cz.msebera.android.httpclient.entity.FileEntity;
+import cz.msebera.android.httpclient.entity.mime.MultipartEntityBuilder;
+
+/**
+ * Created by wkh237 on 2016/6/21.
+ */
+public class RNFetchBlobReq implements Runnable{
+
+    final String filePathPrefix = "RNFetchBlob-file://";
+    ReactApplicationContext ctx;
+    RNFetchBlobConfig options;
+    String taskId;
+    String method;
+    String url;
+    String boundary;
+    ReadableMap headers;
+    Callback callback;
+    HttpEntity entity;
+    AsyncHttpClient req;
+    String type;
+
+    public RNFetchBlobReq(ReactApplicationContext ctx, ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
+        this.ctx = ctx;
+        this.method = method;
+        this.options= new RNFetchBlobConfig(options);
+        this.taskId = taskId;
+        this.url = url;
+        this.headers = headers;
+        this.callback = callback;
+        this.req = new AsyncHttpClient();
+        if(body != null) {
+            type = "octet";
+            buildEntity(body);
+        }
+    }
+
+    public RNFetchBlobReq(ReactApplicationContext ctx, ReadableMap options, String taskId, String method, String url, ReadableMap headers, ReadableArray body, final Callback callback) {
+        this.ctx = ctx;
+        this.method = method;
+        this.options= new RNFetchBlobConfig(options);
+        this.taskId = taskId;
+        this.url = url;
+        this.headers = headers;
+        this.callback = callback;
+        this.req = new AsyncHttpClient();
+        if(body != null) {
+            type = "form";
+            buildFormEntity(body);
+        }
+    }
+
+    @Override
+    public void run() {
+
+        try {
+
+//            AsyncHttpClient req = new AsyncHttpClient();
+
+            // use trusty SSL socket
+            if(this.options.trusty) {
+                KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+                trustStore.load(null, null);
+                MySSLSocketFactory sf = new MySSLSocketFactory(trustStore);
+                sf.setHostnameVerifier(MySSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
+                req.setSSLSocketFactory(sf);
+            }
+
+            // set headers
+            if(headers != null) {
+                ReadableMapKeySetIterator it = headers.keySetIterator();
+                while (it.hasNextKey()) {
+                    String key = it.nextKey();
+                    req.addHeader(key, headers.getString(key));
+                }
+            }
+
+            if(type != null)
+            {
+                if(type == "octet")
+                    req.addHeader("Content-Type", "application/octet-stream");
+                else if(type == "form")
+                    req.addHeader("Content-Type", "multipart/form-data; charset=utf8; boundary="+boundary);
+            }
+
+            AsyncHttpResponseHandler handler;
+
+            // create handler
+            if(options.fileCache || options.path != null) {
+                handler = new RNFetchBlobFileHandler(ctx, taskId, options, callback);
+                // if path format invalid, throw error
+                if (!((RNFetchBlobFileHandler)handler).isValid) {
+                    callback.invoke("RNFetchBlob fetch error, configuration path `"+ options.path  +"` is not a valid path.");
+                    return;
+                }
+            }
+            else
+                handler = new RNFetchBlobBinaryHandler(this.ctx, taskId, callback);
+
+            // send request
+            switch(method.toLowerCase()) {
+                case "get" :
+                    req.get(url, handler);
+                    break;
+                case "post" :
+                    if(this.type == null || this.type.equalsIgnoreCase("octet"))
+                        req.post(ctx, url, entity, "application/octet-stream", handler);
+                    else
+                        req.post(ctx, url, entity, "multipart/form-data", handler);
+                    break;
+                case "put" :
+                    if(this.type == null || this.type.equalsIgnoreCase("octet"))
+                        req.post(ctx, url, entity, "application/octet-stream", handler);
+                    else
+                        req.post(ctx, url, entity, "multipart/form-data", handler);
+                    break;
+                case "delete" :
+                    req.delete(url, handler);
+                    break;
+            }
+        } catch(Exception error) {
+            callback.invoke( "RNFetchBlob serialize request data failed: " + error.getMessage() + error.getCause());
+        }
+    }
+
+    /**
+     * Build Mutipart body
+     * @param body  Body in array format
+     */
+    void buildFormEntity(ReadableArray body) {
+        if(body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
+            Long tsLong = System.currentTimeMillis()/1000;
+            String ts = tsLong.toString();
+            boundary = "RNFetchBlob".concat(ts);
+            MultipartEntityBuilder form = MultipartEntityBuilder.create();
+            form.setBoundary(boundary);
+            for( int i = 0; i< body.size(); i++) {
+                ReadableMap map = body.getMap(i);
+                String name = map.getString("name");
+                if(!map.hasKey("data"))
+                    continue;
+                String data = map.getString("data");
+                // file field
+                if(map.hasKey("filename")) {
+                    String filename = map.getString("filename");
+                    // upload from storage
+                    if(data.startsWith(filePathPrefix)) {
+                        File file = new File(data.substring(filePathPrefix.length()));
+                        form.addBinaryBody(name, file, ContentType.APPLICATION_OCTET_STREAM, filename);
+                    }
+                    // base64 embedded file content
+                    else {
+                        form.addBinaryBody(name, Base64.decode(data, 0), ContentType.APPLICATION_OCTET_STREAM, filename);
+                    }
+                }
+                // data field
+                else {
+                    form.addTextBody(name, map.getString("data"));
+                }
+            }
+            entity = form.build();
+        }
+    }
+
+    /**
+     * Build Octet-Stream body
+     * @param body  Body in string format
+     */
+    void buildEntity(String body) {
+        // set body for POST and PUT
+        if(body != null && (method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put"))) {
+
+            byte [] blob;
+            // upload from storage
+            if(body.startsWith(filePathPrefix)) {
+                String filePath = body.substring(filePathPrefix.length());
+                entity = new FileEntity(new File(filePath));
+            }
+            else {
+                blob = Base64.decode(body, 0);
+                entity = new ByteArrayEntity(blob);
+            }
+        }
+
+    }
+}