Disabling Samsung "Auto Network Switch" for WiFi Connection

Question

In our app, we handle initiating a WiFi connection to a device that broadcasts its own wireless access point (with no internet connection) for direct communication.

It works very well on all of our test devices; however, we're receiving reports from users that on certain Samsung devices (Galaxy S4, Galaxy Note 3) there is a setting under Wi-Fi Settings called "Auto Network Switch" that Samsung has added that looks for "unstable" networks, and will automatically disconnect and revert to mobile data. Unfortunately, since our device has no internet connection, Samsung reports it as un unstable network and immediately disconnects.

I don't have either of these devices available for testing on, so I'm curious if anyone else is aware of this issue or knows of a way to either programmatically disable this setting or work around it?

The code we use for the connection is:

/**
 * Attempt to connect to an open wifi network with the given SSID
 * @param ssid the SSID of the unsecured wireless network to connect to
 */
public static void connectToOpenNetwork (String ssid) {
    WifiManager mgr = getManager();
    WifiConfiguration configuration = getOpenWifiConfiguration(ssid);
    mgr.addNetwork(configuration);
    mgr.saveConfiguration();

    int res = findOpenNetworkId(ssid);
    if (res != INVALID_NETWORK_ID) {
        mgr.enableNetwork(res, true);
        mgr.reconnect();
    } else {
        Log.e(TAG, "Received request to connect to network " + ssid + " but the network was not found in the configurations.");
    }
}

/**
 * Get a WifiConfiguration object configured for an unsecured wireless network with the
 * given SSID.
 * @param ssid the SSID of the network to configure
 * @return a WifiConfiguration object that can be passed to
 * {@link WifiManager#addNetwork(android.net.wifi.WifiConfiguration)}
 */
private static WifiConfiguration getOpenWifiConfiguration (String ssid) {
    WifiConfiguration config = new WifiConfiguration();

    config.SSID = "\"" + ssid + "\"";
    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);

    return config;
}

Answer 1

EDIT: So, further research for those interested, it seems to be a feature added in Samsung Touchwiz versions based on 4.3. Internally, the setting is named "wifi_watchdog_connectivity_check". I still use the below code to see if I'm able to check for sure whether or not the setting is enabled, but otherwise I'd have to assume it's on.

So what I've discovered is that, after you attempt to make a connection, and the OS switches away from the network, the Wi-Fi configuration is in the "disabled" state. So after the problem occurs, you can detect for sure that it has happened by checking the state of the configuration from the WifiManager.

WifiManager m = (WifiManger) getSystemService(Context.WIFI_SERVICE);
List<WifiConfiguration> networks = m.getConfiguredNetworks();
String mySsid = "My Network";
mySsid = "\"" + mySsid + "\"";

boolean isDisabled = false;
for (WifiConfiguration config : networks) {
    if (mySsid.equals(config.SSID)) {
        if (config.status = WifiConfiguration.Status.DISABLED) {
            isDisabled = true;
            break;
        }
    }
}

//If isDisabled is true, the network was disabled by the OS

You can then try to resolve the name of the setting from the system settings application:

/** Gets the resources of another installed application */
private static Resources getExternalResources(Context ctx, String namespace) {
    PackageManager pm = ctx.getPackageManager();
    try {
        return (pm == null) ? null : pm.getResourcesForApplication(namespace);
    } catch (PackageManager.NameNotFoundException ex) {
        return null;
    }
}

/** Gets a resource ID from another installed application */
private static int getExternalIdentifier(Context ctx, String namespace, 
        String key, String type) {
    Resources res = getExternalResources(ctx, namespace);
    return (res == null) ? 0 : res.getIdentifier(key, type, namespace);
}

/** Gets a String resource from another installed application */
public static String getExternalString(Context ctx, String namespace, 
        String key, String defVal) {
    int resId = getExternalIdentifier(ctx, namespace, key, "string");
    if (resId != 0) {
        Resources res = getExternalResources(ctx, namespace);
        return res.getString(resId);
    } else {
        return defVal;
    }
}

Then use it to get the string:

String autoNetworkSwitch = getExternalString(this, "com.android.settings",
        "wifi_watchdog_connectivity_check", "Unknown");

This will return a localized string for the current user's language, if the string exists.

---

