Add slice implementation #44

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

         }
     }
 
+    @ReactMethod
+    public void slice(String src, String dest, int start, int end, String encode, Callback callback) {
+
+    }
+
     @ReactMethod
     public void fetchBlob(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
         new RNFetchBlobReq(options, taskId, method, url, headers, body, null, callback).run();

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

 
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
         callback.invoke(null, arg);
     }
 
+    /**
+     * Create a file by slicing given file path
+     * @param src   Source file path
+     * @param dest  Destination of created file
+     * @param start Start byte offset in source file
+     * @param end   End byte offset
+     * @param encode
+     * @param callback
+     */
+    public static void slice(String src, String dest, int start, int end, String encode, Callback callback) {
+        try {
+            long expected = end - start;
+            long now = 0;
+            FileInputStream in = new FileInputStream(new File(src));
+            FileOutputStream out = new FileOutputStream(new File(dest));
+            in.skip(start);
+            byte [] buffer = new byte[10240];
+            while(now < expected) {
+                long read = in.read(buffer, 0, 10240);
+                if(read <= 0) {
+                    break;
+                }
+                now += read;
+                out.write(buffer, 0, (int) read);
+            }
+            in.close();
+            out.close();
+            callback.invoke(null, dest);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     static void lstat(String path, final Callback callback) {
         path = normalizePath(path);
 

src/ios/RNFetchBlob/RNFetchBlob.m

 
 }
 
+RCT_EXPORT_METHOD(slice:(NSString *)src dest:(NSString *)dest start:(NSNumber *)start end:(NSNumber *)end resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+{
+    [RNFetchBlobFS slice:src dest:dest start:start end:end encode:@"" resolver:resolve rejecter:reject];
+})
+
 #pragma mark RNFetchBlob private methods
 
 

src/ios/RNFetchBlobFS.h

 + (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;
 + (void) readAssetFile:(NSData *)assetUrl completionBlock:(void(^)(NSData * content))completionBlock failBlock:(void(^)(NSError * err))failBlock;
++ (void) slice:(NSString *)path dest:(NSString *)dest start:(NSNumber *)start end:(NSNumber *)end encode:(NSString *)encode resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 //+ (void) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append;
 
 // constructor

src/ios/RNFetchBlobFS.m

     });
 }
 
+// Slice a file into another file, generally for support Blob implementation.
+- (void)slice:(NSString *)path
+         dest:(NSString *)dest
+        start:(NSNumber *)start
+          end:(NSNumber *)end
+        encod:(NSString *)encode
+     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)
+    {
+        reject(@"RNFetchBlob slice failed", @"the file does not exists", path);
+        return;
+    }
+    long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
+    // abort for the file size is less than start
+    if(size < start)
+    {
+        reject(@"RNFetchBlob slice failed", @"start is greater than file size", @"");
+        return;
+    }
+    if(![fm fileExistsAtPath:dest]) {
+        [fm createFileAtPath:dest contents:@"" attributes:nil];
+    }
+    [handle seekToFileOffset:start];
+    while(read < expected)
+    {
+        NSData * chunk = [handle readDataOfLength:10240];
+        read += [chunk length];
+        [os write:[chunk bytes] maxLength:10240];
+    }
+    [handle closeFile];
+    [os close];
+    resolve(dest);
+    
+}
+
 // close file read stream
-- (void)closeInStream {
+- (void)closeInStream
+{
     if(self.inStream != nil) {
         [self.inStream close];
         [self.inStream removeFromRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];