wifi.findAndConnect not connecting to wifi if Mobile data is switched on OS 9

[preetlotey999]

I am trying to connect with IOT device its working in some devices but not working specifically in OS 9 and some OS 8 versions. Please assist.

Thanks

[preetlotey999]

I fixed it.

[dylan10293]

Can you tell me how you fixed it?

[PreetiT9L]

Can you tell me how you fixed it? i am facing same issue

[Pankajmalhan]

I have resolved the issue, now it is working fine for me we need to make the changes in AndroidWifiModule class. Try to replace the code with below code.

package com.devstepbcn.wifi;

import com.facebook.react.uimanager.;
import com.facebook.react.bridge.;
import com.facebook.systrace.Systrace;
import com.facebook.systrace.SystraceMessage;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.ReactRootView;
import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.facebook.react.shell.MainReactPackage;
import com.facebook.soloader.SoLoader;
import android.provider.Settings;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiConfiguration;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.NetworkCapabilities;
import android.net.Network;
import android.net.Uri;
import android.net.wifi.WifiInfo;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.BroadcastReceiver;
import android.os.Build;
import android.os.Bundle;
import android.widget.Toast;
import java.util.List;
import java.lang.Thread;
import android.net.DhcpInfo;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class AndroidWifiModule extends ReactContextBaseJavaModule {

    //WifiManager Instance
    WifiManager wifi;
    ReactApplicationContext reactContext;

    //Constructor
    public AndroidWifiModule(ReactApplicationContext reactContext) {
        super(reactContext);

        wifi = (WifiManager)reactContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
        this.reactContext = reactContext;
    }

    //Name for module register to use:
    @OverRide
    public String getName() {
        return "AndroidWifiModule";
    }

    //Method to load wifi list into string via Callback. Returns a stringified JSONArray
    @ReactMethod
    public void loadWifiList(Callback successCallback, Callback errorCallback) {
        try {
            List < ScanResult > results = wifi.getScanResults();
            JSONArray wifiArray = new JSONArray();

            for (ScanResult result: results) {
                JSONObject wifiObject = new JSONObject();
                if(!result.SSID.equals("")){
                    try {
             wifiObject.put("SSID", result.SSID);
             wifiObject.put("BSSID", result.BSSID);
             wifiObject.put("capabilities", result.capabilities);
             wifiObject.put("frequency", result.frequency);
             wifiObject.put("level", result.level);
             wifiObject.put("timestamp", result.timestamp);
             //Other fields not added
             //wifiObject.put("operatorFriendlyName", result.operatorFriendlyName);
             //wifiObject.put("venueName", result.venueName);
             //wifiObject.put("centerFreq0", result.centerFreq0);
             //wifiObject.put("centerFreq1", result.centerFreq1);
             //wifiObject.put("channelWidth", result.channelWidth);
                    } catch (JSONException e) {
              errorCallback.invoke(e.getMessage());
                    }
                    wifiArray.put(wifiObject);
                }
            }
            successCallback.invoke(wifiArray.toString());
        } catch (IllegalViewOperationException e) {
            errorCallback.invoke(e.getMessage());
        }
    }

    //Method to force wifi usage if the user needs to send requests via wifi
    //if it does not have internet connection. Useful for IoT applications, when
    //the app needs to communicate and send requests to a device that have no
    //internet connection via wifi.

    //Receives a boolean to enable forceWifiUsage if true, and disable if false.
    //Is important to enable only when communicating with the device via wifi
    //and remember to disable it when disconnecting from device.
    @ReactMethod
    public void forceWifiUsage(boolean useWifi) {
boolean canWriteFlag = false;
System.out.println("step start ");
if (useWifi) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                canWriteFlag = true;
                // Only need ACTION_MANAGE_WRITE_SETTINGS on 6.0.0, regular permissions suffice on later versions
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                canWriteFlag = Settings.System.canWrite(reactContext);

                if (!canWriteFlag) {
                    Intent intent = new Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS);
                    intent.setData(Uri.parse("package:" + reactContext.getPackageName()));
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                    reactContext.startActivity(intent);
                }
            }

            if (((Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) && canWriteFlag) || ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) && !(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M))) {
                final ConnectivityManager manager = (ConnectivityManager) reactContext
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkRequest.Builder builder;
                builder = new NetworkRequest.Builder();
                //set the transport type do WIFI
                builder.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);

                    //builder.addCapability(NetworkCapabilities.TRANSPORT_WIFI);
                    System.out.println("called in if "+ builder);
