Add test case and exception handling for #247

fastfix

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

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
             boolean error = false;
 
             if (encoding.equalsIgnoreCase("utf8")) {
+                CharsetEncoder encoder = Charset.forName("UTF-8").newEncoder();
                 while ((cursor = fs.read(buffer)) != -1) {
-                    String chunk = new String(buffer, 0, cursor, "UTF-8");
+                    encoder.encode(ByteBuffer.wrap(buffer).asCharBuffer());
+                    // if the data contains invalid characters the following lines will be
+                    // skipped.
+                    String chunk = new String(buffer);
                     emitStreamEvent(streamId, "data", chunk);
                     if(tick > 0)
                         SystemClock.sleep(tick);
             buffer = null;
 
         } catch (Exception err) {
-            emitStreamEvent(streamId, "error", err.getLocalizedMessage());
+            emitStreamEvent(streamId, "error", "Failed to convert data to "+encoding+" encoded string, this might due to the source data is not able to convert using this encoding.");
         }
     }
 

src/ios/RNFetchBlob/RNFetchBlob.m

         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.writeFile
-RCT_EXPORT_METHOD(writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)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:[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 {
+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) {
+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];
     BOOL isDir = nil;
 }
 
 #pragma mark - fs.writeArrayChunk
-RCT_EXPORT_METHOD(writeArrayChunk:(NSString *)streamId withArray:(NSArray *)dataArray callback:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(writeArrayChunk:(NSString *)streamId withArray:(NSArray *)dataArray callback:(RCTResponseSenderBlock) callback)
+{
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     char * bytes = (char *) malloc([dataArray count]);
     for(int i = 0; i < dataArray.count; i++) {
 }
 
 #pragma mark - fs.writeChunk
-RCT_EXPORT_METHOD(writeChunk:(NSString *)streamId withData:(NSString *)data callback:(RCTResponseSenderBlock) callback) {
+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) {
+RCT_EXPORT_METHOD(closeStream:(NSString *)streamId callback:(RCTResponseSenderBlock) callback)
+{
     RNFetchBlobFS *fs = [[RNFetchBlobFS getFileStreams] valueForKey:streamId];
     [fs closeOutStream];
     callback(@[[NSNull null], @YES]);
 }
 
 #pragma mark - unlink
-RCT_EXPORT_METHOD(unlink:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(unlink:(NSString *)path callback:(RCTResponseSenderBlock) callback)
+{
     NSError * error = nil;
     NSString * tmpPath = nil;
     [[NSFileManager defaultManager] removeItemAtPath:path error:&error];
 }
 
 #pragma mark - fs.removeSession
-RCT_EXPORT_METHOD(removeSession:(NSArray *)paths callback:(RCTResponseSenderBlock) callback) {
+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) {
+RCT_EXPORT_METHOD(ls:(NSString *)path callback:(RCTResponseSenderBlock) callback)
+{
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
     BOOL isDir = nil;
 }
 
 #pragma mark - fs.stat
-RCT_EXPORT_METHOD(stat:(NSString *)target callback:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(stat:(NSString *)target callback:(RCTResponseSenderBlock) callback)
+{
     
     [RNFetchBlobFS getPathFromUri:target completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
         __block NSMutableArray * result;
 }
 
 #pragma mark - fs.lstat
-RCT_EXPORT_METHOD(lstat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(lstat:(NSString *)path callback:(RCTResponseSenderBlock) callback)
+{
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
     BOOL isDir = nil;
 }
 
 #pragma mark - fs.cp
-RCT_EXPORT_METHOD(cp:(NSString*)src toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(cp:(NSString*)src toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback)
+{
     
 //    path = [RNFetchBlobFS getPathOfAsset:path];
     [RNFetchBlobFS getPathFromUri:src completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
 
 
 #pragma mark - fs.mv
-RCT_EXPORT_METHOD(mv:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
+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) {
+RCT_EXPORT_METHOD(mkdir:(NSString *)path callback:(RCTResponseSenderBlock) callback)
+{
     if([[NSFileManager defaultManager] fileExistsAtPath:path]) {
         callback(@[@"mkdir failed, folder already exists"]);
         return;
 }
 
 #pragma mark - fs.readFile
-RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+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 tick:(int)tick streamId:(NSString *)streamId
+RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize tick:(int)tick streamId:(NSString *)streamId)
 {
     if(bufferSize == nil) {
         if([[encoding lowercaseString] isEqualToString:@"base64"])
     dispatch_async(fsQueue, ^{
         [RNFetchBlobFS readStream:path encoding:encoding bufferSize:bufferSize tick:tick streamId:streamId bridgeRef:_bridge];
     });
-})
+}
 
 #pragma mark - fs.getEnvionmentDirs
-RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
+RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback)
+{
 
     callback(@[
                [RNFetchBlobFS getDocumentDir],
 }
 
 #pragma mark - net.enableProgressReport
-RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count  {
+RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count)
+{
     
     RNFetchBlobProgress * cfg = [[RNFetchBlobProgress alloc] initWithType:Download interval:interval count:count];
     [RNFetchBlobNetwork enableProgressReport:taskId config:cfg];
-})
+}
 
 #pragma mark - net.enableUploadProgressReport
-RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count{
+RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count)
+{
     RNFetchBlobProgress * cfg = [[RNFetchBlobProgress alloc] initWithType:Upload interval:interval count:count];
     [RNFetchBlobNetwork enableUploadProgress:taskId config:cfg];
-})
+}
 
 #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
+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];
-})
+}
 
-RCT_EXPORT_METHOD(previewDocument:(NSString*)uri scheme:(NSString *)scheme resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(previewDocument:(NSString*)uri scheme:(NSString *)scheme resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     NSString * utf8uri = [uri stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
     NSURL * url = [[NSURL alloc] initWithString:utf8uri];
     } else {
         reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
     }
-})
+}
 
 # pragma mark - open file with UIDocumentInteractionController and delegate
 
-RCT_EXPORT_METHOD(openDocument:(NSString*)uri scheme:(NSString *)scheme resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(openDocument:(NSString*)uri scheme:(NSString *)scheme resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     NSString * utf8uri = [uri stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
     NSURL * url = [[NSURL alloc] initWithString:utf8uri];
     } else {
         reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
     }
-})
+}
 
 # pragma mark - exclude from backup key
 
-RCT_EXPORT_METHOD(excludeFromBackupKey:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(excludeFromBackupKey:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     NSError *error = nil;
     [ [NSURL URLWithString:url] setResourceValue:[NSNumber numberWithBool:YES] forKey:NSURLIsExcludedFromBackupKey error:&error];
         reject(@"RNFetchBlob could not open document", [error description], nil);
     }
     
-})
+}
 
 
-RCT_EXPORT_METHOD(df:(RCTResponseSenderBlock)callback
+RCT_EXPORT_METHOD(df:(RCTResponseSenderBlock)callback)
 {
     [RNFetchBlobFS df:callback];
-})
+}
 