For anyone interested in the results of this, it turns out that this option is actually a stock Android setting, but it seems to be more aggressive on these Samsung devices. The setting is a hidden setting found in android.provider.Settings.java:

/**
 * Setting to turn off poor network avoidance on Wi-Fi. Feature is enabled by default and
 * the setting needs to be set to 0 to disable it.
 * @hide
 */
public static final String WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED =
       "wifi_watchdog_poor_network_test_enabled";

Which is in Settings$Secure for API == 15 || API == 16, or Settings$Global for API >= 17. This is not a setting that can be enabled or disabled by third party applications; however, it can be detected and warned against. My solution is this:

import static android.os.Build.VERSION.SDK_INT;
import static android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1;
import static android.os.Build.VERSION_CODES.JELLY_BEAN_MR1;

/**
 * Checks whether the "Avoid poor networks" setting (named "Auto network switch" on 
 * some Samsung devices) is enabled, which can in some instances interfere with Wi-Fi.
 *
 * @return true if the "Avoid poor networks" or "Auto network switch" setting is enabled
 */
public static boolean isPoorNetworkAvoidanceEnabled (Context ctx) {
    final int SETTING_UNKNOWN = -1;
    final int SETTING_ENABLED = 1;
    final String AVOID_POOR = "wifi_watchdog_poor_network_test_enabled";
    final String WATCHDOG_CLASS = "android.net.wifi.WifiWatchdogStateMachine";
    final String DEFAULT_ENABLED = "DEFAULT_POOR_NETWORK_AVOIDANCE_ENABLED";
    final ContentResolver cr = ctx.getContentResolver();

    int result;

    if (SDK_INT >= JELLY_BEAN_MR1) {
        //Setting was moved from Secure to Global as of JB MR1
        result = Settings.Global.getInt(cr, AVOID_POOR, SETTING_UNKNOWN);
    } else if (SDK_INT >= ICE_CREAM_SANDWICH_MR1) {
        result = Settings.Secure.getInt(cr, AVOID_POOR, SETTING_UNKNOWN);
    } else {
        //Poor network avoidance not introduced until ICS MR1
        //See android.provider.Settings.java
        return false;
    }

    //Exit here if the setting value is known
    if (result != SETTING_UNKNOWN) {
        return (result == SETTING_ENABLED);
    }

    //Setting does not exist in database, so it has never been changed.
    //It will be initialized to the default value.
    if (SDK_INT >= JELLY_BEAN_MR1) {
        //As of JB MR1, a constant was added to WifiWatchdogStateMachine to determine 
        //the default behavior of the Avoid Poor Networks setting.
        try {
            //In the case of any failures here, take the safe route and assume the 
            //setting is disabled to avoid disrupting the user with false information
            Class wifiWatchdog = Class.forName(WATCHDOG_CLASS);
            Field defValue = wifiWatchdog.getField(DEFAULT_ENABLED);
            if (!defValue.isAccessible()) defValue.setAccessible(true);
            return defValue.getBoolean(null);
        } catch (IllegalAccessException ex) {
            return false;
        } catch (NoSuchFieldException ex) {
            return false;
        } catch (ClassNotFoundException ex) {
            return false;
        } catch (IllegalArgumentException ex) {
            return false;
        }
    } else {
        //Prior to JB MR1, the default for the Avoid Poor Networks setting was
        //to enable it unless explicitly disabled
        return true;
    }
}

For good measure, you can then direct your users to the Advanced Wi-Fi Settings by means of Intent:

/**
 *  Ensure that an Activity is available to receive the given Intent
 */
public static boolean activityExists (Context ctx, Intent intent) {
    final PackageManager mgr = ctx.getPackageManager();
    final ResolveInfo info = mgr.resolveActivity(i, PackageManager.MATCH_DEFAULT_ONLY);
    return (info != null);
}

public static void showAdvancedWifiIfAvailable (Context ctx) {
    final Intent i = new Intent(Settings.ACTION_WIFI_IP_SETTINGS);
    if (activityExists(ctx, i)) {
        ctx.startActivity(i);
    }
}

Interesting trivia: This Intent brings up the same Activity as going to Settings > Wi-Fi > Advanced, but will show it with a different title (IP Settings, vs Advanced Wi-Fi).