Correct fs API implementation

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

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.io.OutputStreamWriter;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 
         RNFetchBlobFS fs = fileStreams.get(streamId);
         FileOutputStream stream = fs.writeStreamInstance;
-        byte [] chunk;
-        if(fs.encoding.equalsIgnoreCase("ascii")) {
-            chunk = data.getBytes(Charset.forName("US-ASCII"));
-        }
-        else if(fs.encoding.equalsIgnoreCase("base64")) {
-            chunk = Base64.decode(data, 0);
-        }
-        else if(fs.encoding.equalsIgnoreCase("utf8")) {
-            chunk = data.getBytes(Charset.forName("UTF-8"));
-        }
-        else {
-            chunk = data.getBytes(Charset.forName("US-ASCII"));
-        }
+        byte [] chunk = RNFetchBlobFS.stringToBytes(data, fs.encoding);
+
         try {
             stream.write(chunk);
             callback.invoke(null);
     static void ls(String path, Callback callback) {
         File src = new File(path);
         if(!src.exists() || !src.isDirectory())
-            callback.invoke(null);
+            callback.invoke("failed to list path `"+path+"` for it is not exist or it is not a folder");
         String [] files = new File(path).list();
-        callback.invoke(files);
+        callback.invoke(null, files);
+    }
+
+    /**
+     * Create new file at path
+     * @param path
+     * @param data
+     * @param encoding
+     * @param callback
+     */
+    static void createFile(String path, String data, String encoding, Callback callback) {
+        try {
+            File dest = new File(path);
+            boolean created = dest.createNewFile();
+            if(!created) {
+                callback.invoke("failed to create file at path `" + path + "` for its parent path may not exists");
+                return;
+            }
+            OutputStream ostream = new FileOutputStream(dest);
+            ostream.write(RNFetchBlobFS.stringToBytes(data, encoding));
+            callback.invoke(null, path);
+        } catch(Exception err) {
+            callback.invoke(err.getLocalizedMessage());
+        }
+    }
+
+    /**
+     * String to byte converter method
+     * @param data  Raw data in string format
+     * @param encoding Decoder name
+     * @return  Converted data byte array
+     */
+    private static byte[] stringToBytes(String data, String encoding) {
+        if(encoding.equalsIgnoreCase("ascii")) {
+            return data.getBytes(Charset.forName("US-ASCII"));
+        }
+        else if(encoding.equalsIgnoreCase("base64")) {
+            return Base64.decode(data, 0);
+        }
+        else if(encoding.equalsIgnoreCase("utf8")) {
+            return data.getBytes(Charset.forName("UTF-8"));
+        }
+        return data.getBytes(Charset.forName("US-ASCII"));
     }
 
     /**

src/fs.js

   }
 }
 
+function createFile(path:string, data:string, encoding: 'base64' | 'ascii' | 'utf8'):Promise {
+  return new Promise((resolve, reject) => {
+    RNFetchBlob.createFile(path, data, encoding, (err) => {
+      if(err)
+        reject(err)
+      else
+        resolve()
+    })
+  })
+}
+
 /**
  * Create write stream to a file.
  * @param  {string} path Target path of file stream.
 
   if(!path)
     throw Error('RNFetchBlob could not open file stream with empty `path`')
-
+  encoding = encoding || 'utf8'
   let stream:RNFetchBlobStream = {
     onData : function(fn) {
       this._onData = fn
       stream._onEnd(detail)
     }
     else {
-      stream._onError(detail)
+      if(stream._onError)
+        stream._onError(detail)
+      else
+        throw new Error(detail)
     }
     // when stream closed or error, remove event handler
     if (event === 'error' || event === 'end') {
 
 function mv(path:string, dest:string):Promise<boolean> {
   return new Promise((resolve, reject) => {
-    RNFetchBlob.ls(path, dest, (err, res) => {
+    RNFetchBlob.mv(path, dest, (err, res) => {
       if(err)
         reject(err)
       else
 
 }
 
+function isDir(path:string):Promise<bool, bool> {
+
+  return new Promise((resolve, reject) => {
+    try {
+      RNFetchBlob.exists(path, (exist, isDir) => {
+        resolve(isDir)
+      })
+    } catch(err) {
+      reject(err)
+    }
+  })
+
+}
+
+
 /**
  * Session class
  * @class RNFetchBlobSession
     this.append = append
   }
 
-  write() {
+  write(data:string) {
     return new Promise((resolve, reject) => {
       try {
         RNFetchBlob.writeChunk(this.id, data, (error) => {
 }
 
 export default {
-  RNFetchBlobSession, unlink, mkdir, session, ls, readStream, getSystemDirs, mv, cp
+  RNFetchBlobSession,
+  unlink,
+  mkdir,
+  session,
+  ls,
+  readStream,
+  getSystemDirs,
+  mv,
+  cp,
+  writeStream,
+  exists,
+  createFile,
+  isDir
 }

src/index.js

   RNFetchBlobSession,
   getSystemDirs,
   readStream,
+  createFile,
   unlink,
+  exists,
   mkdir,
   session,
   writeStream,
   ls,
+  isDir,
   mv,
   cp
 } = fs
 }
 
 export default {
-  fetch, base64, config, getSystemDirs, readStream, unlink, session, ls, mkdir, mv, cp, writeStream
+  fetch,
+  base64,
+  config,
+  session,
+  fs,
 }

src/ios/RNFetchBlob/RNFetchBlob.m

 NSString *const FS_EVENT_END = @"end";
 NSString *const FS_EVENT_WARN = @"warn";
 NSString *const FS_EVENT_ERROR = @"error";
+NSMutableDictionary *fileStreams = nil;
 
 ////////////////////////////////////////
 //
 // static member getter
 + (NSArray *) getFileStreams {
     
-    static NSMutableData *fileStreams = nil;
     if(fileStreams == nil)
-        fileStreams = [[NSArray alloc] init];
+        fileStreams = [[NSMutableDictionary alloc] init];
     return fileStreams;
 }
 
++(void) setFileStream:(FetchBlobFS *) instance withId:(NSString *) uuid {
+    if(fileStreams == nil)
+        fileStreams = [[NSMutableDictionary alloc] init];
+    [fileStreams setValue:instance forKey:uuid];
+}
+
 + (NSString *) getCacheDir {
     return [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
 }
     [self.outStream open];
     NSString *uuid = [[NSUUID UUID] UUIDString];
     self.streamId = uuid;
-    [[FetchBlobFS getFileStreams] setValue:self forKey:uuid];
+    [FetchBlobFS setFileStream:self withId:uuid];
     return uuid;
 }
 
     else if([[self.encoding lowercaseString] isEqualToString:@"ascii"]) {
         decodedData = [chunk dataUsingEncoding:NSASCIIStringEncoding];
     }
-    NSUInteger left = [chunk length];
+    NSUInteger left = [decodedData length];
     NSUInteger nwr = 0;
     do {
         nwr = [self.outStream write:[decodedData bytes] maxLength:left];
     }
 }
 
+// close file write stream
+- (void)closeOutStream {
+    if(self.outStream != nil) {
+        [self.outStream close];
+        self.outStream = nil;
+    }
+
+}
+
 - (void)readWithPath:(NSString *)path useEncoding:(NSString *)encoding bufferSize:(int) bufferSize{
     
     self.inStream = [[NSInputStream alloc] initWithFileAtPath:path];
     // start NSStream is a runloop
     dispatch_async(queue, ^ {
         [inStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
-                             forMode:NSDefaultRunLoopMode];
+                            forMode:NSDefaultRunLoopMode];
         [inStream open];
         [[NSRunLoop currentRunLoop] run];
-    
+        
     });
 }
 
-// close file write stream
-- (void)closeOutStream {
-    if(self.outStream != nil) {
-        [self.outStream close];
-        self.outStream = nil;
-    }
-
-}
-
 // close file read stream
 - (void)closeInStream {
     if(self.inStream != nil) {
             NSMutableData * chunkData = [[NSMutableData data] init];
             NSInteger chunkSize = 4096;
             if([[self.encoding lowercaseString] isEqualToString:@"base64"])
-                chunkSize = 4098;
+                chunkSize = 4095;
             if(self.bufferSize > 0)
                 chunkSize = self.bufferSize;
             uint8_t buf[chunkSize];
                 [chunkData appendBytes:(const void *)buf length:len];
                 // TODO : file read progress ?
                 // dispatch data event
-                NSString * encodedChunk;
+                NSString * encodedChunk = [NSString alloc];
                 if( [[self.encoding lowercaseString] isEqualToString:@"utf8"] ) {
                     encodedChunk = [encodedChunk initWithData:chunkData encoding:NSUTF8StringEncoding];
                 }
                      ];
                     return;
                 }
-                runOnMainQueueWithoutDeadlocking(^{
-                    [self.bridge.eventDispatcher
-                     sendDeviceEventWithName:streamEventCode
-                     body:@{
-                            @"event": FS_EVENT_DATA,
-                            @"detail": encodedChunk
-                            }
-                     ];
-                });
+
+                [self.bridge.eventDispatcher
+                 sendDeviceEventWithName:streamEventCode
+                 body:@{
+                        @"event": FS_EVENT_DATA,
+                        @"detail": encodedChunk
+                        }
+                 ];
+
             }
             // end of stream
             else {
     });
 }
 
+RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
+    
+    NSFileManager * fm = [NSFileManager defaultManager];
+    NSData * fileContent = nil;
+    
+    if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
+        fileContent = [[NSData alloc] initWithData:[data dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES]];
+    }
+    else if([[encoding lowercaseString] isEqualToString:@"base64"]) {
+        fileContent = [[NSData alloc] initWithBase64EncodedData:data options:0];
+    }
+    else {
+        fileContent = [[NSData alloc] initWithData:[data dataUsingEncoding:NSASCIIStringEncoding allowLossyConversion:YES]];
+    }
+    
+    BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
+    if(success == YES)
+        callback(@[[NSNull null]]);
+    else
+        callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
+
+}
+
+
 RCT_EXPORT_METHOD(exists:(NSString *)path callback:(RCTResponseSenderBlock)callback) {
     BOOL isDir = NO;
     BOOL exists = NO;
 
 RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
     FetchBlobFS *fileStream = [[FetchBlobFS alloc] initWithBridgeRef:self.bridge];
+    if(bufferSize == nil) {
+        if([[encoding lowercaseString] isEqualToString:@"base64"])
+            bufferSize = 4095;
+        else
+            bufferSize = 4096;
+    }
     [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
 }
 
     FetchBlobFS * fileStream = [[FetchBlobFS alloc] initWithBridgeRef:self.bridge];
     NSFileManager * fm = [NSFileManager defaultManager];
     BOOL isDir = nil;
-    BOOL exist = ![fm fileExistsAtPath:path isDirectory:&isDir];
+    BOOL exist = [fm fileExistsAtPath:path isDirectory:&isDir];
     if( exist == NO || isDir == YES) {
         callback(@[[NSString stringWithFormat:@"target path `%@` may not exists or it's a folder", path]]);
         return;
 }
 
 RCT_EXPORT_METHOD(ls:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
+    NSFileManager* fm = [NSFileManager defaultManager];
+    BOOL exist = nil;
+    BOOL isDir = nil;
+    exist = [fm fileExistsAtPath:path isDirectory:&isDir];
+    if(exist == NO || isDir == NO) {
+        callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not a folder", path]]);
+        return ;
+    }
     NSError * error = nil;
     NSArray * result = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:&error];
     
 
 RCT_EXPORT_METHOD(cp:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
-    BOOL result = [[NSFileManager defaultManager] copyItemAtURL:path toURL:dest error:&error];
+    BOOL result = [[NSFileManager defaultManager] copyItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
     
     if(error == nil)
         callback(@[[NSNull null], @YES]);
 
 RCT_EXPORT_METHOD(mv:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
-    BOOL result = [[NSFileManager defaultManager] moveItemAtURL:path toURL:dest error:&error];
+    BOOL result = [[NSFileManager defaultManager] moveItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
     
     if(error == nil)
         callback(@[[NSNull null], @YES]);
 }
 
 RCT_EXPORT_METHOD(mkdir:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
-    if([FetchBlobFS exists:path])
-        callback(@[@"file path exists"]);
+    if([FetchBlobFS exists:path]) {
+        callback(@[@"mkdir failed, folder already exists"]);
+        return;
+    }
     else
         [FetchBlobFS mkdir:path];
     callback(@[[NSNull null]]);