Add fs API URI support #114

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

 import android.content.CursorLoader;
 import android.content.res.AssetFileDescriptor;
 import android.database.Cursor;
+import android.graphics.Path;
 import android.media.MediaScannerConnection;
 import android.net.Uri;
 import android.os.AsyncTask;
      * @param path Destination file path.
      * @param encoding Encoding of the string.
      * @param data Array passed from JS context.
-     * @param promise
+     * @param promise RCT Promise
      */
     static public void writeFile(String path, String encoding, String data, final boolean append, final Promise promise) {
         try {
             FileOutputStream fout = new FileOutputStream(f, append);
             // write data from a file
             if(encoding.equalsIgnoreCase(RNFetchBlobConst.DATA_ENCODE_URI)) {
+                data = normalizePath(data);
                 File src = new File(data);
                 if(!src.exists()) {
                     promise.reject("RNfetchBlob writeFileError", "source file : " + data + "not exists");
      * Write array of bytes into file
      * @param path Destination file path.
      * @param data Array passed from JS context.
-     * @param promise
+     * @param promise RCT Promise
      */
     static public void writeFile(String path, ReadableArray data, final boolean append, final Promise promise) {
 
      * @param callback  JS context callback
      */
     static void cp(String path, String dest, Callback callback) {
+
         path = normalizePath(path);
         InputStream in = null;
         OutputStream out = null;
                 callback.invoke("cp error: source file at path`" + path + "` not exists");
                 return;
             }
-
             if(!new File(dest).exists())
                 new File(dest).createNewFile();
 
             }
 
         } catch (Exception err) {
-            if(err != null)
-                callback.invoke(err.getLocalizedMessage());
+            callback.invoke(err.getLocalizedMessage());
         } finally {
             try {
-                in.close();
-                out.close();
+                if (in != null) {
+                    in.close();
+                }
+                if (out != null) {
+                    out.close();
+                }
                 callback.invoke();
-            } catch (IOException e) {
+            } catch (Exception e) {
                 callback.invoke(e.getLocalizedMessage());
             }
         }
      * @param callback  JS context callback
      */
     static void exists(String path, Callback callback) {
-        path = normalizePath(path);
+
         if(isAsset(path)) {
             try {
                 String filename = path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, "");
             }
         }
         else {
+            path = normalizePath(path);
             boolean exist = new File(path).exists();
             boolean isDir = new File(path).isDirectory();
             callback.invoke(exist, isDir);
         }
-
     }
 
     /**
      * @param dest  Destination of created file
      * @param start Start byte offset in source file
      * @param end   End byte offset
-     * @param encode
+     * @param encode NOT IMPLEMENTED
      */
     public static void slice(String src, String dest, int start, int end, String encode, Promise promise) {
         try {
+            src = normalizePath(src);
             File source = new File(src);
             if(!source.exists()) {
                 promise.reject("RNFetchBlob.slice error", "source file : " + src + " not exists");
      */
     static void stat(String path, Callback callback) {
         try {
+            path = normalizePath(path);
             WritableMap result = statFile(path);
             if(result == null)
                 callback.invoke("stat error: failed to list path `" + path + "` for it is not exist or it is not a folder", null);

src/ios/RNFetchBlob/RNFetchBlob.m

     }];
 }
 
+#pragma mark - fs.createFile
 RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
 
     NSFileManager * fm = [NSFileManager defaultManager];
         callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
 
 }
-
+#pragma mark - fs.createFileASCII
 // method for create file with ASCII content
 RCT_EXPORT_METHOD(createFileASCII:(NSString *)path data:(NSArray *)dataArray callback:(RCTResponseSenderBlock)callback) {
 
 
 }
 
-
+#pragma mark - fs.exists
 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)]);
-
+    [RNFetchBlobFS exists:path callback:callback];
 }
 
+#pragma mark - fs.writeFile
 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:[NSString stringWithString:encoding] data:data append:append resolver:resolve rejecter:reject];
 })
 
+#pragma mark - fs.writeArray
 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];
 })
 
+#pragma mark - fs.writeStream
 RCT_EXPORT_METHOD(writeStream:(NSString *)path withEncoding:(NSString *)encoding appendData:(BOOL)append callback:(RCTResponseSenderBlock)callback) {
     RNFetchBlobFS * fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     NSFileManager * fm = [NSFileManager defaultManager];
     callback(@[[NSNull null], streamId]);
 }
 
+#pragma mark - fs.writeArrayChunk
 RCT_EXPORT_METHOD(writeArrayChunk:(NSString *)streamId withArray:(NSArray *)dataArray callback:(RCTResponseSenderBlock) callback) {
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     char * bytes = (char *) malloc([dataArray count]);
     callback(@[[NSNull null]]);
 }
 
