#27 add append option to writeFile API

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

     }
 
     @ReactMethod
-    public void writeFileArray(String path, ReadableArray data, Promise promise) {
-        RNFetchBlobFS.writeFile(path, data, promise);
+    public void writeFileArray(String path, ReadableArray data, boolean append, Promise promise) {
+        RNFetchBlobFS.writeFile(path, data, append, promise);
     }
 
     @ReactMethod
-    public void writeFile(String path, String encoding, String data, Promise promise) {
-        RNFetchBlobFS.writeFile(path, encoding, data, promise);
+    public void writeFile(String path, String encoding, String data, boolean append, Promise promise) {
+        RNFetchBlobFS.writeFile(path, encoding, data, append, promise);
     }
 
     @ReactMethod

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

      * @param data Array passed from JS context.
      * @param promise
      */
-    static public void writeFile(String path, String encoding, String data, final Promise promise) {
+    static public void writeFile(String path, String encoding, String data, final boolean append, final Promise promise) {
         AsyncTask<String, Integer, Integer> task = new AsyncTask<String, Integer, Integer>() {
             @Override
             protected Integer doInBackground(String... args) {
                     File dir = f.getParentFile();
                     if(!dir.exists())
                         dir.mkdirs();
-                    FileOutputStream fout = new FileOutputStream(f);
+                    FileOutputStream fout = new FileOutputStream(f, append);
                     fout.write(stringToBytes(data, encoding));
                     fout.close();
                     promise.resolve(Arguments.createArray());
      * @param data Array passed from JS context.
      * @param promise
      */
-    static public void writeFile(String path, ReadableArray data, final Promise promise) {
+    static public void writeFile(String path, ReadableArray data, final boolean append, final Promise promise) {
         AsyncTask<Object, Void, Void> task = new AsyncTask<Object, Void, Void>() {
             @Override
             protected Void doInBackground(Object... args) {
                     File dir = f.getParentFile();
                     if(!dir.exists())
                         dir.mkdirs();
-                    FileOutputStream os = new FileOutputStream(f);
+                    FileOutputStream os = new FileOutputStream(f, append);
                     byte [] bytes = new byte[data.size()];
                     for(int i=0;i<data.size();i++) {
                         bytes[i] = (byte) data.getInt(i);

src/fs.js

   return RNFetchBlob.readFile(path, encoding)
 }
 
-function writeFile(path:string, encoding:string, data:string | Array<number>):Promise {
+/**
+ * Write data to file.
+ * @param  {string} path  Path of the file.
+ * @param  {string | number[]} data Data to write to the file.
+ * @param  {string} encoding Encoding of data (Optional).
+ * @return {Promise}
+ */
+function writeFile(path:string, data:string | Array<number>, encoding:?string):Promise {
+  encoding = encoding || 'utf8'
+  if(typeof path !== 'string')
+    return Promise.reject('Invalid argument "path" ')
+  if(encoding.toLocaleLowerCase() === 'ascii') {
+    if(!Array.isArray(data))
+      Promise.reject(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`)
+    else
+      return RNFetchBlob.writeFileArray(path, data, false);
+  } else {
+    if(typeof data !== 'string')
+      Promise.reject(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`)
+    else
+      return RNFetchBlob.writeFile(path, encoding, data, false);
+  }
+}
+
+function appendFile(path:string, data:string | Array<number>, encoding:?string):Promise {
+  encoding = encoding || 'utf8'
   if(typeof path !== 'string')
     return Promise.reject('Invalid argument "path" ')
   if(encoding.toLocaleLowerCase() === 'ascii') {
     if(!Array.isArray(data))
       Promise.reject(`Expected "data" is an Array when encoding is "ascii", however got ${typeof data}`)
     else
-      return RNFetchBlob.writeFileArray(path, data);
+      return RNFetchBlob.writeFileArray(path, data, true);
   } else {
     if(typeof data !== 'string')
       Promise.reject(`Expected "data" is a String when encoding is "utf8" or "base64", however got ${typeof data}`)
     else
-      return RNFetchBlob.writeFile(path, encoding, data);
+      return RNFetchBlob.writeFile(path, encoding, data, true);
   }
 }
 

src/ios/RNFetchBlob/RNFetchBlob.m

     [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject];
 })
 
-RCT_EXPORT_METHOD(writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
-    [RNFetchBlobFS writeFile:path encoding:encoding data:data resolver:resolve rejecter:reject];
+RCT_EXPORT_METHOD(writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+    [RNFetchBlobFS writeFile:path encoding:encoding data:data append:append resolver:resolve rejecter:reject];
 })
 
-RCT_EXPORT_METHOD(writeFileArray:(NSString *)path data:(NSArray *)data resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
-    [RNFetchBlobFS writeFileArray:path data:data resolver:resolve rejecter:reject];
+RCT_EXPORT_METHOD(writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+    [RNFetchBlobFS writeFileArray:path data:data append:append resolver:resolve rejecter:reject];
 })
 
 RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {

src/ios/RNFetchBlobFS.h

 + (BOOL) mkdir:(NSString *) path;
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error;
 + (BOOL) exists:(NSString *) path;
-+ (void) writeFileArray:(NSString *)path data:(NSArray *)data resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
-+ (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
++ (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
++ (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 + (void) readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 
 // constructor

src/ios/RNFetchBlobFS.m

     return tempPath;
 }
 
-+ (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
++ (void) writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
     @try {
         NSFileManager * fm = [NSFileManager defaultManager];
         NSError * err = nil;
+        // check if the folder exists, if not exists, create folders recursively
+        // after the folders created, write data into the file
         NSString * folder = [path stringByDeletingLastPathComponent];
         if(![fm fileExistsAtPath:folder]) {
             [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:&err];
         }
+        // if file exists, write file by encoding and strategy
         if(![fm fileExistsAtPath:path]) {
             if([[encoding lowercaseString] isEqualToString:@"base64"]){
                 NSData * byteData = [[NSData alloc] initWithBase64EncodedString:data options:0];
         }
         else {
             NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
-            [fileHandle seekToEndOfFile];
+            NSData * content = nil;
             if([[encoding lowercaseString] isEqualToString:@"base64"]) {
-                NSData * byteData = [[NSData alloc] initWithBase64EncodedString:data options:0];
-                [fileHandle writeData:byteData];
+                content = [[NSData alloc] initWithBase64EncodedString:data options:0];
+            }
+            else {
+                content = [data dataUsingEncoding:NSUTF8StringEncoding];
+            }
+            if(append == YES) {
+                [fileHandle seekToEndOfFile];
+                [fileHandle writeData:content];
+                [fileHandle closeFile];
+            }
+            else {
+                [content writeToFile:path atomically:YES];
             }
-            else
-                [fileHandle writeData:[data dataUsingEncoding:NSUTF8StringEncoding]];
-            [fileHandle closeFile];
         }
         fm = nil;
         resolve([NSNull null]);
     }
 }
 
-+ (void) writeFileArray:(NSString *)path data:(NSArray *)data resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
++ (void) writeFileArray:(NSString *)path data:(NSArray *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
     @try {
         NSFileManager * fm = [NSFileManager defaultManager];
+        NSError * err = nil;
+        // check if the folder exists, if not exists, create folders recursively
+        // after the folders created, write data into the file
+        NSString * folder = [path stringByDeletingLastPathComponent];
+        if(![fm fileExistsAtPath:folder]) {
+            [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:&err];
+        }
         NSMutableData * fileContent = [NSMutableData alloc];
         // prevent stack overflow, alloc on heap
         char * bytes = (char*) malloc([data count]);
         for(int i = 0; i < data.count; i++) {
             bytes[i] = [[data objectAtIndex:i] charValue];
         }
-        // if append == NO
-//        BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
         [fileContent appendBytes:bytes length:data.count];
-        NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
-        [fileHandle seekToEndOfFile];
-        [fileHandle writeData:fileContent];
-        [fileHandle closeFile];
+        if(![fm fileExistsAtPath:path]) {
+            [fm createFileAtPath:path contents:fileContent attributes:NULL];
+        }
+        // if file exists, write file
+        else {
+            if(append == YES) {
+                NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
+                [fileHandle seekToEndOfFile];
+                [fileHandle writeData:fileContent];
+                [fileHandle closeFile];
+            }
+            else {
+                [fileContent writeToFile:path atomically:YES];
+            }
+        }
         free(bytes);
         fm = nil;
         resolve([NSNull null]);

test/test-0.6.0.js

 describe('writeFile test', (report, done) => {
   let path = dirs.DocumentDir + '/0.6.0-'+Date.now()+'/writeFileTest'+Date.now()
   let data = 'hellofrom'+Date.now()
-  fs.writeFile(path, 'utf8', data)
+  fs.writeFile(path, data)
     .then(() => fs.readFile(path, 'utf8'))
     .then((actual) => {
       report(<Assert key="utf8 content should correct" expect={data} actual={actual}/>)
       data += 'base64'
-      return fs.writeFile(path, 'base64', RNFetchBlob.base64.encode('base64'))
+      return fs.writeFile(path, RNFetchBlob.base64.encode('base64'), 'base64')
     })
     .then(() => fs.readFile(path, 'base64'))
     .then((actual) => {
         expect={RNFetchBlob.base64.decode(RNFetchBlob.base64.encode(data))}
         actual={RNFetchBlob.base64.decode(actual)}/>)
       data += 'ascii'
-      return fs.writeFile(path, 'ascii', getASCIIArray('ascii'));
+      return fs.writeFile(path, getASCIIArray('ascii'), 'ascii');
     })
     .then(() => fs.readFile(path, 'ascii'))
     .then((actual) => {