Hey there! Let's walk through how to implement a hardcoded WiFi connection that forces your Android device to only connect to a specified network. I'll break this down into actionable steps with code examples tailored for open-source projects.

1. Add Required Permissions #

First, declare the necessary permissions in your AndroidManifest.xml. Note that permissions vary slightly across Android versions:

<!-- Basic WiFi control permissions -->
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />

<!-- For Android 6.0+ (API 23+) to scan networks -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<!-- For Android 12+ (API 31+) - no location required variant -->
<uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES"
    android:usesPermissionFlags="neverForLocation" />

<!-- To monitor network connection state -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

2. Create Hardcoded WiFi Configuration #

Build a WifiConfiguration object with your target network's details. Make sure to match the correct encryption type (WPA2/WPA3 is the most common standard today):

import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.content.Context;

public class WifiConnector {
    // Replace with your network's details
    private static final String TARGET_SSID = "\"Your_WiFi_SSID\""; // Wrap SSID in double quotes
    private static final String TARGET_PASSWORD = "Your_WiFi_Password";
    private static final String SECURITY_TYPE = "WPA2_PSK"; // Options: WPA2_PSK, WEP, OPEN

    public static WifiConfiguration createTargetWifiConfig() {
        WifiConfiguration config = new WifiConfiguration();
        config.SSID = TARGET_SSID;

        switch (SECURITY_TYPE) {
            case "WPA2_PSK":
                config.preSharedKey = "\"" + TARGET_PASSWORD + "\"";
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
                config.allowedProtocols.set(WifiConfiguration.Protocol.WPA2);
                break;
            case "WEP":
                config.wepKeys[0] = "\"" + TARGET_PASSWORD + "\"";
                config.wepTxKeyIndex = 0;
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
                break;
            case "OPEN":
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                break;
        }

        return config;
    }
}

3. Implement Connection Logic #

Use WifiManager to add the configuration and initiate the connection. We'll also check if the network is already configured to avoid duplicates:

public static boolean connectToTargetWifi(Context context) {
    WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    if (!wifiManager.isWifiEnabled()) {
        wifiManager.setWifiEnabled(true); // Enable WiFi if it's turned off
    }

    WifiConfiguration targetConfig = createTargetWifiConfig();
    int networkId = -1;

    // Check if the network is already saved on the device
    for (WifiConfiguration existingConfig : wifiManager.getConfiguredNetworks()) {
        if (existingConfig.SSID.equals(targetConfig.SSID)) {
            networkId = existingConfig.networkId;
            break;
        }
    }

    if (networkId == -1) {
        // Add the new network configuration
        networkId = wifiManager.addNetwork(targetConfig);
        if (networkId == -1) {
            return false; // Failed to add the network
        }
        wifiManager.saveConfiguration();
    }

    // Disconnect from current network and switch to target
    wifiManager.disconnect();
    boolean connectionInitiated = wifiManager.enableNetwork(networkId, true);
    wifiManager.reconnect();

    return connectionInitiated;
}

4. Force Connection to Only Target Network #

To prevent the device from switching to other networks, add a broadcast receiver to monitor network changes and revert to your target network if needed:

Step 4.1 Register the Receiver in Manifest #

<receiver android:name=".WifiNetworkMonitor">
    <intent-filter>
        <action android:name="android.net.wifi.STATE_CHANGE" />
        <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
    </intent-filter>
</receiver>

Step 4.2 Implement the Broadcast Receiver #

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;

public class WifiNetworkMonitor extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (action == null) return;

        if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
            NetworkInfo networkInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
            if (networkInfo != null && networkInfo.isConnected()) {
                WifiInfo wifiInfo = intent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO);
                if (wifiInfo != null && !wifiInfo.getSSID().equals(WifiConnector.TARGET_SSID)) {
                    // Connected to a non-target network, switch back immediately
                    WifiConnector.connectToTargetWifi(context);
                }
            }
        } else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
            // Fallback check for general connectivity changes
            ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
            if (activeNetwork != null && activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
                WifiInfo wifiInfo = wifiManager.getConnectionInfo();
                if (!wifiInfo.getSSID().equals(WifiConnector.TARGET_SSID)) {
                    WifiConnector.connectToTargetWifi(context);
                }
            }
        }
    }
}

5. Critical Notes #

• Security Warning: Hardcoding WiFi credentials directly in plain text is a security risk. For open-source projects, consider encrypting credentials or using build-time variables (like Gradle properties) to inject them securely instead of hardcoding.
• Android Version Compatibility: Some older methods (like saveConfiguration()) are deprecated in Android 10+. For newer SDKs, you can explore WifiNetworkSpecifier and ConnectivityManager APIs, but the above approach still works for most open-source projects targeting broader Android versions.
• Runtime Permissions: On Android 6.0+, you need to request runtime location permission to scan and connect to WiFi networks.

内容的提问来源于stack exchange，提问作者HyperionX