manager.requestNetwork(builder.build(), new ConnectivityManager.NetworkCallback() {
@OverRide
public void onAvailable(Network network) {
    try {
                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                                    System.out.println("onAvailable in if called "+manager);
                                    manager.bindProcessToNetwork(network);
                                } else {
                                    System.out.println("onAvailable in else called ");
                                    //This method was deprecated in API level 23
                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                        ConnectivityManager.setProcessDefaultNetwork(network);
                                    }
                                }
                                /if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                    manager.unregisterNetworkCallback(this);
                                }/
                            }catch (Exception e){
                                System.out.println("Exception called "+ e);
                            }
                        }
});
}
}
} else {
            System.out.println("useWifi false called ");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
ConnectivityManager manager = (ConnectivityManager) reactContext
.getSystemService(Context.CONNECTIVITY_SERVICE);
manager.bindProcessToNetwork(null);
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
ConnectivityManager.setProcessDefaultNetwork(null);
}
}
}

    //Use this method to make sure that your forced network already bound
    @ReactMethod
    public void connectionStatusOfBoundNetwork(Callback connectionStatusResult) {
        ConnectivityManager connManager = (ConnectivityManager) getReactApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        Network network = null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            network = connManager.getBoundNetworkForProcess();
        }
        if (network != null) {
            connectionStatusResult.invoke(true);
        } else {
            connectionStatusResult.invoke(false);
        }
    }

    //Method to check if wifi is enabled
    @ReactMethod
    public void isEnabled(Callback isEnabled) {
        isEnabled.invoke(wifi.isWifiEnabled());
    }

    //Method to connect/disconnect wifi service
    @ReactMethod
    public void setEnabled(Boolean enabled) {
        wifi.setWifiEnabled(enabled);
    }

    //Send the ssid and password of a Wifi network into this to connect to the network.
    //Example: wifi.findAndConnect(ssid, password);
    //After 10 seconds, a post telling you whether you are connected will pop up.
    //Callback returns true if ssid is in the range
    @ReactMethod
    public void findAndConnect(String ssid, String password, Callback ssidFound) {
        System.out.println("step 1 ");
        List < ScanResult > results = wifi.getScanResults();
        System.out.println("step 2 ");
        boolean connected = false;
        System.out.println("step 3 ");
        for (ScanResult result: results) {
            System.out.println("step 4 ");
            String resultString = "" + result.SSID;
            System.out.println("step 5 ");
            if (ssid.equals(resultString)) {
                System.out.println("step 6 "+resultString);
                connected = connectTo(result, password, ssid);
            }
        }
        ssidFound.invoke(connected);
    }

    //Use this method to check if the device is currently connected to Wifi.
    @ReactMethod
    public void connectionStatus(Callback connectionStatusResult) {
        ConnectivityManager connManager = (ConnectivityManager) getReactApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
        if (mWifi.isConnected()) {
            connectionStatusResult.invoke(true);
        } else {
            connectionStatusResult.invoke(false);
        }
    }

    //Method to connect to WIFI Network
    public Boolean connectTo(ScanResult result, String password, String ssid) {
        //Make new configuration
        WifiConfiguration conf = new WifiConfiguration();

    //clear alloweds

        conf.allowedAuthAlgorithms.clear();
        conf.allowedGroupCiphers.clear();
        conf.allowedKeyManagement.clear();
        conf.allowedPairwiseCiphers.clear();
        conf.allowedProtocols.clear();

    // Quote ssid and password

        conf.SSID = String.format(""%s"", ssid);
    
    WifiConfiguration tempConfig = this.IsExist(conf.SSID);
        if (tempConfig != null) {
            wifi.removeNetwork(tempConfig.networkId);
        }

        String capabilities = result.capabilities;
        
    // appropriate ciper is need to set according to security type used
        if (capabilities.contains("WPA") || capabilities.contains("WPA2") || capabilities.contains("WPA/WPA2 PSK")) {
            System.out.println("step 7 ");
            // This is needed for WPA/WPA2
            // Reference - https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/wifi/java/android/net/wifi/WifiConfiguration.java#149
            conf.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);

            conf.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            conf.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);

            conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);

            conf.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            conf.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);

            conf.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            conf.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            conf.status = WifiConfiguration.Status.ENABLED;
            conf.preSharedKey = String.format(""%s"", password);

        } else if (capabilities.contains("WEP")) {
            System.out.println("step 8 ");
            // This is needed for WEP
            // Reference - https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/wifi/java/android/net/wifi/WifiConfiguration.java#149
            conf.wepKeys[0] = """ + password + """;
            conf.wepTxKeyIndex = 0;
            conf.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            conf.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
            conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            conf.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
    } else {
            System.out.println("step 9 ");
            conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
        }

        List mWifiConfigList = wifi.getConfiguredNetworks();
        if (mWifiConfigList == null) {
         return false;
}

        int updateNetwork = -1;

        // Use the existing network config if exists
        for (WifiConfiguration wifiConfig : mWifiConfigList) {
            if (wifiConfig.SSID.equals(conf.SSID)) {
        conf=wifiConfig;
                updateNetwork=conf.networkId;
            }
        }

        // If network not already in configured networks add new network
        if ( updateNetwork == -1 ) {
     updateNetwork = wifi.addNetwork(conf);
     wifi.saveConfiguration();
        }

    // if network not added return false

        if ( updateNetwork == -1 ) {
            return false;
        }

    // disconnect current network

        boolean disconnect = wifi.disconnect();
        if ( !disconnect ) {
            return false;
        }

     // enable new network
        boolean enableNetwork = wifi.enableNetwork(updateNetwork, true);
        if ( !enableNetwork ) {
            return false;
        }

        return true;
    }
    
    //add configuration of hidden network and return it's networkId
    public int setWifiConfig(String ssid, String sharedKey) {
        WifiConfiguration conf = new WifiConfiguration();

        conf.SSID = """ + ssid + """;
        conf.preSharedKey = """ + sharedKey + """;
    
        conf.hiddenSSID = true;
        conf.status = WifiConfiguration.Status.ENABLED;
        conf.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
        conf.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
        conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
        conf.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
        conf.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
        conf.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
        conf.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
    
        return wifi.addNetwork(conf);
    }

    //Add a hidden wifi network and connect to it
    //Example: wifi.connectToHiddenNetwork(ssid, password, (networkAdded) => {});
    //Callback returns true if network added and tried to connect to it successfully
    //It may take up to 15s to connect to hidden networks
    @ReactMethod
    public void connectToHiddenNetwork(String ssid, String password, Callback networkAdded) {
        List list = wifi.getConfiguredNetworks();
        if (list == null) {
            networkAdded.invoke(false);
         return;
}

        int updateNetwork = -1;

        // check if network config exists and it's hidden
        for (WifiConfiguration wifiConfig : list) {
            if (wifiConfig.SSID.equals(""" + ssid + """) && wifiConfig.hiddenSSID) {
                updateNetwork = wifiConfig.networkId;
            }
        }

        // If network not already in configured networks add new network
        if (updateNetwork == -1) {
            updateNetwork = setWifiConfig(ssid, password);
        }

        // if network not added return false
        if (updateNetwork == -1) {
            networkAdded.invoke(false);
            return;
        }
        
        // disconnect current network
        boolean disconnect = wifi.disconnect();
        if (!disconnect) {
            networkAdded.invoke(false);
            return;
        }

        // enable new network
        boolean enableNetwork = wifi.enableNetwork(updateNetwork, true);
        if (!enableNetwork) {
            networkAdded.invoke(false);
            return;
        }
    
        // reconnect to new network
        boolean reconnect = wifi.reconnect();
        if (!reconnect) {
            networkAdded.invoke(false);
            return;
        }

        wifi.saveConfiguration();

        networkAdded.invoke(true);
    }

    //Disconnect current Wifi.
    @ReactMethod
    public void disconnect() {
        wifi.disconnect();
    }

    //This method will return current ssid
    @ReactMethod
    public void getSSID(final Callback callback) {
        WifiInfo info = wifi.getConnectionInfo();

        // This value should be wrapped in double quotes, so we need to unwrap it.
        String ssid = info.getSSID();
        if (ssid.startsWith(""") && ssid.endsWith(""")) {
            ssid = ssid.substring(1, ssid.length() - 1);
        }

        callback.invoke(ssid);
    }

    //This method will return the basic service set identifier (BSSID) of the current access point
    @ReactMethod
    public void getBSSID(final Callback callback) {
        WifiInfo info = wifi.getConnectionInfo();

        String bssid = info.getBSSID();

        callback.invoke(bssid.toUpperCase());
    }

    //This method will return current wifi signal strength
    @ReactMethod
    public void getCurrentSignalStrength(final Callback callback) {
        int linkSpeed = wifi.getConnectionInfo().getRssi();
        callback.invoke(linkSpeed);
    }

    //This method will return current wifi frequency
    @ReactMethod
    public void getFrequency(final Callback callback) {
        WifiInfo info = wifi.getConnectionInfo();
        int frequency = 0;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
            frequency = info.getFrequency();
        }
        callback.invoke(frequency);
    }

    //This method will return current IP
    @ReactMethod
    public void getIP(final Callback callback) {
        WifiInfo info = wifi.getConnectionInfo();
        String stringip = longToIP(info.getIpAddress());
        callback.invoke(stringip);
    }

    //This method will remove the wifi network as per the passed SSID from the device list
    @ReactMethod
    public void isRemoveWifiNetwork(String ssid, final Callback callback) {
     List mWifiConfigList = wifi.getConfiguredNetworks();
if (mWifiConfigList == null) {
return;
}

     for (WifiConfiguration wifiConfig : mWifiConfigList) {
            String comparableSSID = ('"' + ssid + '"'); //Add quotes because wifiConfig.SSID has them
            if(wifiConfig.SSID.equals(comparableSSID)) {
                wifi.removeNetwork(wifiConfig.networkId);
                wifi.saveConfiguration();
                callback.invoke(true);
                return;
            }
     }
        callback.invoke(false);
    }

    @ReactMethod
    public void reScanAndLoadWifiList(Callback successCallback, Callback errorCallback) {
        WifiReceiver receiverWifi = new WifiReceiver(wifi, successCallback, errorCallback);
      getCurrentActivity().registerReceiver(receiverWifi, new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));
     wifi.startScan();
    }

    @ReactMethod
    public void getDhcpServerAddress(Callback callback) {
        DhcpInfo dhcpInfo = wifi.getDhcpInfo();
        String ip = longToIP(dhcpInfo.serverAddress);
        callback.invoke(ip);
    }

    public static String longToIP(int longIp){
        StringBuffer sb = new StringBuffer("");
        String[] strip=new String[4];
        strip[3]=String.valueOf((longIp >>> 24));
        strip[2]=String.valueOf((longIp & 0x00FFFFFF) >>> 16);
        strip[1]=String.valueOf((longIp & 0x0000FFFF) >>> 8);
        strip[0]=String.valueOf((longIp & 0x000000FF));
        sb.append(strip[0]);
        sb.append(".");
        sb.append(strip[1]);
        sb.append(".");
        sb.append(strip[2]);
        sb.append(".");
        sb.append(strip[3]);
        return sb.toString();
    }

    private WifiConfiguration IsExist(String SSID) {
        List existingConfigs = wifi.getConfiguredNetworks();
        if (existingConfigs == null) {
            return null;
        }

        for (WifiConfiguration existingConfig : existingConfigs) {
            if (existingConfig.SSID.equals(""" + SSID + """)) {
                return existingConfig;
            }
        }
        return null;
    }

    class WifiReceiver extends BroadcastReceiver {

        private Callback successCallback;
        private Callback errorCallback;
        private WifiManager wifi;

        public WifiReceiver(final WifiManager wifi, Callback successCallback, Callback errorCallback) {
            super();
            this.successCallback = successCallback;
            this.errorCallback = errorCallback;
            this.wifi = wifi;
        }

        // This method call when number of wifi connections changed
  public void onReceive(Context c, Intent intent) {
            
            c.unregisterReceiver(this);

            try {
                List < ScanResult > results = this.wifi.getScanResults();
                JSONArray wifiArray = new JSONArray();

                for (ScanResult result: results) {
                    JSONObject wifiObject = new JSONObject();
                    if(!result.SSID.equals("")){
                        try {
                 wifiObject.put("SSID", result.SSID);
                 wifiObject.put("BSSID", result.BSSID);
                 wifiObject.put("capabilities", result.capabilities);
                 wifiObject.put("frequency", result.frequency);
                 wifiObject.put("level", result.level);
                 wifiObject.put("timestamp", result.timestamp);
                        } catch (JSONException e) {
                   this.errorCallback.invoke(e.getMessage());
                            return;
                        }
                        wifiArray.put(wifiObject);
                    }
                }
                this.successCallback.invoke(wifiArray.toString());
                return;
            } catch (IllegalViewOperationException e) {
                this.errorCallback.invoke(e.getMessage());
                return;
            }
        }
    }
}

