#44 wip commit

src/index.js

       }
     })
 
+    // When the request body comes from Blob polyfill, we should use special its ref
+    // as the request body
+    if( body instanceof Blob && body.isRNFetchBlobPolyfill) {
+      body = body.getRNFetchBlobRef()
+    }
+
     let req = RNFetchBlob[nativeMethodName]
     req(options, taskId, method, url, headers || {}, body, (err, data) => {
 

src/ios/RNFetchBlob/RNFetchBlob.m

                   headers:(NSDictionary *)headers
                   body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
-	NSString *cType = [headers valueForKey:"content-type"]
-	if (cType != nil && cType == @"application/x-www-form-urlencoded") {
-		[RNFetchBlobReqBuilder buildEncodedRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
-	        // send HTTP request
-	        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-	        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
-	        utils = nil;
-	    }];
-	} else {
+    NSString *cType = [headers valueForKey:@"content-type"];
+//	if (cType != nil && cType == @"application/x-www-form-urlencoded") {
+//		[RNFetchBlobReqBuilder buildEncodedRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
+//	        // send HTTP request
+//	        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+//	        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+//	        utils = nil;
+//	    }];
+//	} else {
 		[RNFetchBlobReqBuilder buildOctetRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
 	        // send HTTP request
 	        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
 	        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
 	        utils = nil;
 	    }];
-	}
+//	}
 }
 
 RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {

src/ios/RNFetchBlobConst.m

 extern NSString *const CONFIG_FILE_EXT = @"appendExt";
 extern NSString *const CONFIG_TRUSTY = @"trusty";
 extern NSString *const CONFIG_INDICATOR = @"indicator";
-extern NSString *const CONFIG_KEY = "@key";
+extern NSString *const CONFIG_KEY = @"key";
 
 extern NSString *const EVENT_STATE_CHANGE = @"RNFetchBlobState";
 extern NSString *const MSG_EVENT = @"RNFetchBlobMessage";

src/ios/RNFetchBlobNetwork.m

     return mheaders;
 }
 
-- (NSString *)md5 {
-    const char* str = [self UTF8String];
+- (NSString *)md5:(NSString *)input {
+    const char* str = [input UTF8String];
     unsigned char result[CC_MD5_DIGEST_LENGTH];
     CC_MD5(str, (CC_LONG)strlen(str), result);
 
 
 		NSString* cacheKey = taskId;
 		if (key != nil) {
-			cacheKey = [key md5];
+            cacheKey = [self md5:key];
 			if (cacheKey == nil) {
 				cacheKey = taskId;
 			}
 
 			destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
             if ([[NSFileManager defaultManager] fileExistsAtPath:destPath]) {
-				callback([NSNull null], destPath]);
+				callback(@[[NSNull null], destPath]);
                 return;
             }
 		}

src/ios/RNFetchBlobReqBuilder.m

     });
 }
 
-+(void) buildEncodedRequest:(NSDictionary *)options
-                   taskId:(NSString *)taskId
-                   method:(NSString *)method
-                      url:(NSString *)url
-                  headers:(NSDictionary *)headers
-                     body:(NSString *)body
-               onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
-{
-	NSMutableData * formData = [[NSMutableData alloc] init];
-	[formData appendData:[[NSString stringWithFormat:@"%@", body] dataUsingEncoding:NSUTF8StringEncoding]];
-	onComplete(formData);
-}
+//+(void) buildEncodedRequest:(NSDictionary *)options
+//                   taskId:(NSString *)taskId
+//                   method:(NSString *)method
+//                      url:(NSString *)url
+//                  headers:(NSDictionary *)headers
+//                     body:(NSString *)body
+//               onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
+//{
+//	NSMutableData * formData = [[NSMutableData alloc] init];
+//    
+//	[formData appendData:[[NSString stringWithFormat:@"%@", body] dataUsingEncoding:NSUTF8StringEncoding]];
+//	onComplete(formData);
+//}
 
 
 +(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData))onComplete

src/polyfill/Blob.js

 import RNFetchBlob from '../index.js'
 import fs from '../fs.js'
 import getUUID from '../utils/uuid'
+import Log from '../utils/log.js'
 
+const log = new Log('Blob')
 const blobCacheDir = fs.dirs.DocumentDir + '/RNFetchBlob-blob/'
 