-- (UIViewController *) documentInteractionControllerViewControllerForPreview: (UIDocumentInteractionController *) controller {
+- (UIViewController *) documentInteractionControllerViewControllerForPreview: (UIDocumentInteractionController *) controller
+{
     UIWindow *window = [UIApplication sharedApplication].keyWindow;
     return window.rootViewController;
 }
 
 # pragma mark - getCookies
-RCT_EXPORT_METHOD(getCookies:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
+RCT_EXPORT_METHOD(getCookies:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     resolve([RNFetchBlobNetwork getCookies:url]);
-})
+}
 
 # pragma mark - check expired network events
 
-RCT_EXPORT_METHOD(emitExpiredEvent:(RCTResponseSenderBlock)callback
+RCT_EXPORT_METHOD(emitExpiredEvent:(RCTResponseSenderBlock)callback)
 {
     [RNFetchBlobNetwork emitExpiredTasks];
-})
+}
 
 
 @end

src/ios/RNFetchBlobFS.m

 // send read stream chunks via native event emitter
 + (void) emitDataChunks:(NSData *)data encoding:(NSString *) encoding streamId:(NSString *)streamId event:(RCTEventDispatcher *)event
 {
-    NSString * encodedChunk = @"";
-    if([[encoding lowercaseString] isEqualToString:@"utf8"])
-    {
-        NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] };
-        [event sendDeviceEventWithName:streamId body:payload];
-    }
-    else if ([[encoding lowercaseString] isEqualToString:@"base64"])
-    {
-        NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : [data base64EncodedStringWithOptions:0] };
-        [event sendDeviceEventWithName:streamId body:payload];
-    }
-    else if([[encoding lowercaseString] isEqualToString:@"ascii"])
+    @try
     {
-        // RCTBridge only emits string data, so we have to create JSON byte array string
-        NSMutableArray * asciiArray = [NSMutableArray array];
-        unsigned char *bytePtr;
-        if (data.length > 0)
+        NSString * encodedChunk = @"";
+        if([[encoding lowercaseString] isEqualToString:@"utf8"])
         {
-            bytePtr = (unsigned char *)[data bytes];
-            NSInteger byteLen = data.length/sizeof(uint8_t);
-            for (int i = 0; i < byteLen; i++)
+            NSDictionary * payload = @{
+                                       @"event": FS_EVENT_DATA,
+                                       @"detail" : [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]
+                                       };
+            [event sendDeviceEventWithName:streamId body:payload];
+        }
+        else if ([[encoding lowercaseString] isEqualToString:@"base64"])
+        {
+            NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : [data base64EncodedStringWithOptions:0] };
+            [event sendDeviceEventWithName:streamId body:payload];
+        }
+        else if([[encoding lowercaseString] isEqualToString:@"ascii"])
+        {
+            // RCTBridge only emits string data, so we have to create JSON byte array string
+            NSMutableArray * asciiArray = [NSMutableArray array];
+            unsigned char *bytePtr;
+            if (data.length > 0)
             {
-                [asciiArray addObject:[NSNumber numberWithChar:bytePtr[i]]];
+                bytePtr = (unsigned char *)[data bytes];
+                NSInteger byteLen = data.length/sizeof(uint8_t);
+                for (int i = 0; i < byteLen; i++)
+                {
+                    [asciiArray addObject:[NSNumber numberWithChar:bytePtr[i]]];
+                }
             }
+            
+            NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : asciiArray };
+            [event sendDeviceEventWithName:streamId body:payload];
         }
