Add fetch polyfill Blob reader method #70

Fix Blob unicode data convertion #73

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

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
 import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Map;
         if(encoding.equalsIgnoreCase("ascii")) {
             return data.getBytes(Charset.forName("US-ASCII"));
         }
-        else if(encoding.equalsIgnoreCase("base64")) {
-            return Base64.decode(data, Base64.NO_WRAP);
+        else if(encoding.toLowerCase().contains("base64")) {
+            byte [] b = Base64.decode(data, Base64.NO_WRAP);
+            if(encoding.toLowerCase().contains("urlencode")) {
+                try {
+                    b = URLDecoder.decode(new String(b), "UTF-8").getBytes();
+                } catch (UnsupportedEncodingException e) {
+                    e.printStackTrace();
+                }
+            }
+            return b;
         }
         else if(encoding.equalsIgnoreCase("utf8")) {
             return data.getBytes(Charset.forName("UTF-8"));

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

             });
 
 
-            if(options.timeout > 0) {
+            if(options.timeout >= 0) {
                 clientBuilder.connectTimeout(options.timeout, TimeUnit.MILLISECONDS);
                 clientBuilder.readTimeout(options.timeout, TimeUnit.MILLISECONDS);
             }

src/ios/RNFetchBlobFS.m

         }
         NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
         NSData * content = nil;
-        if([encoding isEqualToString:@"base64"]) {
+        if([encoding containsString:@"base64"]) {
             content = [[NSData alloc] initWithBase64EncodedString:data options:0];
+            if([encoding containsString:@"urlencode"])
+            {
+                NSString * decode = [[[NSString alloc] initWithData:content encoding:NSUTF8StringEncoding] stringByRemovingPercentEncoding];
+                content = [decode dataUsingEncoding:NSUTF8StringEncoding];
+            }
         }
         else if([encoding isEqualToString:@"uri"]) {
             NSNumber* size = [[self class] writeFileFromFile:data toFile:path append:append];

src/ios/RNFetchBlobNetwork.m

     
     NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
     float timeout = [options valueForKey:@"timeout"] == nil ? -1 : [[options valueForKey:@"timeout"] floatValue];
-    NSLog(@"timeout = %f",timeout);
     if(timeout > 0)
     {
         defaultConfigObject.timeoutIntervalForRequest = timeout/1000;

src/polyfill/Blob.js

 const log = new Log('Blob')
 const blobCacheDir = fs.dirs.DocumentDir + '/RNFetchBlob-blobs/'
 
-log.disable()
+log.level(3)
 
 /**
  * A RNFetchBlob style Blob polyfill class, this is a Blob which compatible to
       // when content type contains application/octet* or *;base64, RNFetchBlob
       // fs will treat it as BASE64 encoded string binary data
       if(/(application\/octet|\;base64)/i.test(mime))
-        encoding = 'base64'
+        encoding = 'base64+urlencode'
       else
         data = data.toString()
       // create cache file

src/polyfill/Fetch.js

 import Log from '../utils/log.js'
 import fs from '../fs'
 import unicode from '../utils/unicode'
+import Blob from './Blob'
 
 const log = new Log('FetchPolyfill')
 
 class RNFetchBlobFetchPolyfill {
 
   constructor(config:RNFetchBlobConfig) {
-    this.build = () => (url, options) => {
+    this.build = () => (url, options = {}) => {
       options.headers = options.headers || {}
       options['Content-Type'] = options.headers['Content-Type'] || options.headers['content-type']
       options['content-type'] = options.headers['Content-Type'] || options.headers['content-type']
       return RNFetchBlob.config(config)
         .fetch(options.method, url, options.headers, options.body)
         .then((resp) => {
+          log.verbose('response', resp)
           let info = resp.info()
           return Promise.resolve(new RNFetchBlobFetchRepsonse(resp))
         })
   }
 }
 
+function readBlob(resp, info):Promise<object> {
+  log.verbose('readBlob', resp, info)
+  let cType = info.headers['Content-Type']
+  switch (info.rnfbEncode) {
+    case 'base64':
+      return Blob.build(resp.data, { type : `${cType};BASE64` })
+    case 'path':
+      return Blob.build(RNFetchBlob.wrap(resp.data), { type : `${cType}`})
+    default:
+      return Blob.build(resp.data, { type : `${cType}`})
+  }
+}
+
 function readJSON(resp, info):Promise<object> {
+  log.verbose('readJSON', resp, info)
   switch (info.rnfbEncode) {
     case 'base64':
       return Promise.resolve(resp.json())