+log.level(3)
+
 /**
  * A RNFetchBlob style Blob polyfill class, this is a Blob which compatible to
  * Response object attain fron RNFetchBlob.fetch.
   cacheName:string;
   type:string;
   size:number;
+  isRNFetchBlobPolyfill:boolean = true;
 
   _ref:string = null;
   _blobCreated:boolean = false;
 
   // legacy constructor
   constructor(data:any, mime:?string) {
+
     this.cacheName = getBlobName()
+    this.isRNFetchBlobPolyfill = true
     this.type = mime
+    log.verbose('Blob constructor called' , data, 'mime', mime)
+
     if(typeof data === 'string') {
       // content from file
       if(data.startsWith('RNFetchBlob-file://')) {
       }
       // content from variable need create file
       else {
+        log.verbose('create Blob cache file ..')
         this._ref = RNFetchBlob.wrap(blobCacheDir + this.cacheName)
         let encoding = 'utf8'
         if(typeof data === 'string' && String(mime).match('application/octet') )
 
         this.init(data, encoding)
           .then(() => {
+            log.verbose('init executed ')
             if(typeof this._onCreated === 'function')
-              this._onCreated()
-            _blobCreated = true
+              this._onCreated(this)
           })
           .catch((err) => {
-            console.log('RNFetchBlob cannot create Blob', err)
+            log.error('RNFetchBlob cannot create Blob', err)
           })
       }
+    }
+    // TODO : handle mixed blob array
+    else if(Array.isArray(data)) {
+
     }
     else {
-      console.log('TODO')
+      log.verbose('TODO: else')
     }
   }
 
   onCreated(fn:() => void) {
-    console.log('register blob onCreated', fn)
+    log.verbose('register blob onCreated')
     if(this._blobCreated)
       fn()
     else
    * @return {Promise}
    */
   init(data, encoding):Promise {
-    console.log('blob init called')
-    return fs.exists(blobCacheDir).then((exist) => {
-      if(!exist)
-        return fs.mkdir(blobCacheDir).then(() => fs.createFile(this._ref, data, encoding))
-      else
-        return fs.createFile(this._ref, data, encoding)
+    return new Promise((resolve, reject) => {
+      fs.exists(blobCacheDir)
+        .then((exist) => {
+          log.verbose('blob cache folder exist', blobCacheDir, exist)
+          let path = String(this._ref).replace('RNFetchBlob-file://', '')
+          log.verbose('create cache file', path)
+          if(!exist)
+            return fs.mkdir(blobCacheDir)
+                     .then(() => fs.createFile(path, data, encoding))
+          else
+            return fs.createFile(path, data, encoding)
+        })
+        .then(() => {
+          this._blobCreated = true
+          resolve()
+        })
+        .catch((err) => {
+          reject(err)
+        })
     })
+
   }
 
   /**
    * @return {Blob}
    */
   slice(start:?number, end:?number, encoding:?string):Blob {
-    console.log('slice called')
+    log.verbose('slice called')
     // return fs.slice(this.cacheName, getBlobName(), contentType, start, end)
   }
 
     return fs.unlink(this._ref)
   }
 
-
 }
 
 /**
 function getBlobName() {
   return 'blob-' + getUUID()
 }
+
+/**
+ * Create a file according to given array. The element in array can be a number,
+ * Blob, string.
+ * @param  {Array} dataArray An array contains different types of data.
+ * @return {string}      The blob file reference
+ */
+function createMixedBlobData(dataArray) {
+  // TODO : mixed blob data creator
+}

src/polyfill/FormData.js

+export default class FormData {
+
+  constructor() {
+    console.log('FormData constructor called')
+  }
+
+}

src/polyfill/XMLHttpRequest.js

 
 import RNFetchBlob from '../index.js'
 import XMLHttpRequestEventTarget from './XMLHttpRequestEventTarget.js'
