Add stat lstat to IOS fs API

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

         RNFetchBlobFS.removeSession(paths, callback);
     }
 
+    @ReactMethod
+    public void lstat(String path, Callback callback) {
+        RNFetchBlobFS.ls(path, callback);
+    }
+
+    @ReactMethod
+    public void stat(String path, Callback callback) {
+        RNFetchBlobFS.stat(path, callback);
+    }
+
+    @ReactMethod
+    public void scanFile(ReadableMap pairs, Callback callback) {
+        ReadableMapKeySetIterator it = pairs.keySetIterator();
+        WritableArray path = Arguments.createArray();
+        WritableArray mimes = Arguments.createArray();
+        while(it.hasNextKey()) {
+            String key = pairs.keySetIterator().nextKey();
+            path.pushString(key);
+            String mime = pairs.getString(key);
+            mimes.pushString(mime);
+        }
+        String [] p = new String[path.size()];
+        String [] m = new String[path.size()];
+        for(int i =0;i<path.size();i++) {
+            p[i] = path.getString(i);
+            m[i] = mimes.getString(i);
+        }
+        new RNFetchBlobFS(this.getReactApplicationContext()).scanFile(p, m, callback);
+    }
+
     @ReactMethod
     /**
      * @param path Stream file path

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

 package com.RNFetchBlob;
 
+import android.media.MediaScannerConnection;
+import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Environment;
 
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
     static public void getSystemfolders(ReactApplicationContext ctx, Callback callback) {
         callback.invoke(
                 // document folder
-                String.valueOf(ctx.getFilesDir().getAbsolutePath()),
+                ctx.getFilesDir().getAbsolutePath(),
                 // cache folder
-                String.valueOf(ctx.getCacheDir().getAbsolutePath()),
+                ctx.getCacheDir().getAbsolutePath(),
                 // SD card folder
-                String.valueOf(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath()),
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath(),
                 // Download folder
-                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getAbsolutePath()
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getAbsolutePath(),
+                // Picture
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES).getAbsolutePath(),
+                // Music
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC).getAbsolutePath(),
+                // Movies
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES).getAbsolutePath(),
+                // Ringtones
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_RINGTONES).getAbsolutePath()
         );
     }
 
     public void writeStream(String path, String encoding, boolean append, Callback callback) {
         File dest = new File(path);
         if(!dest.exists() || dest.isDirectory()) {
-            callback.invoke("target path `" + path + "` may not exists or it's a folder");
+            callback.invoke("write stream error: target path `" + path + "` may not exists or it's a folder");
             return;
         }
         try {
             this.writeStreamInstance = fs;
             callback.invoke(null, streamId);
         } catch(Exception err) {
-            callback.invoke("failed to create write stream at path `"+path+"` "+ err.getLocalizedMessage());
+            callback.invoke("write stream error: failed to create write stream at path `"+path+"` "+ err.getLocalizedMessage());
         }
 
     }
     static void mkdir(String path, Callback callback) {
         File dest = new File(path);
         if(dest.exists()) {
-            callback.invoke("failed to create folder at `" + path + "` folder already exists");
+            callback.invoke("mkdir error: failed to create folder at `" + path + "` folder already exists");
             return;
         }
         dest.mkdirs();
 
             String destFolder = new File(dest).getPath();
             if(!new File(path).exists()) {
-                callback.invoke("source file at path`" + path + "` not exists");
+                callback.invoke("cp error: source file at path`" + path + "` not exists");
                 return;
             }
 
     static void mv(String path, String dest, Callback callback) {
         File src = new File(path);
         if(!src.exists()) {
-            callback.invoke("source file at path `" + path + "` does not exists");
+            callback.invoke("mv error: source file at path `" + path + "` does not exists");
             return;
         }
         src.renameTo(new File(dest));
     static void ls(String path, Callback callback) {
         File src = new File(path);
         if(!src.exists() || !src.isDirectory()) {
-            callback.invoke("failed to list path `" + path + "` for it is not exist or it is not a folder");
+            callback.invoke("ls error: failed to list path `" + path + "` for it is not exist or it is not a folder");
             return;
         }
         String [] files = new File(path).list();
         callback.invoke(null, arg);
     }
 
+    static void lstat(String path, final Callback callback) {
+        File src = new File(path);
+        new AsyncTask<String, Integer, Integer>() {
+            @Override
+            protected Integer doInBackground(String ...args) {
+                WritableArray res = Arguments.createArray();
+                File src = new File(args[0]);
+                if(!src.exists()) {
+                    callback.invoke("lstat error: failed to list path `" + args[0] + "` for it is not exist or it is not a folder");
+                    return 0;
+                }
+                if(src.isDirectory()) {
+                    String [] files = src.list();
+                    for(String p : files) {
+                        res.pushMap(statFile ( src.getPath() + p));
+                    }
+                }
+                else {
+                    res.pushMap(statFile(src.getAbsolutePath()));
+                }
+                callback.invoke(null, res);
+                return 0;
+            }
+        }.execute(path);
+    }
+
+    /**
+     * show status of a file or directory
+     * @param path
+     * @param callback
+     */
+    static void stat(String path, Callback callback) {
+        File target = new File(path);
+        if(!target.exists()) {
+            callback.invoke("stat error: file "+path+" does not exists");
+            return;
+        }
+        WritableMap stat = Arguments.createMap();
+        stat.putString("filename", target.getName());
+        stat.putString("path", target.getPath());
+        stat.putString("type", target.isDirectory() ? "directory" : "file");
+        stat.putInt("size", (int)target.length());
+        stat.putInt("lastModified", (int)target.lastModified());
+        callback.invoke(null, stat);
+    }
+
+    void scanFile(String [] path, String[] mimes, final Callback callback) {
+        try {
+            MediaScannerConnection.scanFile(mCtx, path, mimes, new MediaScannerConnection.OnScanCompletedListener() {
+                @Override
+                public void onScanCompleted(String s, Uri uri) {
+                    callback.invoke(null, true);
+                }
+            });
+        } catch(Exception err) {
+            callback.invoke(err.getLocalizedMessage(), null);
+        }
+    }
+
     /**
      * Create new file at path
      * @param path
             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");
+                callback.invoke("create file error: failed to create file at path `" + path + "` for its parent path may not exists");
                 return;
             }
             OutputStream ostream = new FileOutputStream(dest);
         }
     }
 
+    /**
+     * Create file for ASCII encoding
+     * @param path  Path of new file.
+     * @param data  Content of new file
+     * @param callback  JS context callback
+     */
     static void createFileASCII(String path, ReadableArray data, 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");
+                callback.invoke("create file error: failed to create file at path `" + path + "` for its parent path may not exists");
                 return;
             }
             OutputStream ostream = new FileOutputStream(dest);
         }
     }
 
