correct android readstream function

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

     }
 
     @ReactMethod
-    public ReadableArray getSystemDirs() {
+    public void getEnvironmentDirs(Callback callback) {
 
         WritableArray results = Arguments.createArray();
         ReactApplicationContext ctx = this.getReactApplicationContext();
         results.pushString(String.valueOf(ctx.getCacheDir()));
         results.pushString(String.valueOf(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC)));
         results.pushString(String.valueOf(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)));
-        return results;
+        callback.invoke(results);
     }
 
     @ReactMethod
     }
 
     @ReactMethod
-    public void readStream(String path, String encoding) {
+    /**
+     * @param path Stream file path
+     * @param encoding Stream encoding, should be one of `base64`, `ascii`, and `utf8`
+     * @param bufferSize Stream buffer size, default to 1024 or 1026(base64).
+     */
+    public void readStream(String path, String encoding, String bufferSize) {
         RNFetchBlobFS fs = new RNFetchBlobFS(this.getReactApplicationContext());
-        fs.readStream(path, encoding);
+        fs.readStream(path, encoding, bufferSize);
     }
 
     @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 {
             Uri uri = Uri.parse(url);
             AsyncHttpClient req = new AsyncHttpClient();

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

     public String appendExt;
 
     RNFetchBlobConfig(ReadableMap options) {
-
-        this.fileCache = options.getBoolean("fileCache");
-        this.path = options.getString("path");
-        this.appendExt = options.getString("appendExt");
+        if(options == null)
+            return;
+        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") : "";
 
     }
 

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

 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.loopj.android.http.Base64;
 
+import java.io.File;
 import java.io.FileInputStream;
 
 import cz.msebera.android.httpclient.util.EncodingUtils;
         this.emitter = ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
     }
     
-    // TODO : make it an AsyncTask
-    public void readStream(final String path, String encoding) {
+    public void readStream( String path, String encoding, String bufferSize) {
         AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
             @Override
             protected Integer doInBackground(String ... args) {
                 String path = args[0];
                 String encoding = args[1];
+                int bufferSize = Integer.parseInt(args[2]);
                 String eventName = "RNFetchBlobStream+" + path;
                 try {
-                    FileInputStream fs = mCtx.openFileInput(mCtx.getFilesDir() + "/"+ path);
-                    byte[] buffer = new byte[1024];
+
+                    int chunkSize = encoding.equalsIgnoreCase("base64") ? 1026 : 1024;
+                    if(bufferSize > 0)
+                        chunkSize = bufferSize;
+                    FileInputStream fs = new FileInputStream(new File(path));
+                    byte[] buffer = new byte[chunkSize];
                     int cursor = 0;
                     boolean error = false;
 
-                    if (encoding.toLowerCase() == "utf8") {
+                    if (encoding.equalsIgnoreCase("utf8")) {
                         while ((cursor = fs.read(buffer)) != -1) {
                             String chunk = new String(buffer, 0, cursor, "UTF-8");
-                            emitFSData(eventName, "data", chunk);
+                            emitStreamEvent(eventName, "data", chunk);
                         }
-                    } else if (encoding.toLowerCase() == "ascii") {
+                    } else if (encoding.equalsIgnoreCase("ascii")) {
                         while ((cursor = fs.read(buffer)) != -1) {
                             String chunk = EncodingUtils.getAsciiString(buffer, 0, cursor);
-                            emitFSData(eventName, "data", chunk);
+                            emitStreamEvent(eventName, "data", chunk);
                         }
-                    } else if (encoding.toLowerCase() == "base64") {
+                    } else if (encoding.equalsIgnoreCase("base64")) {
                         while ((cursor = fs.read(buffer)) != -1) {
-                            emitFSData(eventName, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
+                            emitStreamEvent(eventName, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
                         }
                     } else {
                         String msg = "unrecognized encoding `" + encoding + "`";
-                        emitFSData(eventName, "error", msg);
+                        emitStreamEvent(eventName, "error", msg);
                         error = true;
                     }
 
                     if(!error)
-                        emitFSData(eventName, "end", "");
+                        emitStreamEvent(eventName, "end", "");
+                    fs.close();
+
 
                 } catch (Exception err) {
-                    emitFSData(eventName, "error", err.getLocalizedMessage());
+                    emitStreamEvent(eventName, "error", err.getLocalizedMessage());
                 }
                 return null;
             }
         };
-        task.execute(path, encoding);
+        task.execute(path, encoding, bufferSize);
+    }
+
+    void emitStreamEvent(String streamName, String event, String data) {
+        WritableMap eventData = Arguments.createMap();
+        eventData.putString("event", event);
+        eventData.putString("detail", data);
+        this.emitter.emit(streamName, eventData);
     }
 
     void emitFSData(String taskId, String event, String data) {