Android code to connect to a WiFi network programatically.

WiFiConnector.java

package com.tonbo.streamer.network;

import android.content.Context;
import android.content.IntentFilter;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.support.annotation.CheckResult;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by rish on 4/8/17.
 */

public class WiFiConnector implements WiFiBroadcastReceiver.WiFiBroadcastListener {

    private static final String TAG = WiFiConnector.class.getSimpleName();
    public static final String NO_WIFI = quoted("<unknown ssid>");

    private Context mContext;
    private boolean mIsWifiBroadcastRegistered;
    private IntentFilter mWifiIntentFilter;
    private WifiManager mWifiManager;
    private WiFiBroadcastReceiver mWiFiBroadcastReceiver;
    private WiFiConnectorListener mWifiConnectorListener;

    public WiFiConnector(Context context, WiFiConnectorListener wifiConnectorListener) {
        mContext = context;
        mWifiIntentFilter = new IntentFilter();
        mWifiIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        mWifiIntentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
        mWifiIntentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
        mWifiIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        if (mWiFiBroadcastReceiver == null)
            this.mWiFiBroadcastReceiver = new WiFiBroadcastReceiver();
        mWiFiBroadcastReceiver.setOnWiFiBroadcastListener(this);
        mWifiConnectorListener = wifiConnectorListener;
    }

    public NetworkInfo.DetailedState connectToWiFi(int securityType, String ssid, String key) {
        Log.d(TAG, "connectToWiFi() called with: securityType = [" + securityType + "], ssid = [" + ssid + "], key = [" + key + "]");
        /* Check if already connected to that wifi */
        String currentSsid = getActiveConnection().getSSID();
        Log.d(TAG, "Current Ssid " + currentSsid);
        NetworkInfo.DetailedState currentState = WifiInfo.getDetailedStateOf(getActiveConnection().getSupplicantState()); //todo check this
        if (currentState == NetworkInfo.DetailedState.CONNECTED && currentSsid.equals(quoted(ssid))) {
            Log.d(TAG, "Already connected");
            mWifiConnectorListener.onWiFiStateUpdate(getActiveConnection(), NetworkInfo.DetailedState.CONNECTED);
            return NetworkInfo.DetailedState.CONNECTED;
        }

        int highestPriorityNumber = 0;
        WifiConfiguration selectedConfig = null;
        /* Check if not connected but has connected to that wifi in the past */
        for (WifiConfiguration config : mWifiManager.getConfiguredNetworks()) {
            if (config.priority > highestPriorityNumber) highestPriorityNumber = config.priority;
            if (config.SSID.equals(quoted(ssid)) && config.allowedKeyManagement.get(securityType)) {
                Log.d(TAG, "Saved preshared key is " + config.preSharedKey);
                if (securityType == WifiConfiguration.KeyMgmt.WPA_PSK
                        && config.preSharedKey != null && config.preSharedKey.equals(key))
                    selectedConfig = config;
                else if (securityType == WifiConfiguration.KeyMgmt.NONE)
                    selectedConfig = config;
            }
        }

        if (selectedConfig != null) {
            selectedConfig.priority = highestPriorityNumber + 1;
            mWifiManager.updateNetwork(selectedConfig);
            // mWifiManager.disconnect(); /* disconnect from whichever wifi you're connected to */
            mWifiManager.enableNetwork(selectedConfig.networkId, true);
            mWifiManager.reconnect();
            Log.d(TAG, "Connection exists in past, enabling and connecting priority = " + highestPriorityNumber);
            return NetworkInfo.DetailedState.CONNECTING;
        }

        /* Make new connection */
        WifiConfiguration config = new WifiConfiguration();
        config.SSID = quoted(ssid);
        config.priority = highestPriorityNumber + 1;
        config.status = WifiConfiguration.Status.ENABLED;
        if (securityType == WifiConfiguration.KeyMgmt.WPA_PSK) {
            config.preSharedKey = quoted(key);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
        } else {
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
        }
        Log.d(TAG, "Attempting new wifi connection, setting priority number to, connecting " + config.priority);

        int netId = mWifiManager.addNetwork(config);
        // mWifiManager.disconnect(); /* disconnect from whichever wifi you're connected to */
        mWifiManager.enableNetwork(netId, true);
        mWifiManager.reconnect(); // todo?
        return NetworkInfo.DetailedState.CONNECTING;
    }

    @CheckResult
    public boolean startScan() {
        return mWifiManager.startScan();
    }

    public WifiInfo getActiveConnection() {
        WifiInfo currentInfo = mWifiManager.getConnectionInfo();
        return currentInfo;
    }

    @Override
    public void onStateUpdate(NetworkInfo.DetailedState detailedState) {
        mWifiConnectorListener.onWiFiStateUpdate(getActiveConnection(), detailedState);
    }

    @Override
    public void onRssiChanged(int rssi) {
        mWifiConnectorListener.onWiFiRssiChanged(rssi);
    }

    @Override
    public void onScanResultsAvailable() {
        List<ScanResult> scanResults = mWifiManager.getScanResults();
        ArrayList<BriefWiFiInfo> wiFiList = new ArrayList<>();
        for (ScanResult scanResult : scanResults) {
            BriefWiFiInfo briefWiFiInfo = new BriefWiFiInfo();
            briefWiFiInfo.setSsid(scanResult.SSID);
            int rssiPercentage = WifiManager.calculateSignalLevel(scanResult.level, 100);
            briefWiFiInfo.setRssi(rssiPercentage);
            wiFiList.add(briefWiFiInfo);
        }
        mWifiConnectorListener.onWiFiScanResults(wiFiList);
    }

    public void setup() {
        registerReceiver(mContext);
    }

    public void destroy() {
        unregisterReceiver();
    }

    private void registerReceiver(Context context) {
        context.getApplicationContext().registerReceiver(mWiFiBroadcastReceiver, mWifiIntentFilter);
        mIsWifiBroadcastRegistered = true;
    }

    private void unregisterReceiver() {
        if (mContext != null && mWiFiBroadcastReceiver != null && mIsWifiBroadcastRegistered) {
            try {
                mContext
                        .getApplicationContext()
                        .unregisterReceiver(mWiFiBroadcastReceiver);
                mIsWifiBroadcastRegistered = false;
            } catch (IllegalArgumentException e) {
                Log.d(TAG, "Unable to unregister receiver");
            }
        }
    }

    public static String quoted(String s) {
        return "\"" + s + "\"";
    }

    public interface WiFiConnectorListener {
        void onWiFiStateUpdate(WifiInfo wifiInfo, NetworkInfo.DetailedState detailedState);

        void onWiFiRssiChanged(int rssi);

        /**
         * list contains SSID and RSSI only
         */
        void onWiFiScanResults(ArrayList<BriefWiFiInfo> wiFiList);
    }
}

where is the WiFiBroadcastReceiver and BriefWiFiInfo?

No WiFiBroadcastReceiver and BriefWiFiInfo classes. useless

what about the permissions? I read we need to have location permissions and GPS permissions, in order to get wifi scan results otherwise, mWifiManager.startScan() just returns false.

Alright, looking at the comments here, I should probably make a repo out of this. I'll do so some time :)

Have you created a repo yet? I think this is exactly what I am looking for :)

I haven't yet. Maybe this weekend!

Hey @crearo, Have you done with the pending implementations?

Ah no, I haven't. It's funny this is still such a big problem in Android. I'll put a link if/when I get to publishing the library.

thank you @crearo