+    /**
+     * Remove files in session.
+     * @param paths An array of file paths.
+     * @param callback JS contest callback
+     */
     static void removeSession(ReadableArray paths, Callback callback) {
 
         AsyncTask<ReadableArray, Integer, Integer> task = new AsyncTask<ReadableArray, Integer, Integer>() {
         eventData.putString("detail", data);
         this.emitter.emit("RNFetchBlobStream" + taskId, eventData);
     }
+
+    static WritableMap statFile(String path) {
+        File target = new File(path);
+        if(!target.exists()) {
+            return null;
+        }
+        WritableMap stat = Arguments.createMap();
+        stat.putString("filename", target.getName());
+        stat.putString("path", target.getPath());
+        stat.putString("type", target.isDirectory() ? "directory" : "file");
+        stat.putInt("size", (int)target.length());
+        stat.putInt("lastModified", (int)target.lastModified());
+        return stat;
+    }
+
 }
 
 

src/ios/RNFetchBlob/RNFetchBlob.m

     return err == nil;
 }
 
++ (NSData *) stat:(NSString *) path error:(NSError **) error{
+    NSMutableData *stat = [[NSMutableData alloc]init];
+    NSFileManager * fm = [NSFileManager defaultManager];
+    NSData * info = [fm attributesOfItemAtPath:path error:&error];
+    [stat setValue:[info valueForKey:NSFileSystemSize] forKey:@"size"];
+    [stat setValue:path forKey:@"path"];
+    [stat setValue:[path stringByDeletingPathExtension] forKey:@"filename"];
+    NSDate * lastModified;
+    [[NSURL fileURLWithPath:path] getResourceValue:&lastModified forKey:NSURLContentModificationDateKey error:&error];
+    [stat setValue:lastModified forKey:@"lastModified"];
+    return stat;
+}
+
 + (BOOL) exists:(NSString *) path {
     return [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:NULL];
 }
     
 }
 
+RCT_EXPORT_METHOD(stat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
+    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 list path `%@` for it is not exist or it is not exist", path]]);
+        return ;
+    }
+    NSData * res = [FetchBlobFS stat:path error:&error];
+    
+    if(error == nil)
+        callback(@[[NSNull null], res]);
+    else
+        callback(@[[error localizedDescription], [NSNull null]]);
+    
+}
+
+RCT_EXPORT_METHOD(lstat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
+    NSFileManager* fm = [NSFileManager defaultManager];
+    BOOL exist = nil;
+    BOOL isDir = nil;
+    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 ;
+    }
+    NSError * error = nil;
+    NSArray * files = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:&error];
+
+    NSMutableArray * res = [NSMutableArray alloc];
+    if(isDir == YES) {
+        for(NSString * p in files) {
+            NSString * filePath = [NSString stringWithFormat:@"%@/%@", path, p];
+            [res addObject:[FetchBlobFS stat:filePath error:&error]];
+        }
+    }
+    else {
+        [res addObject:[FetchBlobFS stat:path error:&error]];
+    }
+    
+    if(error == nil)
+        callback(@[[NSNull null], res == nil ? [NSNull null] :res ]);
+    else
+        callback(@[[error localizedDescription], [NSNull null]]);
+    
+}
+
 RCT_EXPORT_METHOD(cp:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     BOOL result = [[NSFileManager defaultManager] copyItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];