-
-        NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : asciiArray };
-        [event sendDeviceEventWithName:streamId body:payload];
+        
+    }
+    @catch (NSException * ex)
+    {
+        NSString * message = [NSString stringWithFormat:@"Failed to convert data to '%@' encoded string, this might due to the source data is not able to convert using this encoding. source = %@", encoding, [ex description]];
+        [event
+         sendDeviceEventWithName:streamId
+         body:@{
+                @"event" : MSG_EVENT_ERROR,
+                @"detail" : message
+                }];
+        [event
+         sendDeviceEventWithName:MSG_EVENT
+         body:@{
+                @"event" : MSG_EVENT_WARN,
+                @"detail" : message
+                }];
     }
-
-
 }
 
 # pragma write file from file

test/test-0.10.2.js

 
 })
 
-describe('#240 openDocument does not support file URI', (report, done) => {
-  RNFetchBlob
-  .config({ fileCache : true })
-  .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
-  .then((res) => {
-    RNFetchBlob.ios.openDocument(res.path())
-    .then(() => {
-      done();
-    })
-  })
-
-})
+// describe('#240 openDocument does not support file URI', (report, done) => {
+//   RNFetchBlob
+//   .config({ path : dirs.DocumentDir + '/app copy.png' })
+//   .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
+//   .then((res) => {
+//     RNFetchBlob.ios.openDocument(res.path())
+//     .then(() => {
+//       done();
+//     })
+//     .catch((err) => {
+//       console.log(err)
+//     })
+//   })
+//
+// })
 
 describe('#241 null header silent failed issue', (report, done) => {
 
     foo : null
   })
   .then(() => {
+    report(<Assert key="null header should not crash the app"
+      expect={true}
+      actual={true}/>)
     done()
   })
 })
+
+describe('#247 binary data UTF8 encoding causes app crash', (report, done) => {
+
+  RNFetchBlob
+  .config({fileCache : true})
+  .fetch('GET', `${TEST_SERVER_URL}/public/github.png`)
+  .then((res) => fs.readStream(res.path(), 'utf8'))
+  .then((stream) => {
+    stream.open()
+    stream.onError((err) => {
+      report(<Assert
+        key="read binary data to UTF8 should cause error but not crash the app"
+        expect={true}
+        actual={true}/>)
+      done()
+    })
+  })
+
+})