#29 add IOS implementation for self-signed server

src/ios/RNFetchBlobConst.h

 extern NSString *const CONFIG_USE_TEMP;
 extern NSString *const CONFIG_FILE_PATH;
 extern NSString *const CONFIG_FILE_EXT;
+extern NSString *const CONFIG_TRUSTY;
 
 // fs events
 extern NSString *const FS_EVENT_DATA;

src/ios/RNFetchBlobConst.m

 extern NSString *const CONFIG_USE_TEMP = @"fileCache";
 extern NSString *const CONFIG_FILE_PATH = @"path";
 extern NSString *const CONFIG_FILE_EXT = @"appendExt";
+extern NSString *const CONFIG_TRUSTY = @"trusty";
+
 
 extern NSString *const MSG_EVENT = @"RNFetchBlobMessage";
 extern NSString *const MSG_EVENT_LOG = @"log";

src/ios/RNFetchBlobNetwork.h

 #import <Foundation/Foundation.h>
 #import "RCTBridgeModule.h"
 
-@interface RNFetchBlobNetwork : NSObject  <NSURLSessionDelegate, NSURLSessionTaskDelegate, NSURLSessionDataDelegate> {
-    
-    NSString * taskId;
-    int expectedBytes;
-    int receivedBytes;
-    NSMutableData * respData;
-    RCTResponseSenderBlock callback;
-    RCTBridge * bridge;
-    NSDictionary * options;
-    RNFetchBlobFS * fileStream;
-}
-@property (nonatomic) NSString * taskId;
+typedef void(^CompletionHander)(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error);
+typedef void(^DataTaskCompletionHander) (NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error);
+
+@interface RNFetchBlobNetwork : NSObject  <NSURLSessionDelegate, NSURLSessionTaskDelegate, NSURLSessionDataDelegate, UIApplicationDelegate>
+
+@property (nullable, nonatomic) NSString * taskId;
 @property (nonatomic) int expectedBytes;
 @property (nonatomic) int receivedBytes;
-@property (nonatomic) NSMutableData * respData;
-@property (nonatomic) RCTResponseSenderBlock callback;
-@property (nonatomic) RCTBridge * bridge;
-@property (nonatomic) NSDictionary * options;
-@property (nonatomic) RNFetchBlobFS * fileStream;
+@property (nullable, nonatomic) NSMutableData * respData;
+@property (nullable, nonatomic) RCTResponseSenderBlock callback;
+@property (nullable, nonatomic) RCTBridge * bridge;
+@property (nullable, nonatomic) NSDictionary * options;
+@property (nullable, nonatomic) RNFetchBlobFS * fileStream;
+@property (nullable, nonatomic) CompletionHander fileTaskCompletionHandler;
+@property (nullable, nonatomic) DataTaskCompletionHander dataTaskCompletionHandler;
+@property (nullable, nonatomic) NSError * error;
 
 
-- (id) init;
+- (nullable id) init;
 - (void) sendRequest;
 
-+ (NSMutableDictionary *) normalizeHeaders:(NSDictionary *)headers;
-- (void) sendRequest:(NSDictionary *)options bridge:(RCTBridge *)bridgeRef taskId:(NSString *)taskId withRequest:(NSURLRequest *)req callback:(RCTResponseSenderBlock) callback;
++ (NSMutableDictionary  * _Nullable ) normalizeHeaders:(NSDictionary * _Nullable)headers;
+- (void) sendRequest:(NSDictionary  * _Nullable )options bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
 
 
 @end

src/ios/RNFetchBlobNetwork.m

 
 @implementation RNFetchBlobNetwork
 
+NSOperationQueue *taskQueue;
 
 @synthesize taskId;
 @synthesize expectedBytes;
 @synthesize callback;
 @synthesize bridge;
 @synthesize options;
+@synthesize fileTaskCompletionHandler;
+@synthesize dataTaskCompletionHandler;
+@synthesize error;
+
 
 // constructor
 - (id)init {
     self = [super init];
+    if(taskQueue == nil) {
+        taskQueue = [[NSOperationQueue alloc] init];
+    }
     return self;
 }
 
 }
 
 // send HTTP request
-- (void) sendRequest:(NSDictionary *)options bridge:(RCTBridge *)bridgeRef taskId:(NSString *)taskId withRequest:(NSURLRequest *)req callback:(RCTResponseSenderBlock) callback {
+- (void) sendRequest:(NSDictionary  * _Nullable )options bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback
+{
     self.taskId = taskId;
     self.respData = [[NSMutableData alloc] initWithLength:0];
     self.callback = callback;
     
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
     NSString * ext = [self.options valueForKey:CONFIG_FILE_EXT];
-
-    NSURLSession * session = [NSURLSession sharedSession];
+    NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
+    NSURLSession * session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:taskQueue];
+    
+//    NSURLSession * session = [NSURLSession sharedSession];
     
     // file will be stored at a specific path
     if( path != nil) {
-        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+        
+        self.fileTaskCompletionHandler = ^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
             if(error != nil) {
                 callback(@[[error localizedDescription]]);
                 return;
                 return;
             }
             callback(@[[NSNull null], path]);
-        }];
+        };
+        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:fileTaskCompletionHandler];
         [task resume];
     }
     // file will be stored at tmp path
     else if ( [self.options valueForKey:CONFIG_USE_TEMP]!= nil ) {
-        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+        
+        self.fileTaskCompletionHandler = ^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
             if(error != nil) {
                 callback(@[[error localizedDescription]]);
                 return;
                 return;
             }
             callback(@[[NSNull null], tmpPath]);
-        }];
+        };
+        NSURLSessionDownloadTask * task = [session downloadTaskWithRequest:req completionHandler:fileTaskCompletionHandler];
         [task resume];
     }
     // base64 response
     else {
-        NSURLSessionUploadTask * task =
-        
-        [session dataTaskWithRequest:req completionHandler:^(NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+        self.dataTaskCompletionHandler = ^(NSData * _Nullable resp, NSURLResponse * _Nullable response, NSError * _Nullable error) {
             if(error != nil) {
                 callback(@[[error localizedDescription]]);
                 return;
             else {
                 callback(@[[NSNull null], [resp base64EncodedStringWithOptions:0]]);
             }
-        }];
+        };
+        NSURLSessionDataTask * task = [session dataTaskWithRequest:req completionHandler:dataTaskCompletionHandler];
         [task resume];
     }
 }
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
     NSLog([error localizedDescription]);
+    self.error = error;
 }
 
 // upload progress handler
      ];
 }
 
+- (void) application:(UIApplication *)application handleEventsForBackgroundURLSession:(NSString *)identifier completionHandler:(void (^)())completionHandler {
+    
+}
+
+- (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
+{
+    if(self.dataTaskCompletionHandler != nil)
+    {
+        dataTaskCompletionHandler(self.respData, nil, error);
+    }
+    else if(self.fileTaskCompletionHandler != nil)
+    {
+        fileTaskCompletionHandler(nil, nil, self.error);
+    }
+}
+
+- (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition, NSURLCredential * _Nullable))completionHandler
+{
+    if([options valueForKey:CONFIG_TRUSTY] == YES)
+        completionHandler(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
+    else
+        RCTLogError(@"counld not create connection with an unstrusted SSL certification, if you're going to create connection anyway, add `trusty:true` to RNFetchBlob.config");
+}
+
 @end