Improve file API consistency #18

src/fs.js

 
 /**
  * Get path of system directories.
- * @return {object} Map contains PictureDir, MovieDir, DocumentDir, CacheDir,
- * MusicDir, and DCIMDir, some directory might not be supported by platform.
+ * @return {object} Map contains DocumentDir, CacheDir, DCIMDir, DownloadDir,
+ * , some directory might not be supported by platform.
  */
 function getSystemDirs() {
   return new Promise((resolve, reject) => {
     try {
       RNFetchBlob.getEnvironmentDirs((...dirs) => {
-        let [PictureDir, MovieDir, DocumentDir, CacheDir, MusicDir, DCIMDir] = [...dirs]
-        resolve({PictureDir, MovieDir, DocumentDir, CacheDir, MusicDir, DCIMDir})
+        let [DocumentDir, CacheDir, DCIMDir, DownloadDir] = [...dirs]
+        resolve({DocumentDir, CacheDir, DCIMDir, DownloadDir})
       })
     } catch(err) {
       reject(err)
   }
 }
 
+/**
+ * Create write stream to a file.
+ * @param  {string} path Target path of file stream.
+ * @param  {string} encoding Encoding of input data.
+ * @param  {bool} append  A flag represent if data append to existing ones.
+ * @return {Promise<WriteStream>} A promise resolves a `WriteStream` object.
+ */
 function writeStream(
-  path:string,
-  encoding:'utf8' | 'ascii' | 'base64',
-  callback:(streamId:string) => void
+  path : string,
+  encoding : 'utf8' | 'ascii' | 'base64',
+  append? : ?bool,
 ):Promise<WriteStream> {
   if(!path)
     throw Error('RNFetchBlob could not open file stream with empty `path`')
   encoding = encoding || 'base64'
   return new Promise((resolve, reject) => {
-    RNFetchBlob.writeStream(path, encoding || 'base64', (streamId:string) => {
-      resolve(new WriteStream(streamId))
+    RNFetchBlob.writeStream(path, encoding || 'base64', append || false, (err, streamId:string) => {
+      if(err)
+        reject(err)
+      else
+        resolve(new WriteStream(streamId))
     })
   })
 }
 
 /**
  * Create file stream from file at `path`.
- * @param  {String} path   The file path.
- * @param  {String} encoding Data encoding, should be one of `base64`, `utf8`, `ascii`
- * @param  {String} bufferSize Size of stream buffer.
+ * @param  {string} path   The file path.
+ * @param  {string} encoding Data encoding, should be one of `base64`, `utf8`, `ascii`
+ * @param  {boolean} bufferSize Size of stream buffer.
  * @return {RNFetchBlobStream} RNFetchBlobStream stream instance.
  */
 function readStream(
-  path:string,
-  encoding:'utf8' | 'ascii' | 'base64',
-  bufferSize?:?number
+  path : string,
+  encoding : 'utf8' | 'ascii' | 'base64',
+  bufferSize? : ?number
 ):RNFetchBlobStream {
 
   if(!path)
   })
 }
 
+/**
+ * Check if file exists and if it is a folder.
+ * @param  {string} path Path to check
+ * @return {Promise<bool, bool>}
+ */
+function exists(path:string):Promise<bool, bool> {
+
+  return new Promise((resolve, reject) => {
+    try {
+      RNFetchBlob.exists(path, (exist, isDir) => {
+        resolve(exist, isDir)
+      })
+    } catch(err) {
+      reject(err)
+    }
+  })
+
+}
+
 /**
  * Session class
  * @class RNFetchBlobSession
 
   id : string;
   encoding : string;
+  append : bool;
 
-  constructor(streamId:string, encoding:string) {
+  constructor(streamId:string, encoding:string, append:string) {
     this.id = streamId
     this.encoding = encoding
+    this.append = append
   }
 
   write() {
     return new Promise((resolve, reject) => {
       try {
-        RNFetchBlob.writeChunk(this.id, data, this.encoding, () => {
-          resolve()
+        RNFetchBlob.writeChunk(this.id, data, (error) => {
+          if(error)
+            reject(error)
+          else
+            resolve()
         })
       } catch(err) {
         reject(err)

src/index.js

   unlink,
   mkdir,
   session,
+  writeStream,
   ls,
   mv,
   cp
 }
 
 export default {
-  fetch, base64, config, getSystemDirs, readStream, unlink, session, ls, mkdir, mv, cp
+  fetch, base64, config, getSystemDirs, readStream, unlink, session, ls, mkdir, mv, cp, writeStream
 }

src/ios/RNFetchBlob/RNFetchBlob.h

     Boolean isOpen;
     NSString * encoding;
     int bufferSize;
+    BOOL appendData;
     NSString * taskId;
     NSString * path;
     NSString * streamId;
 @property (nonatomic) NSString * path;
 @property (nonatomic) int bufferSize;
 @property (nonatomic) NSString * streamId;
+@property (nonatomic) BOOL appendData;
 
 + (NSString *) getTempPath;
 + (FetchBlobFS *) getFileStreams;
 @property (nonatomic) NSDictionary * options;
 @property (nonatomic) FetchBlobFS * fileStream;
 
+
 - (id) init;
 - (void) sendRequest;
 

src/ios/RNFetchBlob/RNFetchBlob.m

 @synthesize callback;
 @synthesize taskId;
 @synthesize path;
+@synthesize appendData;
 @synthesize bufferSize;
 
 // static member getter
     return self;
 }
 
-- (NSString *)openWithPath:(NSString *)destPath {
-    self.outStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:YES];
+// Create file stream for write data
+- (NSString *)openWithPath:(NSString *)destPath encode:(nullable NSString *)encode appendData:(BOOL)append {
+    self.outStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:append];
+    self.encoding = encode;
     [self.outStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
     [self.outStream open];
     NSString *uuid = [[NSUUID UUID] UUIDString];
     return uuid;
 }
 
+// Write file chunk into an opened stream
+- (void)writeEncodeChunk:(NSString *) chunk {
+    NSMutableData * decodedData = [NSData alloc];
+    if([[self.encoding lowercaseString] isEqualToString:@"base64"]) {
+        decodedData = [chunk dataUsingEncoding:NSUTF8StringEncoding];
+    }
+    if([[self.encoding lowercaseString] isEqualToString:@"utf8"]) {
+        decodedData = [chunk dataUsingEncoding:NSUTF8StringEncoding];
+    }
+    else if([[self.encoding lowercaseString] isEqualToString:@"ascii"]) {
+        decodedData = [chunk dataUsingEncoding:NSASCIIStringEncoding];
+    }
+    NSUInteger left = [chunk length];
+    NSUInteger nwr = 0;
+    do {
+        nwr = [self.outStream write:[decodedData bytes] maxLength:left];
+        if (-1 == nwr) break;
+        left -= nwr;
+    } while (left > 0);
+    if (left) {
+        NSLog(@"stream error: %@", [self.outStream streamError]);
+    }
+}
+
 // Write file chunk into an opened stream
 - (void)write:(NSData *) chunk {
     NSUInteger left = [chunk length];
     // open file stream for write
     if( path != nil) {
         self.fileStream = [[FetchBlobFS alloc]initWithCallback:self.callback];
-        [self.fileStream openWithPath:path];
+        [self.fileStream openWithPath:path encode:@"ascii" appendData:YES ];
     }
     else if ( [self.options valueForKey:CONFIG_USE_TEMP]!= nil ) {
         self.fileStream = [[FetchBlobFS alloc]initWithCallback:self.callback];
-        [self.fileStream openWithPath:[FetchBlobFS getTempPath:taskId withExtension:ext]];
+        [self.fileStream openWithPath:[FetchBlobFS getTempPath:taskId withExtension:ext] encode:@"ascii" appendData:YES];
     }
     
     NSURLConnection *conn = [[NSURLConnection alloc] initWithRequest:req delegate:self startImmediately:NO];
     });
 }
 
+RCT_EXPORT_METHOD(exists:(NSString *)path callback:(RCTResponseSenderBlock)callback) {
+    BOOL isDir = NO;
+    BOOL exists = NO;
+    exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
+    callback(@[@(exists), @(isDir)]);
+
+}
+
 RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
     FetchBlobFS *fileStream = [[FetchBlobFS alloc] initWithBridgeRef:self.bridge];
     [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
 }
 
-RCT_EXPORT_METHOD(writeStream:(NSString *)path withEncoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
-    FetchBlobFS *fileStream = [[FetchBlobFS alloc] initWithBridgeRef:self.bridge];
-    NSString * streamId = [fileStream openWithPath:path];
-    callback(@[streamId]);
+RCT_EXPORT_METHOD(writeStream:(NSString *)path withEncoding:(NSString *)encoding appendData:(BOOL)append callback:(RCTResponseSenderBlock)callback) {
+    FetchBlobFS * fileStream = [[FetchBlobFS alloc] initWithBridgeRef:self.bridge];
+    NSFileManager * fm = [NSFileManager defaultManager];
+    BOOL isDir = nil;
+    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;
+    }
+    NSString * streamId = [fileStream openWithPath:path encode:encoding appendData:append];
+    callback(@[[NSNull null], streamId]);
 }
 
-RCT_EXPORT_METHOD(writeChunk:(NSString *)streamId withData:(NSString *)data encoding:(NSString *)encode callback:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(writeChunk:(NSString *)streamId withData:(NSString *)data callback:(RCTResponseSenderBlock) callback) {
     FetchBlobFS *fs = [[FetchBlobFS getFileStreams] valueForKey:streamId];
-    NSMutableData * decodedData = [NSData alloc];
-    if([[encode lowercaseString] isEqualToString:@"base64"]) {
-        [fs write:[data dataUsingEncoding:NSUTF8StringEncoding]];
-    }
-    if([[encode lowercaseString] isEqualToString:@"utf8"]) {
-        [fs write:[data dataUsingEncoding:NSUTF8StringEncoding]];
-    }
-    else if([[encode lowercaseString] isEqualToString:@"ascii"]) {
-        [fs write:[data dataUsingEncoding:NSASCIIStringEncoding]];
-    }
+    [fs writeEncodeChunk:data];
+    callback(@[[NSNull null]]);
 }
 
 RCT_EXPORT_METHOD(closeStream:(NSString *)streamId callback:(RCTResponseSenderBlock) callback) {
 RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
     
     callback(@[
-               [FetchBlobFS getPictureDir],
-               [FetchBlobFS getMovieDir],
                [FetchBlobFS getDocumentDir],
                [FetchBlobFS getCacheDir],
             ]);