[gpawlik]

@Pankajmalhan could you please explain the change that you made or paste it again within a code block? It seems like Github formatting stripped some of the code. Thanks!

[Pankajmalhan]

Hi @gpawlik following is the list of changes that I made.
Change 1: Replace Constructor code with following
`public AndroidWifiModule(ReactApplicationContext reactContext) {
super(reactContext);

	wifi = (WifiManager)reactContext.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
	this.reactContext = reactContext;
}`

Change 2: Replace Force Wifi Usage with below code
`@ReactMethod
public void forceWifiUsage(boolean useWifi) {
boolean canWriteFlag = false;

    if (useWifi) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                canWriteFlag = true;
                // Only need ACTION_MANAGE_WRITE_SETTINGS on 6.0.0, regular permissions suffice on later versions
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                canWriteFlag = Settings.System.canWrite(reactContext);

                if (!canWriteFlag) {
                    Intent intent = new Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS);
                    intent.setData(Uri.parse("package:" + reactContext.getPackageName()));
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

                    reactContext.startActivity(intent);
                }
            }

            if (((Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) && canWriteFlag) || ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) && !(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M))) {
                final ConnectivityManager manager = (ConnectivityManager) reactContext
                        .getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkRequest.Builder builder;
                builder = new NetworkRequest.Builder();
                //set the transport type do WIFI
                builder.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);


                manager.requestNetwork(builder.build(), new ConnectivityManager.NetworkCallback() {
                    @Override
                    public void onAvailable(Network network) {
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                            manager.bindProcessToNetwork(network);
                        } else {
							//This method was deprecated in API level 23
							if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP){
								ConnectivityManager.setProcessDefaultNetwork(network);
							}
                        }
                        try {
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                      //  manager.unregisterNetworkCallback(this);
                    }
                });
            }
        }
    } else {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            ConnectivityManager manager = (ConnectivityManager) reactContext
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            manager.bindProcessToNetwork(null);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            ConnectivityManager.setProcessDefaultNetwork(null);
        }
    }
}`

