Merge pull request #497 from cristianoccazinsp/wifiOnly

wifi only option, and missing typings.

README.md

 
 ## About
 
-This project was started in the cause of solving issue [facebook/react-native#854](https://github.com/facebook/react-native/issues/854), React Native's lacks of `Blob` implementation which results into problems when transferring binary data. 
+This project was started in the cause of solving issue [facebook/react-native#854](https://github.com/facebook/react-native/issues/854), React Native's lacks of `Blob` implementation which results into problems when transferring binary data.
 
 It is committed to making file access and transfer easier and more efficient for React Native developers. We've implemented highly customizable filesystem and network module which plays well together. For example, developers can upload and download data directly from/to storage, which is more efficient, especially for large files. The file system supports file stream, so you don't have to worry about OOM problem when accessing large files.
 
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
-+   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />                                               
-+   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />                                              
++   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
++   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 +   <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
     ...
 
     <intent-filter>
             <action android:name="android.intent.action.MAIN" />
             <category android:name="android.intent.category.LAUNCHER" />
-+           <action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>                          
++           <action android:name="android.intent.action.DOWNLOAD_COMPLETE"/>
     </intent-filter>
 ```
 
+If you are going to use the `wifiOnly` flag, you need to add this to `AndroidManifest.xml`
+
+```diff
++   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    ...
+
+```
+
 **Grant Access Permission for Android 6.0**
 
 Beginning in Android 6.0 (API level 23), users grant permissions to apps while the app is running, not when they install the app. So adding permissions in `AndroidManifest.xml` won't work for Android 6.0+ devices. To grant permissions in runtime, you might use [PermissionAndroid API](https://facebook.github.io/react-native/docs/permissionsandroid.html).
 
 - To send a form data, the `Content-Type` header does not matter. When the body is an `Array` we will set proper content type for you.
 - To send binary data, you have two choices, use BASE64 encoded string or path points to a file contains the body.
- - If the `Content-Type` containing substring`;BASE64` or `application/octet` the given body will be considered as a BASE64 encoded data which will be decoded to binary data as the request body.   
+ - If the `Content-Type` containing substring`;BASE64` or `application/octet` the given body will be considered as a BASE64 encoded data which will be decoded to binary data as the request body.
  - Otherwise, if a string starts with `RNFetchBlob-file://` (which can simply be done by `RNFetchBlob.wrap(PATH_TO_THE_FILE)`), it will try to find the data from the URI string after `RNFetchBlob-file://` and use it as the request body.
 - To send the body as-is, simply use a `Content-Type` header not containing `;BASE64` or `application/octet`.
 
   })
   .then((res) => {
     let status = res.info().status;
-    
+
     if(status == 200) {
       // the conversion is done in native code
       let base64Str = res.base64()
     'Content-Type' : 'application/octet-stream',
     // here's the body you're going to send, should be a BASE64 encoded string
     // (you can use "base64"(refer to the library 'mathiasbynens/base64') APIs to make one).
-    // The data will be converted to "byte array"(say, blob) before request sent.  
+    // The data will be converted to "byte array"(say, blob) before request sent.
   }, base64ImageString)
   .then((res) => {
     console.log(res.text())
     ifstream.onError((err) => {
       console.log('oops', err)
     })
-    ifstream.onEnd(() => {  
+    ifstream.onEnd(() => {
       <Image source={{ uri : 'data:image/png,base64' + data }}
     })
 })
 .catch(console.error)
 ```
 
-or 
+or
 
 ```js
 RNFetchBlob.fs.writeStream(
   .then((res) => {
     // set session of a response
     res.session('foo')
-  })  
+  })
 
   RNFetchblob.config({
     // you can also set session beforehand
   .fetch('GET', 'http://example.com/download/file')
   .then((res) => {
     // ...
-  })  
+  })
 
   // or put an existing file path to the session
   RNFetchBlob.session('foo').add('some-file-path')
 })
 ```
 
+### WiFi only requests
+
+If you wish to only route requests through the Wifi interface, set the below configuration.
+Note: On Android, the `ACCESS_NETWORK_STATE` permission must be set, and this flag will only work
+on API version 21 (Lollipop, Android 5.0) or above. APIs below 21 will ignore this flag.
+
+```js
+RNFetchBlob.config({
+  wifiOnly : true
+})
+.fetch('GET', 'https://mysite.com')
+.then((resp) => {
+  // ...
+})
+```
+
 ## Web API Polyfills
 
 After `0.8.0` we've made some [Web API polyfills](https://github.com/joltup/rn-fetch-blob/wiki/Web-API-Polyfills-(experimental)) that makes some browser-based library available in RN.

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

     public String appendExt;
     public ReadableMap addAndroidDownloads;
     public Boolean trusty;
+    public Boolean wifiOnly = false;
     public String key;
     public String mime;
     public Boolean auto;
         this.path = options.hasKey("path") ? options.getString("path") : null;
         this.appendExt = options.hasKey("appendExt") ? options.getString("appendExt") : "";
         this.trusty = options.hasKey("trusty") ? options.getBoolean("trusty") : false;
+        this.wifiOnly = options.hasKey("wifiOnly") ? options.getBoolean("wifiOnly") : false;
         if(options.hasKey("addAndroidDownloads")) {
             this.addAndroidDownloads = options.getMap("addAndroidDownloads");
         }

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

 import android.net.Uri;
 import android.os.Build;
 import androidx.annotation.NonNull;
+import android.net.Network;
+import android.net.NetworkInfo;
+import android.net.NetworkCapabilities;
+import android.net.ConnectivityManager;
 import android.util.Base64;
 
 import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
 import java.net.SocketException;
 import java.net.SocketTimeoutException;
 import java.net.URL;
+import java.net.Proxy;
 import java.nio.ByteBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
                 clientBuilder = client.newBuilder();
             }
 
+            // wifi only, need ACCESS_NETWORK_STATE permission
+            // and API level >= 21
+            if(this.options.wifiOnly){
+
+                boolean found = false;
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                    ConnectivityManager connectivityManager = (ConnectivityManager) RNFetchBlob.RCTContext.getSystemService(RNFetchBlob.RCTContext.CONNECTIVITY_SERVICE);
+                    Network[] networks = connectivityManager.getAllNetworks();
+
+                    for (Network network : networks) {
+
+                        NetworkInfo netInfo = connectivityManager.getNetworkInfo(network);
+                        NetworkCapabilities caps = connectivityManager.getNetworkCapabilities(network);
+
+                        if(caps == null || netInfo == null){
+                            continue;
+                        }
+
+                        if(!netInfo.isConnected()){
+                            continue;
+                        }
+
+                        if(caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)){
+                            clientBuilder.proxy(Proxy.NO_PROXY);
+                            clientBuilder.socketFactory(network.getSocketFactory());
+                            found = true;
+                            break;
+
+                        }
+                    }
+
+                    if(!found){
+                        callback.invoke("No available WiFi connections.", null, null);
+                        releaseTaskResource();
+                        return;
+                    }
+                }
+                else{
+                    RNFetchBlobUtils.emitWarningEvent("RNFetchBlob: wifiOnly was set, but SDK < 21. wifiOnly was ignored.");
+                }
+            }
+
             final Request.Builder builder = new Request.Builder();
             try {
                 builder.url(new URL(url));
                     }
                     catch (SocketTimeoutException e ){
                         timeout = true;
-                        RNFetchBlobUtils.emitWarningEvent("RNFetchBlob error when sending request : " + e.getLocalizedMessage());
+                        //RNFetchBlobUtils.emitWarningEvent("RNFetchBlob error when sending request : " + e.getLocalizedMessage());
                     } catch(Exception ex) {
 
                     }
                     // check if this error caused by socket timeout
                     if(e.getClass().equals(SocketTimeoutException.class)) {
                         respInfo.putBoolean("timeout", true);
-                        callback.invoke("request timed out.", null, null);
+                        callback.invoke("The request timed out.", null, null);
                     }
                     else
                         callback.invoke(e.getLocalizedMessage(), null, null);
 
                 RNFetchBlobFileResp rnFetchBlobFileResp = (RNFetchBlobFileResp) responseBody;
 
-                if(rnFetchBlobFileResp != null && rnFetchBlobFileResp.isDownloadComplete() == false){
-                    callback.invoke("RNFetchBlob failed. Download interrupted.", null);
+                if(rnFetchBlobFileResp != null && !rnFetchBlobFileResp.isDownloadComplete()){
+                    callback.invoke("Download interrupted.", null);
                 }
                 else {
                     this.destPath = this.destPath.replace("?append=true", "");
                     callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 }
+
                 break;
             default:
                 try {
                 }
 
                 String filePath = null;
-                try {    
+                try {
                     // the file exists in media content database
                     if (c.moveToFirst()) {
                         // #297 handle failed request

index.d.ts

      */
     trusty?: boolean;
 
+    /**
+     * Set this property to true will only do requests through the WiFi interface, and fail otherwise.
+     */
+    wifiOnly?: boolean;
+
+    /**
+     * Set this property so redirects are not automatically followed.
+     */
+    followRedirect?: boolean;
+
     /**
      * Set this property to true will makes response data of the fetch stored in a temp file, by default the temp
      * file will stored in App's own root folder with file name template RNFetchBlob_tmp${timestamp}.

index.js

  *                   If it doesn't exist, the file is downloaded as usual
  *         @property {number} timeout
  *                   Request timeout in millionseconds, by default it's 60000ms.
+ *         @property {boolean} followRedirect
+ *                   Follow redirects automatically, default true
+ *         @property {boolean} trusty
+ *                   Trust all certificates
+ *         @property {boolean} wifiOnly
+ *                   Only do requests through WiFi. Android SDK 21 or above only.
  *
  * @return {function} This method returns a `fetch` method instance.
  */

index.js.flow

   path?: string,
   session?: string,
   timeout?: number,
-  trusty?: boolean
+  trusty?: boolean,
+  wifiOnly?: boolean,
+  followRedirect?: boolean
 };
 export type RNFetchBlobResponseInfo = {
   headers: {[fieldName: string]: string},

ios/RNFetchBlobConst.h

 extern NSString *const CONFIG_FILE_PATH;
 extern NSString *const CONFIG_FILE_EXT;
 extern NSString *const CONFIG_TRUSTY;
+extern NSString *const CONFIG_WIFI_ONLY;
 extern NSString *const CONFIG_INDICATOR;
 extern NSString *const CONFIG_KEY;
 extern NSString *const CONFIG_EXTRA_BLOB_CTYPE;

ios/RNFetchBlobConst.m

 NSString *const CONFIG_FILE_PATH = @"path";
 NSString *const CONFIG_FILE_EXT = @"appendExt";
 NSString *const CONFIG_TRUSTY = @"trusty";
+NSString *const CONFIG_WIFI_ONLY = @"wifiOnly";
 NSString *const CONFIG_INDICATOR = @"indicator";
 NSString *const CONFIG_KEY = @"key";
 NSString *const CONFIG_EXTRA_BLOB_CTYPE = @"binaryContentTypes";

ios/RNFetchBlobRequest.m

     const char* str = [input UTF8String];
     unsigned char result[CC_MD5_DIGEST_LENGTH];
     CC_MD5(str, (CC_LONG)strlen(str), result);
-    
+
     NSMutableString *ret = [NSMutableString stringWithCapacity:CC_MD5_DIGEST_LENGTH*2];
     for (int i = 0; i<CC_MD5_DIGEST_LENGTH; i++) {
         [ret appendFormat:@"%02x",result[i]];
     self.expectedBytes = 0;
     self.receivedBytes = 0;
     self.options = options;
-    
+
     backgroundTask = [[options valueForKey:@"IOSBackgroundTask"] boolValue];
     // when followRedirect not set in options, defaults to TRUE
     followRedirect = [options valueForKey:@"followRedirect"] == nil ? YES : [[options valueForKey:@"followRedirect"] boolValue];
     isIncrement = [[options valueForKey:@"increment"] boolValue];
     redirects = [[NSMutableArray alloc] init];
-    
+
     if (req.URL) {
         [redirects addObject:req.URL.absoluteString];
     }
-    
+
     // set response format
     NSString * rnfbResp = [req.allHTTPHeaderFields valueForKey:@"RNFB-Response"];
-    
+
     if ([[rnfbResp lowercaseString] isEqualToString:@"base64"]) {
         responseFormat = BASE64;
     } else if ([[rnfbResp lowercaseString] isEqualToString:@"utf8"]) {
     } else {
         responseFormat = AUTO;
     }
-    
+
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
     NSString * key = [self.options valueForKey:CONFIG_KEY];
     NSURLSession * session;
-    
+
     bodyLength = contentLength;
-    
+
     // the session trust any SSL certification
     NSURLSessionConfiguration *defaultConfigObject;
-    
+
     defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
-    
+
     if (backgroundTask) {
         defaultConfigObject = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:taskId];
     }
-    
+
     // request timeout, -1 if not set in options
     float timeout = [options valueForKey:@"timeout"] == nil ? -1 : [[options valueForKey:@"timeout"] floatValue];
-    
+
     if (timeout > 0) {
         defaultConfigObject.timeoutIntervalForRequest = timeout/1000;
     }
-    
+
+    if([options valueForKey:CONFIG_WIFI_ONLY] != nil && ![options[CONFIG_WIFI_ONLY] boolValue]){
+        [defaultConfigObject setAllowsCellularAccess:NO];
+    }
+
     defaultConfigObject.HTTPMaximumConnectionsPerHost = 10;
     session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:operationQueue];
-    
+
     if (path || [self.options valueForKey:CONFIG_USE_TEMP]) {
         respFile = YES;
-        
+
         NSString* cacheKey = taskId;
         if (key) {
             cacheKey = [self md5:key];
-            
+
             if (!cacheKey) {
                 cacheKey = taskId;
             }
-            
+
             destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
-            
+
             if ([[NSFileManager defaultManager] fileExistsAtPath:destPath]) {
                 callback(@[[NSNull null], RESP_TYPE_PATH, destPath]);
-                
+
                 return;
             }
         }
-        
+
         if (path) {
             destPath = path;
         } else {
         respData = [[NSMutableData alloc] init];
         respFile = NO;
     }
-    
+
     self.task = [session dataTaskWithRequest:req];
     [self.task resume];
-    
+
     // network status indicator
     if ([[options objectForKey:CONFIG_INDICATOR] boolValue]) {
         dispatch_async(dispatch_get_main_queue(), ^{
 - (void) URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveResponse:(NSURLResponse *)response completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
 {
     expectedBytes = [response expectedContentLength];
-    
+
     NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse*)response;
     NSInteger statusCode = [(NSHTTPURLResponse *)response statusCode];
     NSString * respType = @"";
     respStatus = statusCode;
-    
+
     if ([response respondsToSelector:@selector(allHeaderFields)])
     {
         NSDictionary *headers = [httpResponse allHeaderFields];
         NSString * respCType = [[RNFetchBlobReqBuilder getHeaderIgnoreCases:@"Content-Type" fromHeaders:headers] lowercaseString];
-        
+
         if (self.isServerPush) {
             if (partBuffer) {
                 [self.bridge.eventDispatcher
                         }
                  ];
             }
-            
+
             partBuffer = [[NSMutableData alloc] init];
             completionHandler(NSURLSessionResponseAllow);
 
         } else {
             self.isServerPush = [[respCType lowercaseString] RNFBContainsString:@"multipart/x-mixed-replace;"];
         }
-        
+
         if(respCType)
         {
             NSArray * extraBlobCTypes = [options objectForKey:CONFIG_EXTRA_BLOB_CTYPE];
-            
+
             if ([respCType RNFBContainsString:@"text/"]) {
                 respType = @"text";
             } else if ([respCType RNFBContainsString:@"application/json"]) {
                 }
             } else {
                 respType = @"blob";
-                
+
                 // for XMLHttpRequest, switch response data handling strategy automatically
                 if ([options valueForKey:@"auto"]) {
                     respFile = YES;
         } else {
             respType = @"text";
         }
-        
+
 #pragma mark - handling cookies
         // # 153 get cookies
         if (response.URL) {
                 [cookieStore setCookies:cookies forURL:response.URL mainDocumentURL:nil];
             }
         }
-        
+
         [self.bridge.eventDispatcher
          sendDeviceEventWithName: EVENT_STATE_CHANGE
          body:@{
     } else {
         NSLog(@"oops");
     }
-    
+
     if (respFile)
     {
         @try{
             NSFileManager * fm = [NSFileManager defaultManager];
             NSString * folder = [destPath stringByDeletingLastPathComponent];
-            
+
             if (![fm fileExistsAtPath:folder]) {
                 [fm createDirectoryAtPath:folder withIntermediateDirectories:YES attributes:NULL error:nil];
             }
-            
+
             // if not set overwrite in options, defaults to TRUE
             BOOL overwrite = [options valueForKey:@"overwrite"] == nil ? YES : [[options valueForKey:@"overwrite"] boolValue];
             BOOL appendToExistingFile = [destPath RNFBContainsString:@"?append=true"];
-            
+
             appendToExistingFile = !overwrite;
-            
+
             // For solving #141 append response data if the file already exists
             // base on PR#139 @kejinliang
             if (appendToExistingFile) {
                 destPath = [destPath stringByReplacingOccurrencesOfString:@"?append=true" withString:@""];
             }
-            
+
             if (![fm fileExistsAtPath:destPath]) {
                 [fm createFileAtPath:destPath contents:[[NSData alloc] init] attributes:nil];
             }
-            
+
             writeStream = [[NSOutputStream alloc] initToFileAtPath:destPath append:appendToExistingFile];
             [writeStream scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
             [writeStream open];
             NSLog(@"write file error");
         }
     }
-    
+
     completionHandler(NSURLSessionResponseAllow);
 }
 
     if (self.isServerPush)
     {
         [partBuffer appendData:data];
-        
+
         return ;
     }
-    
+
     NSNumber * received = [NSNumber numberWithLong:[data length]];
     receivedBytes += [received longValue];
     NSString * chunkString = @"";
-    
+
     if (isIncrement) {
         chunkString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
     }
-    
+
     if (respFile) {
         [writeStream write:[data bytes] maxLength:[data length]];
     } else {
         [respData appendData:data];
     }
-    
+
     if (expectedBytes == 0) {
         return;
     }
-    
+
     NSNumber * now =[NSNumber numberWithFloat:((float)receivedBytes/(float)expectedBytes)];
-    
+
     if ([self.progressConfig shouldReport:now]) {
         [self.bridge.eventDispatcher
          sendDeviceEventWithName:EVENT_PROGRESS
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
 {
-    
+
     self.error = error;
     NSString * errMsg;
     NSString * respStr;
     NSString * rnfbRespType;
-    
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
-    });
-    
+
+    // only run this if we were requested to change it
+    if ([[options objectForKey:CONFIG_INDICATOR] boolValue]) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
+        });
+    }
+
     if (error) {
         if (error.domain == NSURLErrorDomain && error.code == NSURLErrorCancelled) {
             errMsg = @"task cancelled";
             errMsg = [error localizedDescription];
         }
     }
-    
+
     if (respFile) {
         [writeStream close];
         rnfbRespType = RESP_TYPE_PATH;
         // if it turns out not to be `nil` that means the response data contains valid UTF8 string,
         // in order to properly encode the UTF8 string, use URL encoding before BASE64 encoding.
         NSString * utf8 = [[NSString alloc] initWithData:respData encoding:NSUTF8StringEncoding];
-        
+
         if (responseFormat == BASE64) {
             rnfbRespType = RESP_TYPE_BASE64;
             respStr = [respData base64EncodedStringWithOptions:0];
             }
         }
     }
-    
-    
+
+
     callback(@[
                errMsg ?: [NSNull null],
                rnfbRespType ?: @"",
                respStr ?: [NSNull null]
                ]);
-    
+
     respData = nil;
     receivedBytes = 0;
     [session finishTasksAndInvalidate];
-    
+
 }
 
 // upload progress handler
     if (totalBytesExpectedToWrite == 0) {
         return;
     }
-    
+
     NSNumber * now = [NSNumber numberWithFloat:((float)totalBytesWritten/(float)totalBytesExpectedToWrite)];
 
     if ([self.uploadProgressConfig shouldReport:now]) {
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
 {
-    
+
     if (followRedirect) {
         if (request.URL) {
             [redirects addObject:[request.URL absoluteString]];
         }
-        
+
         completionHandler(request);
     } else {
         completionHandler(nil);

types.js

   appendExt : string,
   session : string,
   addAndroidDownloads : any,
-  indicator : bool
+  indicator : bool,
+  followRedirect : bool,
+  trusty : bool,
+  wifiOnly : bool
 };
 
 type RNFetchBlobNative = {