+#pragma mark - fs.writeChunk
 RCT_EXPORT_METHOD(writeChunk:(NSString *)streamId withData:(NSString *)data callback:(RCTResponseSenderBlock) callback) {
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     [fs writeEncodeChunk:data];
     callback(@[[NSNull null]]);
 }
 
+#pragma mark - fs.closeStream
 RCT_EXPORT_METHOD(closeStream:(NSString *)streamId callback:(RCTResponseSenderBlock) callback) {
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     [fs closeOutStream];
         callback(@[[NSString stringWithFormat:@"failed to unlink file or path at %@", path]]);
 }
 
+#pragma mark - fs.removeSession
 RCT_EXPORT_METHOD(removeSession:(NSArray *)paths callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     NSString * tmpPath = nil;
 
 }
 
+#pragma mark - fs.ls
 RCT_EXPORT_METHOD(ls:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
 
 }
 
-RCT_EXPORT_METHOD(stat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
-    NSFileManager* fm = [NSFileManager defaultManager];
-    BOOL exist = nil;
-    BOOL isDir = nil;
-    NSError * error = nil;
-
-    path = [RNFetchBlobFS getPathOfAsset:path];
-
-    exist = [fm fileExistsAtPath:path isDirectory:&isDir];
-    if(exist == NO) {
-        callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not exist", path]]);
-        return ;
-    }
-    NSData * res = [RNFetchBlobFS stat:path error:&error];
-
-    if(error == nil)
-        callback(@[[NSNull null], res]);
-    else
-        callback(@[[error localizedDescription], [NSNull null]]);
+#pragma mark - fs.stat
+RCT_EXPORT_METHOD(stat:(NSString *)target callback:(RCTResponseSenderBlock) callback) {
+    
+    [RNFetchBlobFS getPathFromUri:target completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        __block NSMutableArray * result;
+        if(path != nil)
+        {
+            NSFileManager* fm = [NSFileManager defaultManager];
+            BOOL exist = nil;
+            BOOL isDir = nil;
+            NSError * error = nil;
+            
+            exist = [fm fileExistsAtPath:path isDirectory:&isDir];
+            if(exist == NO) {
+                callback(@[[NSString stringWithFormat:@"failed to stat path `%@` for it is not exist or it is not exist", path]]);
+                return ;
+            }
+            result = [RNFetchBlobFS stat:path error:&error];
+            
+            if(error == nil)
+                callback(@[[NSNull null], result]);
+            else
+                callback(@[[error localizedDescription], [NSNull null]]);
 
+        }
+        else if(asset != nil)
+        {
+            __block NSNumber * size = [NSNumber numberWithLong:[asset size]];
+            result = [asset metadata];
+            [result setValue:size forKey:@"size"];
+            callback(@[[NSNull null], result]);
+        }
+        else
+        {
+            callback(@[@"failed to stat path, could not resolve URI", [NSNull null]]);
+        }
+    }];
 }
 
+#pragma mark - fs.lstat
 RCT_EXPORT_METHOD(lstat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
 
 }
 
+#pragma mark - fs.cp
 RCT_EXPORT_METHOD(cp:(NSString*)src toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     
 //    path = [RNFetchBlobFS getPathOfAsset:path];
     
 }
 
+
+#pragma mark - fs.mv
 RCT_EXPORT_METHOD(mv:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     BOOL result = [[NSFileManager defaultManager] moveItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
 
 }
 
+#pragma mark - fs.mkdir
 RCT_EXPORT_METHOD(mkdir:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
-    if([RNFetchBlobFS exists:path]) {
+    if([[NSFileManager defaultManager] fileExistsAtPath:path]) {
         callback(@[@"mkdir failed, folder already exists"]);
         return;
     }
     callback(@[[NSNull null]]);
 }
 
+#pragma mark - fs.readFile
 RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
 
     [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject onComplete:nil];
 })
 
+#pragma mark - fs.readStream
 RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
 
     RNFetchBlobFS *fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
 }
 
+#pragma mark - fs.getEnvionmentDirs
 RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
 
     callback(@[
                ]);
 }
 
+#pragma mark - net.cancelRequest
 RCT_EXPORT_METHOD(cancelRequest:(NSString *)taskId callback:(RCTResponseSenderBlock)callback) {
     [RNFetchBlobNetwork cancelRequest:taskId];
     callback(@[[NSNull null], taskId]);
 
 }
 
+#pragma mark - net.enableProgressReport
 RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId {
     [RNFetchBlobNetwork enableProgressReport:taskId];
 })
 
