#2 ios download to file API complete

src/index.js

   Platform,
 } from 'react-native'
 
+type RNFetchBlobNative = {
+  fetchBlob : (
+    options:fetchConfig,
+    taskId:string,
+    method:string,
+    url:string,
+    headers:any,
+    body:any,
+    callback:(err:any, ...data:any) => void
+  ) => void,
+  fetchBlobForm : (
+    options:fetchConfig,
+    taskId:string,
+    method:string,
+    url:string,
+    headers:any,
+    form:Array<any>,
+    callback:(err:any, ...data:any) => void
+  ) => void,
+  readStream : (
+    taskId:string,
+    path:string,
+    encode: 'utf8' | 'ascii' | 'base64'
+  ) => void,
+  getEnvironmentDirs : (dirs:any) => void,
+  flush : () => void
+};
+
 import base64 from 'base-64'
 const emitter = (Platform.OS === 'android' ? DeviceEventEmitter : NativeAppEventEmitter)
-const RNFetchBlob = NativeModules.RNFetchBlob
+const RNFetchBlob:RNFetchBlobNative = NativeModules.RNFetchBlob
 
 emitter.addListener("RNFetchBlobMessage", (e) => {
 
 type fetchConfig = {
   fileCache : bool,
   path : string,
+};
+
+function getSystemDirs() {
+  return new Promise((resolve, reject) => {
+    try {
+      RNFetchBlob.getEnvironmentDirs((...dirs) => {
+        console.log('##',...dirs)
+        let [PictureDir, MovieDir, DocumentDir, CacheDir] = [...dirs]
+        resolve({PictureDir, MovieDir, DocumentDir, CacheDir})
+      })
+    } catch(err) {
+      reject(err)
+    }
+  })
+
 }
 
-const config = function(options) {
+function config (options:fetchConfig) {
   return { fetch : fetch.bind(options) }
 }
 
 // Promise wrapper function
-const fetch = function(...args:any) {
+function fetch(...args:any) {
 
   let options = this || {}
 
         reject(new Error(err, ...data))
       else {
         let respType = 'base64'
-        if(options.fileCache || options.path)
+        if(options.path || options.fileCache)
           respType = 'path'
-        resolve(new FetchBlobResponse(taskId, options.path, respType,...data))
+        resolve(new FetchBlobResponse(taskId, respType, ...data))
       }
 
     })
 class FetchBlobResponse {
 
   taskId : string;
-  path : string;
+  path : () => string | null;
   type : 'base64' | 'path';
   data : any;
   blob : (contentType:string, sliceSize:number) => null;
     fn:(event : 'data' | 'end', chunk:any) => void
   ) => void;
 
-  constructor(taskId:string, path:string, type:'base64' | 'path',data:any) {
+  constructor(taskId:string, type:'base64' | 'path', data:any) {
     this.data = data
-    this.path = path
     this.taskId = taskId
+    this.type = type
     /**
      * Convert result to javascript Blob object.
      * @param  {string} contentType MIME type of the blob object.
       RNFetchBlob.flush(this.taskId, this.path)
     }
 
+    this.path = () => {
+      if(this.type === 'path')
+        return this.data
+      return null
+    }
+
     /**
      * Start read stream from cached file
      * @param  {String} encoding Encode type, should be one of `base64`, `ascrii`, `utf8`.
           subscription()
       })
 
-      RNFetchBlob.readStream(this.taskId, this.path, encode)
+      if(this.type === 'path') {
+        RNFetchBlob.readStream(this.taskId, this.data, encode)
+      }
+      else {
+        console.warn('RNFetchblob', 'this response data does not contains any available stream')
+      }
+
     }
 
   }
 }
 
 export default {
-  fetch, FetchBlobResponse, base64
+  fetch, base64, config, getSystemDirs
 }

src/ios/RNFetchBlob/RNFetchBlob.m

 
 + (NSString *) getDocumentDir {
 
-    return NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+    return [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
 }
 
 + (NSString *) getMusicDir {
-    return NSSearchPathForDirectoriesInDomains(NSMusicDirectory, NSUserDomainMask, YES);
+    return [NSSearchPathForDirectoriesInDomains(NSMusicDirectory, NSUserDomainMask, YES) firstObject];
 }
 
 + (NSString *) getMovieDir {
-    return NSSearchPathForDirectoriesInDomains(NSMoviesDirectory, NSUserDomainMask, YES);
+    return [NSSearchPathForDirectoriesInDomains(NSMoviesDirectory, NSUserDomainMask, YES) firstObject];
 }
 
 + (NSString *) getPictureDir {
-    return NSSearchPathForDirectoriesInDomains(NSPicturesDirectory, NSUserDomainMask, YES);
+    return [NSSearchPathForDirectoriesInDomains(NSPicturesDirectory, NSUserDomainMask, YES) firstObject];
 }
 
 + (NSString *) getTempPath:(NSString*)taskId {
 
-    NSString * documentDir = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
-    NSString * filename = [NSString stringWithFormat:@"RNFetchBlobTmp_%s", taskId];
+    NSString * documentDir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+    NSString * filename = [NSString stringWithFormat:@"/RNFetchBlobTmp_%@", taskId];
     NSString * tempPath = [documentDir stringByAppendingString: filename];
     return tempPath;
 }
 }
 
 - (void)openWithPath:(NSString *)destPath {
-    self.outStream = [[NSOutputStream alloc]init];
-    [self.outStream initToFileAtPath:destPath append:NO];
+    self.outStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:YES];
+    [self.outStream open];
 }
 
 
 }
 
 // Write file chunk into an opened stream
-- (void)write:(NSString *) chunk {
-    [self.outStream write:[chunk cStringUsingEncoding:NSASCIIStringEncoding] maxLength:chunk.length];
+- (void)write:(NSData *) chunk toPath:(NSString *) path{
+    NSUInteger left = [chunk length];
+    NSUInteger nwr = 0;
+    do {
+        nwr = [self.outStream write:[chunk bytes] maxLength:left];
+        if (-1 == nwr) break;
+        left -= nwr;
+    } while (left > 0);
+    if (left) {
+        NSLog(@"stream error: %@", [self.outStream streamError]);
+    }
 }
 
 - (void)readWithPath:(NSString *)path useEncoding:(NSString *)encoding {
         [self readWithPath:path useEncoding:encoding];
 }
 
-// close file stream
+// close file write stream
 - (void)closeOutStream {
     if(self.outStream != nil) {
         [self.outStream close];
 
 }
 
+// close file read stream
 - (void)closeInStream {
     if(self.inStream != nil) {
         [self.inStream close];
 - (void)stream:(NSStream *)stream handleEvent:(NSStreamEvent)eventCode {
 
     switch(eventCode) {
-    
+            
+        // write stream event
+        case NSStreamEventHasSpaceAvailable:
+        {
+            
+        
+        }
+        
+        // read stream incoming chunk
         case NSStreamEventHasBytesAvailable:
         {
             
             }
             break;
         }
+            
+        // stream error
         case NSStreamEventErrorOccurred:
         {
             [self.bridge.eventDispatcher
         self.fileStream = [[FetchBlobFS alloc]initWithCallback:self.callback];
         [self.fileStream openWithPath:path];
     }
-    else if ( [self.options valueForKey:CONFIG_USE_TEMP] == YES ) {
+    else if ( [self.options valueForKey:CONFIG_USE_TEMP]!= nil ) {
         self.fileStream = [[FetchBlobFS alloc]initWithCallback:self.callback];
         [self.fileStream openWithId:taskId];
     }
 
 
 - (void) connection:(NSURLConnection *)connection didReceiveResponse:(nonnull NSURLResponse *)response {
-    [UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
+//    [UIApplication sharedApplication].networkActivityIndicatorVisible = YES;
     expectedBytes = [response expectedContentLength];
 }
 
     
     Boolean fileCache = [self.options valueForKey:CONFIG_USE_TEMP];
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
-    
+    if(path != nil) {
+        [self.fileStream write:data toPath:path];
+    }
     // write to tmp file
-    if( fileCache == YES || path != nil ) {
-        [self.fileStream write:data];
+    else if( fileCache != nil) {
+        [self.fileStream write:data toPath:[FetchBlobFS getTempPath:self.taskId ]];
     }
     // cache data in memory
     else {
 
 - (void) connection:(NSURLConnection *)connection didFailWithError:(NSError *)error {
     
-    [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
+//    [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
     
     [self.fileStream closeInStream];
     [self.fileStream closeOutStream];
     else
         data = [[NSData alloc] init];
     
-    NSString * path = [NSString stringWithString:[self.options valueForKey:CONFIG_FILE_PATH]];
+    NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
+    Boolean useCache = [self.options valueForKey:CONFIG_USE_TEMP];
     
     [self.fileStream closeInStream];
     
         callback(@[[NSNull null], path]);
     }
     // when fileCache option is set but no path specified, save to tmp path
-    else if( [self.options valueForKey:CONFIG_USE_TEMP] == YES || path != nil ) {
+    else if( [self.options valueForKey:CONFIG_USE_TEMP] != nil) {
         NSString * tmpPath = [FetchBlobFS getTempPath:taskId];
         callback(@[[NSNull null], tmpPath]);
     }
 RCT_EXPORT_MODULE();
 
 // Fetch blob data request
-RCT_EXPORT_METHOD(fetchBlobForm:(NSDictionary *)options taskId:(NSString *)taskId method:(NSString *)method url:(NSString *)url headers:(NSDictionary *)headers form:(NSArray *)form callback:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(fetchBlobForm:(NSDictionary *)options
+                  taskId:(NSString *)taskId
+                  method:(NSString *)method
+                  url:(NSString *)url
+                  headers:(NSDictionary *)headers
+                  form:(NSArray *)form
+                  callback:(RCTResponseSenderBlock)callback)
 {
     
     // send request
 }
 
 // Fetch blob data request
-RCT_EXPORT_METHOD(fetchBlob:(NSDictionary *)options taskId:(NSString *)taskId method:(NSString *)method url:(NSString *)url headers:(NSDictionary *)headers body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(fetchBlob:(NSDictionary *)options
+                  taskId:(NSString *)taskId
+                  method:(NSString *)method
+                  url:(NSString *)url
+                  headers:(NSDictionary *)headers
+                  body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
     // send request
     NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
     [[NSFileManager defaultManager] removeItemAtPath:path error:&error];
 }
 
+RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
+    
+    callback(@[
+               [FetchBlobFS getPictureDir],
+               [FetchBlobFS getMovieDir],
+               [FetchBlobFS getDocumentDir],
+               [FetchBlobFS getCacheDir],
+            ]);
+}
+
 @end