Change 3: Replace code of connectionStatusOfBoundNetwork method with the following code

These are the changes that you need to make and this is code how I am connecting to devices.

connectToInternet = () => { wifi.reScanAndLoadWifiList((wifiStringList) => { wifi.forceWifiUsage(true); wifi.findAndConnect(this.wifiname, API.pIDevicePassword, (found) => { if (found) { ToastAndroid.show(strings("checkInstall.wifiFind", lang), ToastAndroid.SHORT); setTimeout(() => { wifi.connectionStatusOfBoundNetwork((isBound) => { wifi.getSSID((ssid) => { if (ssid == this.wifiname) { // call your method here that you want ot run after making the connection } else { this.connectToInternet(); } }); }); }, 15000); } else { } }); }, () => { alert('can not rescan') }) }

I need to implement setTimeout here because forceWifiUsage some time to make a force connections.

[Pankajmalhan]

I don't why this code is formatting, you can download file from here AndoirdWifiModule.java

connectToInternet = () => {
    wifi.reScanAndLoadWifiList((wifiStringList) => {
        wifi.forceWifiUsage(true); wifi.findAndConnect(this.wifiname, API.pIDevicePassword, (found) => {
            if (found) {
                ToastAndroid.show(strings("checkInstall.wifiFind", lang), ToastAndroid.SHORT); setTimeout(() => {
                    wifi.connectionStatusOfBoundNetwork((isBound) => {
                        wifi.getSSID((ssid) => {
                            if (ssid == this.wifiname) { // call your method here that you want ot run after making the connection 
                            } else { this.connectToInternet(); }
                        });
                    });
                }, 15000);
            } else { }
        });
    }, () => { alert('can not rescan') })
}

[jothikannan]

@Pankajmalhan given code doesn't work for do we need to make any other changes in AndroidManifest.xml or another file?

[jothikannan]

@preetlotey999 can you please help on this? I am also having the same scenario, could you please post your fix?

[andrewhavens]

I'm also having issues with Android 9. forceWifiUsage(true) is not prompting to enable write settings.