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.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){
+                            continue;
+                        }
+
+                        // netinfo is deprecated
+                        //if (netInfo.getType() == ConnectivityManager.TYPE_WIFI && netInfo.getState() == NetworkInfo.State.CONNECTED) {
+                        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));
                 }
                 break;
             case FileStorage:
-                ResponseBody responseBody = resp.body();
-
                 try {
                     // In order to write response data to `destPath` we have to invoke this method.
                     // It uses customized response body which is able to report download progress
                     // and write response data to destination path.
-                    responseBody.bytes();
+                    resp.body().bytes();
                 } catch (Exception ignored) {
 //                    ignored.printStackTrace();
                 }
-
-                RNFetchBlobFileResp rnFetchBlobFileResp = (RNFetchBlobFileResp) responseBody;
-
-                if(rnFetchBlobFileResp != null && rnFetchBlobFileResp.isDownloadComplete() == false){
-                    callback.invoke("RNFetchBlob failed. Download interrupted.", null);
-                }
-                else {
-                    this.destPath = this.destPath.replace("?append=true", "");
-                    callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
-                }
+                this.destPath = this.destPath.replace("?append=true", "");
+                callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, this.destPath);
                 break;
             default:
                 try {

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 30000ms.
+ *         @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

         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];
     

types.js

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