+import Log from '../utils/log.js'
+import Blob from './Blob.js'
+
+const log = new Log('XMLHttpRequest')
+
+log.level(3)
 
 const UNSENT = 0
 const OPENED = 1
 
   constructor(...args) {
     super()
-    console.log('XMLHttpRequest constructor called', args)
+    log.verbose('XMLHttpRequest constructor called', args)
     this._config = {}
     this._args = {}
     this._headers = {}
 
   // XMLHttpRequest.open, always async, user and password not supported.
   open(method:string, url:string, async:true, user:any, password:any) {
-    console.log('XMLHttpRequest open ', method, url, async, user, password)
+    log.verbose('XMLHttpRequest open ', method, url, async, user, password)
     this._method = method
     this._url = url
     this.readyState = XMLHttpRequest.OPENED
    * @param  {any} body Body in RNfetchblob flavor
    */
   send(body) {
-    console.log('XMLHttpRequest send ', body)
+    log.verbose('XMLHttpRequest send ', body)
     let {_method, _url, _headers } = this
-    console.log('sending request with args', _method, _url, _headers, body)
+    log.verbose('sending request with args', _method, _url, _headers, body)
+
     this._upload = new XMLHttpRequestEventTarget()
+    log.verbose(typeof body, body instanceof FormData)
+    if(Array.isArray(body)) {
+      // TODO
+    }
+
     this.dispatchEvent('loadstart')
     if(this.onloadstart)
       this.onloadstart()
   }
 
   overrideMimeType(mime:string) {
-    console.log('XMLHttpRequest overrideMimeType', mime)
+    log.verbose('XMLHttpRequest overrideMimeType', mime)
     this._headers['content-type'] = mime
   }
 
   setRequestHeader(name, value) {
-    console.log('XMLHttpRequest set header', name, value)
+    log.verbose('XMLHttpRequest set header', name, value)
     this._headers[name] = value
   }
 
   abort() {
-    console.log('XMLHttpRequest abort ')
+    log.verbose('XMLHttpRequest abort ')
     if(!this._task)
       return
     this._task.cancel((err) => {
   }
 
   getResponseHeader(field:string):string | null {
-    console.log('XMLHttpRequest get header', field)
+    log.verbose('XMLHttpRequest get header', field)
     if(!this.responseHeaders)
       return null
     return this.responseHeaders[field] || null
   }
 
   getAllResponseHeaders():string | null {
-    console.log('XMLHttpRequest get all headers')
+    log.verbose('XMLHttpRequest get all headers')
     if(!this.responseHeaders)
       return null
     let result = ''
   }
 
   _headerReceived(e) {
-    console.log('header received ', e)
+    log.verbose('header received ', e)
     this.responseURL = this._url
     if(e.state === "2") {
       this.readyState = XMLHttpRequest.HEADERS_RECEIVED
   }
 
   _progressEvent(send:number, total:number) {
-    console.log(this.readyState)
+    log.verbose(this.readyState)
     if(this.readyState === XMLHttpRequest.HEADERS_RECEIVED)
       this.readyState = XMLHttpRequest.LOADING
     let lengthComputable = false
   }
 
   _onError(err) {
-    console.log('XMLHttpRequest error', err)
+    log.verbose('XMLHttpRequest error', err)
     this.statusText = err
     this.status = String(err).match(/\d+/)
     this.status = this.status ? Math.floor(this.status) : 404
   }
 
   _onDone(resp) {
-    console.log('XMLHttpRequest done', resp.text())
+    log.verbose('XMLHttpRequest done', resp.text())
     this.statusText = '200 OK'
     this._status = 200
     switch(resp.type) {
   }
 
   set onreadystatechange(fn:() => void) {
-    console.log('XMLHttpRequest set onreadystatechange', fn.toString())
+    log.verbose('XMLHttpRequest set onreadystatechange', fn.toString())
     this._onreadystatechange = fn
   }
 
   set readyState(val:number) {
 
-    console.log('XMLHttpRequest ready state changed to ', val)
+    log.verbose('XMLHttpRequest ready state changed to ', val)
     this._readyState = val
     if(this._onreadystatechange) {
-      console.log('trigger onreadystatechange event', this._readyState)
-      console.log(this._onreadystatechange)
+      log.verbose('trigger onreadystatechange event', this._readyState)
+      log.verbose(this._onreadystatechange)
       this.dispatchEvent('readystatechange', )
       if(this._onreadystatechange)
         this._onreadystatechange()
   }
 
   get readyState() {
-    console.log('get readyState', this._readyState)
+    log.verbose('get readyState', this._readyState)
     return this._readyState
   }
 
   get status() {
-    console.log('get status', this._status)
+    log.verbose('get status', this._status)
     return this._status
   }
 
   }
 
   get statusText() {
-    console.log('get statusText', this._statusText)
+    log.verbose('get statusText', this._statusText)
     return this._statusText
   }
 
   set response(val) {
-    console.log('set response', val)
+    log.verbose('set response', val)
     this._response = val
   }
 
   get response() {
-    console.log('get response', this._response)
+    log.verbose('get response', this._response)
     return this._response
   }
 
   get responseText() {
-    console.log('get responseText', this._responseText)
+    log.verbose('get responseText', this._responseText)
     return this._responseText
   }
 
   get responseURL() {
-    console.log('get responseURL', this._responseURL)
+    log.verbose('get responseURL', this._responseURL)
     return this._responseURL
   }
 
   get responseHeaders() {
-    console.log('get responseHeaders', this._responseHeaders)
+    log.verbose('get responseHeaders', this._responseHeaders)
     return this._responseHeaders
   }
 
   set timeout(val) {
-    console.log('set timeout', this._timeout)
+    log.verbose('set timeout', this._timeout)
     this._timeout = val
   }
 
   get timeout() {
-    console.log('get timeout', this._timeout)
+    log.verbose('get timeout', this._timeout)
     return this._timeout
   }
 
   get upload() {
-    console.log('get upload', this._upload)
+    log.verbose('get upload', this._upload)
     return this._upload
   }
 
   get responseType() {
-    console.log('get response type', this._responseType)
+    log.verbose('get response type', this._responseType)
     return this._responseType
   }
 

src/polyfill/XMLHttpRequestEventTarget.js

 
 const log = new Log('XMLHttpRequestEventTarget')
 
+log.disable()
+
 export default class XMLHttpRequestEventTarget extends EventTarget {
 
   _onabort : (e:Event) => void;

src/polyfill/index.js

 import Blob from './Blob.js'
 import File from './File.js'
 import XMLHttpRequest from './XMLHttpRequest.js'
+import FormData from './FormData.js'
 
 export default {
-  Blob, File, XMLHttpRequest
+  Blob, File, XMLHttpRequest, FormData
 }

src/utils/log.js

 export default class Log {
 
   _name:string;
+  _isEnable:boolean = true
+  _level:number = 0
 
   constructor(name:string) {
     this._name = name
   }
 
-  info(...args) {
-    console.log(this._name, '-info:', ...args)
+  level(val:number) {
+    this._level = val
+  }
+
+  enable() {
+    this._isEnable = true
+  }
+
+  disable() {
+    this._isEnable = false
+  }
+
+  verbose(...args) {
+    this._isEnable && this._level > 2 && console.log(this._name, 'verbose:', ...args)
   }
 
   debug(...args) {
-    console.log(this._name, '-debug:', ...args)
+    this._isEnable && this._level > 1 && console.log(this._name, 'debug:', ...args)
+  }
+
+  info(...args) {
+    this._isEnable && this._level > 0 && console.log(this._name, 'info:', ...args)
   }
 
   error(...args) {
-    console.log(this._name, '-error:', ...args)
+    this._isEnable && this._level > -1 && console.log(this._name, 'error:', ...args)
   }
 
 }

test/test-firebase.js

 
 window.XMLHttpRequest = RNFetchBlob.polyfill.XMLHttpRequest
 window.Blob = Blob
+window.FormData = RNFetchBlob.polyfill.FormData
 
 const { Assert, Comparer, Info, prop } = RNTest
 const describe = RNTest.config({
   })
 })
 
-
 describe('upload file to firebase', (report, done) => {
 
   try {
     let blob = new Blob(RNTest.prop('image'), 'application/octet-binary')
     blob.onCreated(() => {
-      console.log('BINGO')
       let storage = firebase.storage().ref()
       let task = storage
         .child(`testdata/firebase-test-${Platform.OS}.png`)

test/test-init.js

 // test environment variables
 
 prop('FILENAME', `${Platform.OS}-0.7.0-${Date.now()}.png`)
-prop('TEST_SERVER_URL', 'http://192.168.16.70:8123')
-prop('TEST_SERVER_URL_SSL', 'https://192.168.16.70:8124')
+prop('TEST_SERVER_URL', 'http://192.168.0.11:8123')
+prop('TEST_SERVER_URL_SSL', 'https://192.168.0.11:8124')
 prop('DROPBOX_TOKEN', 'fsXcpmKPrHgAAAAAAAAAoXZhcXYWdgLpQMan6Tb_bzJ237DXhgQSev12hA-gUXt4')
 prop('styles', {
   image : {