+#pragma mark - net.enableUploadProgressReport
 RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId {
     [RNFetchBlobNetwork enableUploadProgress:taskId];
 })
 
+#pragma mark - fs.slice
 RCT_EXPORT_METHOD(slice:(NSString *)src dest:(NSString *)dest start:(nonnull NSNumber *)start end:(nonnull NSNumber *)end resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
 {
     [RNFetchBlobFS slice:src dest:dest start:start end:end encode:@"" resolver:resolve rejecter:reject];

src/ios/RNFetchBlobFS.h

 + (RNFetchBlobFS *) getFileStreams;
 + (BOOL) mkdir:(NSString *) path;
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error;
-+ (BOOL) exists:(NSString *) path;
++ (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback;
 + (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 onComplete:(void (^)(NSData * content))onComplete;

src/ios/RNFetchBlobFS.m

 
 # pragma write file from file
 
-+ (NSNumber *) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append
++ (NSNumber *) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append callback:(void(^)(NSString * errMsg, NSNumber *size))callback
 {
+    [[self class] getPathFromUri:src completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        if(path != nil)
+        {
+            __block NSInputStream * is = [[NSInputStream alloc] initWithFileAtPath:path];
+            __block NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
+            [is open];
+            [os open];
+            uint8_t buffer[10240];
+            __block long written = 0;
+            int read = [is read:buffer maxLength:10240];
+            written += read;
+            while(read > 0) {
+                [os write:buffer maxLength:read];
+                read = [is read:buffer maxLength:10240];
+                written += read;
+            }
+            [os close];
+            [is close];
+            __block NSNumber * size = [NSNumber numberWithLong:written];
+            callback(nil, size);
+        }
+        else if(asset != nil)
+        {
+            
+            __block NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
+            int read = 0;
+            int cursor = 0;
+            __block long written = 0;
+            uint8_t buffer[10240];
+            [os open];
+            while((read = [asset getBytes:buffer fromOffset:cursor length:10240 error:nil]) > 0)
+            {
+                [os write:buffer maxLength:read];
+            }
+            __block NSNumber * size = [NSNumber numberWithLong:written];
+            [os close];
+            callback(nil, size);
+        }
+        else
+            callback(@"failed to resolve path", nil);
+    }];
     
-    NSInputStream * is = [[NSInputStream alloc] initWithFileAtPath:src];
-    NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
-    [is open];
-    [os open];
-    uint8_t buffer[10240];
-    long written = 0;
-    int read = [is read:buffer maxLength:10240];
-    written += read;
-    while(read > 0) {
-        [os write:buffer maxLength:read];
-        read = [is read:buffer maxLength:10240];
-        written += read;
-    }
-    [os close];
-    [is close];
-    return [NSNumber numberWithLong:written];
+    return 0;
 }
 
 # pragma mark - write file
             [fm createFileAtPath:path contents:nil attributes:nil];
         }
         if(err != nil) {
-            reject(@"RNFetchBlob writeFile Error", @"could not create file at path", path);
+            reject(@"RNFetchBlob writeFile Error", @"could not create file at path", nil);
             return;
         }
         NSFileHandle *fileHandle = [NSFileHandle fileHandleForWritingAtPath:path];
             content = [[NSData alloc] initWithBase64EncodedString:data options:0];
         }
         else if([encoding isEqualToString:@"uri"]) {
-            NSNumber* size = [[self class] writeFileFromFile:data toFile:path append:append];
-            resolve(size);
+            NSNumber* size = [[self class] writeFileFromFile:data toFile:path append:append callback:^(NSString *errMsg, NSNumber *size) {
+                if(errMsg != nil)
+                    reject(@"RNFetchBlob writeFile Error", errMsg, nil);
+                else
+                    resolve(size);
+            }];
             return;
         }
         else {
 # pragma mark - stat
 
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error {
+
     
     BOOL isDir = NO;
     NSFileManager * fm = [NSFileManager defaultManager];
 
 # pragma mark - exists
 
-+ (BOOL) exists:(NSString *) path {
-    return [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:NULL];
++ (void) exists:(NSString *) path callback:(RCTResponseSenderBlock)callback
+{
+    [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
+        if(path != nil)
+        {
+            BOOL isDir = NO;
+            BOOL exists = NO;
+            exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
+            callback(@[@(exists), @(isDir)]);
+        }
+        else if(asset != nil)
+        {
+            callback(@[@YES, @NO]);
+        }
+        else
+        {
+            callback(@[@NO, @NO]);
+        }
+    }];
 }
 
 - (id)init {
      resolver:(RCTPromiseResolveBlock)resolve
      rejecter:(RCTPromiseRejectBlock)reject
 {
-    long expected = [end longValue] - [start longValue];
-    long read = 0;
-    NSFileHandle * handle = [NSFileHandle fileHandleForReadingAtPath:path];
-    NSFileManager * fm = [NSFileManager defaultManager];
-    NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
-    [os open];
-    // abort for the source file not exists
-    if([fm fileExistsAtPath:path] == NO)
+    [[self class] getPathFromUri:path completionHandler:^(NSString *path, ALAssetRepresentation *asset)
     {
-        reject(@"RNFetchBlob slice failed : the file does not exists", path, nil);
-        return;
-    }
-    long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
-    long max = MIN(size, [end longValue]);
-    
-    if(![fm fileExistsAtPath:dest]) {
-        [fm createFileAtPath:dest contents:@"" attributes:nil];
-    }
-    [handle seekToFileOffset:[start longValue]];
-    while(read < expected)
-    {
-        
-        NSData * chunk;
-        long chunkSize = 0;
-        if([start longValue] + read + 10240 > max)
+        if(path != nil)
+        {
+            long expected = [end longValue] - [start longValue];
+            long read = 0;
+            NSFileHandle * handle = [NSFileHandle fileHandleForReadingAtPath:path];
+            NSFileManager * fm = [NSFileManager defaultManager];
+            NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
+            [os open];
+            // abort for the source file not exists
+            if([fm fileExistsAtPath:path] == NO)
+            {
+                reject(@"RNFetchBlob slice failed : the file does not exists", path, nil);
+                return;
+            }
+            long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
+            long max = MIN(size, [end longValue]);
+            
+            if(![fm fileExistsAtPath:dest]) {
+                [fm createFileAtPath:dest contents:@"" attributes:nil];
+            }
+            [handle seekToFileOffset:[start longValue]];
+            while(read < expected)
+            {
+                
+                NSData * chunk;
+                long chunkSize = 0;
+                if([start longValue] + read + 10240 > max)
+                {
+                    NSLog(@"read chunk %lu", max - read - [start longValue]);
+                    chunkSize = max - read - [start longValue];
+                    chunk = [handle readDataOfLength:chunkSize];
+                }
+                else
+                {
+                    NSLog(@"read chunk %lu", 10240);
+                    chunkSize = 10240;
+                    chunk = [handle readDataOfLength:10240];
+                }
+                if([chunk length] <= 0)
+                    break;
+                long remain = expected - read;
+                
+                [os write:[chunk bytes] maxLength:chunkSize];
+                read += [chunk length];
+            }
+            [handle closeFile];
+            [os close];
+            resolve(dest);
+        }
+        else if (asset != nil)
         {
-            NSLog(@"read chunk %lu", max - read - [start longValue]);
-            chunkSize = max - read - [start longValue];
-            chunk = [handle readDataOfLength:chunkSize];
+            long expected = [end longValue] - [start longValue];
+            long read = 0;
+            long chunkRead = 0;
+            NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:NO];
+            [os open];
+            long size = asset.size;
+            long max = MIN(size, [end longValue]);
+            
+            while(read < expected)
+            {
+                
+                uint8_t * chunk[10240];
+                long chunkSize = 0;
+                if([start longValue] + read + 10240 > max)
+                {
+                    NSLog(@"read chunk %lu", max - read - [start longValue]);
+                    chunkSize = max - read - [start longValue];
+                    chunkRead = [asset getBytes:chunk fromOffset:[start longValue] + read length:chunkSize error:nil];
+                }
+                else
+                {
+                    NSLog(@"read chunk %lu", 10240);
+                    chunkSize = 10240;
+                    chunkRead = [asset getBytes:chunk fromOffset:[start longValue] + read length:chunkSize error:nil];
+                }
+                if( chunkRead <= 0)
+                    break;
+                long remain = expected - read;
+                
+                [os write:chunk maxLength:chunkSize];
+                read += chunkRead;
+            }
+            [os close];
+            resolve(dest);
         }
         else
         {
-            NSLog(@"read chunk %lu", 10240);
-            chunkSize = 10240;
-            chunk = [handle readDataOfLength:10240];
+            reject(@"slice error",  [NSString stringWithFormat: @"could not resolve URI %@", path ], nil);
         }
-        if([chunk length] <= 0)
-            break;
-        long remain = expected - read;
-    
-        [os write:[chunk bytes] maxLength:chunkSize];
-        read += [chunk length];
-    }
-    [handle closeFile];
-    [os close];
-    resolve(dest);
-    
+        
+    }];
 }
 
 // close file read stream