Code refactor

Correct flow type notations and remove unnecessary code.

src/android.js

  * @param  {string} mime MIME type string
  * @return {Promise}
  */
-function actionViewIntent(path:string, mime = 'text/plain':string) {
+function actionViewIntent(path:string, mime:string = 'text/plain') {
   if(Platform.OS === 'android')
     return RNFetchBlob.actionViewIntent(path, mime)
   else

src/class/RNFetchBlobReadStream.js

     // register for file stream event
     let subscription = emitter.addListener(this.streamId, (e) => {
       let {event, detail} = e
-      if(this._onData && event === 'data')
+      if(this._onData && event === 'data') {
         this._onData(detail)
+        return 
+      }
       else if (this._onEnd && event === 'end') {
         this._onEnd(detail)
       }
       throw new Error('Stream closed')
   }
 
-  onData(fn) {
-    // if(this.encoding.toLowerCase() === 'ascii')
-    //   this._onData = (data) => {
-    //     fn(data)
-    //   }
-    // else
+  onData(fn:() => void) {
     this._onData = fn
   }
 

src/index.js

   path : () => string | null;
   type : 'base64' | 'path' | 'utf8';
   data : any;
-  blob : (contentType:string, sliceSize:number) => null;
-  text : () => string;
+  blob : (contentType:string, sliceSize:number) => Promise<Blob>;
+  text : () => string | Promise<any>;
   json : () => any;
   base64 : () => any;
   flush : () => void;
   respInfo : RNFetchBlobResponseInfo;
   session : (name:string) => RNFetchBlobSession | null;
-  readFile : (encode: 'base64' | 'utf8' | 'ascii') => ?Promise;
+  readFile : (encode: 'base64' | 'utf8' | 'ascii') => ?Promise<any>;
   readStream : (
     encode: 'utf8' | 'ascii' | 'base64',
   ) => RNFetchBlobStream | null;
      * Convert result to text.
      * @return {string} Decoded base64 string.
      */
-    this.text = ():string => {
+    this.text = ():string | Promise<any> => {
       let res = this.data
       switch(this.type) {
         case 'base64':
           return base64.decode(this.data)
-        break
         case 'path':
           return fs.readFile(this.data, 'base64').then((b64) => Promise.resolve(base64.decode(b64)))
-        break
         default:
           return this.data
-        break
       }
     }
     /**
       switch(this.type) {
         case 'base64':
           return JSON.parse(base64.decode(this.data))
-        break
         case 'path':
           return fs.readFile(this.data, 'utf8')
                    .then((text) => Promise.resolve(JSON.parse(text)))
-        break
         default:
           return JSON.parse(this.data)
-        break
       }
     }
     /**
      * Return BASE64 string directly.
      * @return {string} BASE64 string of response body.
      */
-    this.base64 = ():string => {
+    this.base64 = ():string | Promise<any> => {
       switch(this.type) {
         case 'base64':
           return this.data
-        break
         case 'path':
           return fs.readFile(this.data, 'base64')
-        break
         default:
           return base64.encode(this.data)
-        break
       }
     }
     /**
     this.readFile = (encode: 'base64' | 'utf8' | 'ascii') => {
       if(this.type === 'path') {
         encode = encode || 'utf8'
-
         return readFile(this.data, encode)
       }
       else {