/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.net.wifi;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.database.ContentObserver;
import android.net.ConnectivityManager;
import android.net.DnsPinger;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Message;
import android.os.SystemClock;
import android.os.SystemProperties;
import android.provider.Settings;
import android.provider.Settings.Secure;
import android.util.Log;
import com.android.internal.R;
import com.android.internal.util.Protocol;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.URL;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
/**
* {@link WifiWatchdogStateMachine} monitors the initial connection to a Wi-Fi
* network with multiple access points. After the framework successfully
* connects to an access point, the watchdog verifies connectivity by 'pinging'
* the configured DNS server using {@link DnsPinger}.
* <p>
* On DNS check failure, the BSSID is blacklisted if it is reasonably likely
* that another AP might have internet access; otherwise the SSID is disabled.
* <p>
* On DNS success, the WatchdogService initiates a walled garden check via an
* http get. A browser window is activated if a walled garden is detected.
*
* @hide
*/
public class WifiWatchdogStateMachine extends StateMachine {
private static final boolean DBG = false;
private static final String TAG = "WifiWatchdogStateMachine";
private static final String DISABLED_NETWORK_NOTIFICATION_ID = "WifiWatchdog.networkdisabled";
private static final String WALLED_GARDEN_NOTIFICATION_ID = "WifiWatchdog.walledgarden";
private static final int WIFI_SIGNAL_LEVELS = 4;
/**
* Low signal is defined as less than or equal to cut off
*/
private static final int LOW_SIGNAL_CUTOFF = 0;
private static final long DEFAULT_DNS_CHECK_SHORT_INTERVAL_MS = 2 * 60 * 1000;
private static final long DEFAULT_DNS_CHECK_LONG_INTERVAL_MS = 60 * 60 * 1000;
private static final long DEFAULT_WALLED_GARDEN_INTERVAL_MS = 30 * 60 * 1000;
private static final int DEFAULT_MAX_SSID_BLACKLISTS = 7;
private static final int DEFAULT_NUM_DNS_PINGS = 5; // Multiple pings to detect setup issues
private static final int DEFAULT_MIN_DNS_RESPONSES = 1;
private static final int DEFAULT_DNS_PING_TIMEOUT_MS = 2000;
private static final long DEFAULT_BLACKLIST_FOLLOWUP_INTERVAL_MS = 15 * 1000;
// See http://go/clientsdns for usage approval
private static final String DEFAULT_WALLED_GARDEN_URL =
"http://clients3.google.com/generate_204";
private static final int WALLED_GARDEN_SOCKET_TIMEOUT_MS = 10000;
/* Some carrier apps might have support captive portal handling. Add some delay to allow
app authentication to be done before our test.
TODO: This should go away once we provide an API to apps to disable walled garden test
for certain SSIDs
*/
private static final int WALLED_GARDEN_START_DELAY_MS = 3000;
private static final int DNS_INTRATEST_PING_INTERVAL_MS = 200;
/* With some router setups, it takes a few hunder milli-seconds before connection is active */
private static final int DNS_START_DELAY_MS = 1000;
private static final int BASE = Protocol.BASE_WIFI_WATCHDOG;
/**
* Indicates the enable setting of WWS may have changed
*/
private static final int EVENT_WATCHDOG_TOGGLED = BASE + 1;
/**
* Indicates the wifi network state has changed. Passed w/ original intent
* which has a non-null networkInfo object
*/
private static final int EVENT_NETWORK_STATE_CHANGE = BASE + 2;
/**
* Indicates the signal has changed. Passed with arg1
* {@link #mNetEventCounter} and arg2 [raw signal strength]
*/
private static final int EVENT_RSSI_CHANGE = BASE + 3;
private static final int EVENT_SCAN_RESULTS_AVAILABLE = BASE + 4;
private static final int EVENT_WIFI_RADIO_STATE_CHANGE = BASE + 5;
private static final int EVENT_WATCHDOG_SETTINGS_CHANGE = BASE + 6;
private static final int MESSAGE_HANDLE_WALLED_GARDEN = BASE + 100;
private static final int MESSAGE_HANDLE_BAD_AP = BASE + 101;
/**
* arg1 == mOnlineWatchState.checkCount
*/
private static final int MESSAGE_SINGLE_DNS_CHECK = BASE + 102;
private static final int MESSAGE_NETWORK_FOLLOWUP = BASE + 103;
private static final int MESSAGE_DELAYED_WALLED_GARDEN_CHECK = BASE + 104;
private Context mContext;
private ContentResolver mContentResolver;
private WifiManager mWifiManager;
private DnsPinger mDnsPinger;
private IntentFilter mIntentFilter;
private BroadcastReceiver mBroadcastReceiver;
private DefaultState mDefaultState = new DefaultState();
private WatchdogDisabledState mWatchdogDisabledState = new WatchdogDisabledState();
private WatchdogEnabledState mWatchdogEnabledState = new WatchdogEnabledState();
private NotConnectedState mNotConnectedState = new NotConnectedState();
private ConnectedState mConnectedState = new ConnectedState();
private DnsCheckingState mDnsCheckingState = new DnsCheckingState();
private OnlineWatchState mOnlineWatchState = new OnlineWatchState();
private OnlineState mOnlineState = new OnlineState();
private DnsCheckFailureState mDnsCheckFailureState = new DnsCheckFailureState();
private DelayWalledGardenState mDelayWalledGardenState = new DelayWalledGardenState();
private WalledGardenState mWalledGardenState = new WalledGardenState();
private BlacklistedApState mBlacklistedApState = new BlacklistedApState();
private long mDnsCheckShortIntervalMs;
private long mDnsCheckLongIntervalMs;
private long mWalledGardenIntervalMs;
private int mMaxSsidBlacklists;
private int mNumDnsPings;
private int mMinDnsResponses;
private int mDnsPingTimeoutMs;
private long mBlacklistFollowupIntervalMs;
private boolean mPoorNetworkDetectionEnabled;
private boolean mWalledGardenTestEnabled;
private String mWalledGardenUrl;
private boolean mShowDisabledNotification;
/**
* The {@link WifiInfo} object passed to WWSM on network broadcasts
*/
private WifiInfo mConnectionInfo;
private int mNetEventCounter = 0;
/**
* Currently maintained but not used, TODO
*/
private HashSet<String> mBssids = new HashSet<String>();
private int mNumCheckFailures = 0;
private Long mLastWalledGardenCheckTime = null;
/**
* This is set by the blacklisted state and reset when connected to a new AP.
* It triggers a disableNetwork call if a DNS check fails.
*/
public boolean mDisableAPNextFailure = false;
private static boolean sWifiOnly = false;
private boolean mDisabledNotificationShown;
private boolean mWalledGardenNotificationShown;
public boolean mHasConnectedWifiManager = false;
/**
* STATE MAP
* Default
* / \
* Disabled Enabled
* / \
* NotConnected Connected
* /---------\
* (all other states)
*/
private WifiWatchdogStateMachine(Context context) {
super(TAG);
mContext = context;
mContentResolver = context.getContentResolver();
mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
mDnsPinger = new DnsPinger(mContext, "WifiWatchdogStateMachine.DnsPinger",
this.getHandler().getLooper(), this.getHandler(),
ConnectivityManager.TYPE_WIFI);
setupNetworkReceiver();
// The content observer to listen needs a handler
registerForSettingsChanges();
registerForWatchdogToggle();
addState(mDefaultState);
addState(mWatchdogDisabledState, mDefaultState);
addState(mWatchdogEnabledState, mDefaultState);
addState(mNotConnectedState, mWatchdogEnabledState);
addState(mConnectedState, mWatchdogEnabledState);
addState(mDnsCheckingState, mConnectedState);
addState(mDnsCheckFailureState, mConnectedState);
addState(mDelayWalledGardenState, mConnectedState);
addState(mWalledGardenState, mConnectedState);
addState(mBlacklistedApState, mConnectedState);
addState(mOnlineWatchState, mConnectedState);
addState(mOnlineState, mConnectedState);
setInitialState(mWatchdogDisabledState);
updateSettings();
}
public static WifiWatchdogStateMachine makeWifiWatchdogStateMachine(Context context) {
ContentResolver contentResolver = context.getContentResolver();
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(
Context.CONNECTIVITY_SERVICE);
sWifiOnly = (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE) == false);
// Disable for wifi only devices.
if (Settings.Secure.getString(contentResolver, Settings.Secure.WIFI_WATCHDOG_ON) == null &&
sWifiOnly) {
putSettingsBoolean(contentResolver, Settings.Secure.WIFI_WATCHDOG_ON, false);
}
WifiWatchdogStateMachine wwsm = new WifiWatchdogStateMachine(context);
wwsm.start();
wwsm.sendMessage(EVENT_WATCHDOG_TOGGLED);
return wwsm;
}
/**
*
*/
private void setupNetworkReceiver() {
mBroadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
sendMessage(EVENT_NETWORK_STATE_CHANGE, intent);
} else if (action.equals(WifiManager.RSSI_CHANGED_ACTION)) {
obtainMessage(EVENT_RSSI_CHANGE, mNetEventCounter,
intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200)).sendToTarget();
} else if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
sendMessage(EVENT_SCAN_RESULTS_AVAILABLE);
} else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
sendMessage(EVENT_WIFI_RADIO_STATE_CHANGE,
intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
WifiManager.WIFI_STATE_UNKNOWN));
}
}
};
mIntentFilter = new IntentFilter();
mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
mIntentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
}
/**
* Observes the watchdog on/off setting, and takes action when changed.
*/
private void registerForWatchdogToggle() {
ContentObserver contentObserver = new ContentObserver(this.getHandler()) {
@Override
public void onChange(boolean selfChange) {
sendMessage(EVENT_WATCHDOG_TOGGLED);
}
};
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_ON),
false, contentObserver);
}
/**
* Observes watchdogs secure setting changes.
*/
private void registerForSettingsChanges() {
ContentObserver contentObserver = new ContentObserver(this.getHandler()) {
@Override
public void onChange(boolean selfChange) {
sendMessage(EVENT_WATCHDOG_SETTINGS_CHANGE);
}
};
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(
Settings.Secure.WIFI_WATCHDOG_DNS_CHECK_SHORT_INTERVAL_MS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_DNS_CHECK_LONG_INTERVAL_MS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_WALLED_GARDEN_INTERVAL_MS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_MAX_SSID_BLACKLISTS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_NUM_DNS_PINGS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_MIN_DNS_RESPONSES),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_DNS_PING_TIMEOUT_MS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(
Settings.Secure.WIFI_WATCHDOG_BLACKLIST_FOLLOWUP_INTERVAL_MS),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_WALLED_GARDEN_TEST_ENABLED),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_WALLED_GARDEN_URL),
false, contentObserver);
mContext.getContentResolver().registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_SHOW_DISABLED_NETWORK_POPUP)
, false, contentObserver);
}
/**
* DNS based detection techniques do not work at all hotspots. The one sure
* way to check a walled garden is to see if a URL fetch on a known address
* fetches the data we expect
*/
private boolean isWalledGardenConnection() {
HttpURLConnection urlConnection = null;
try {
URL url = new URL(mWalledGardenUrl);
urlConnection = (HttpURLConnection) url.openConnection();
urlConnection.setInstanceFollowRedirects(false);
urlConnection.setConnectTimeout(WALLED_GARDEN_SOCKET_TIMEOUT_MS);
urlConnection.setReadTimeout(WALLED_GARDEN_SOCKET_TIMEOUT_MS);
urlConnection.setUseCaches(false);
urlConnection.getInputStream();
// We got a valid response, but not from the real google
return urlConnection.getResponseCode() != 204;
} catch (IOException e) {
if (DBG) {
log("Walled garden check - probably not a portal: exception " + e);
}
return false;
} finally {
if (urlConnection != null) {
urlConnection.disconnect();
}
}
}
private boolean rssiStrengthAboveCutoff(int rssi) {
return WifiManager.calculateSignalLevel(rssi, WIFI_SIGNAL_LEVELS) > LOW_SIGNAL_CUTOFF;
}
public void dump(PrintWriter pw) {
pw.print("WatchdogStatus: ");
pw.print("State " + getCurrentState());
pw.println(", network [" + mConnectionInfo + "]");
pw.print("checkFailures " + mNumCheckFailures);
pw.println(", bssids: " + mBssids);
pw.println("lastSingleCheck: " + mOnlineWatchState.lastCheckTime);
}
private boolean isWatchdogEnabled() {
return getSettingsBoolean(mContentResolver, Settings.Secure.WIFI_WATCHDOG_ON, true);
}
private void updateSettings() {
mDnsCheckShortIntervalMs = Secure.getLong(mContentResolver,
Secure.WIFI_WATCHDOG_DNS_CHECK_SHORT_INTERVAL_MS,
DEFAULT_DNS_CHECK_SHORT_INTERVAL_MS);
mDnsCheckLongIntervalMs = Secure.getLong(mContentResolver,
Secure.WIFI_WATCHDOG_DNS_CHECK_LONG_INTERVAL_MS,
DEFAULT_DNS_CHECK_LONG_INTERVAL_MS);
mMaxSsidBlacklists = Secure.getInt(mContentResolver,
Secure.WIFI_WATCHDOG_MAX_SSID_BLACKLISTS,
DEFAULT_MAX_SSID_BLACKLISTS);
mNumDnsPings = Secure.getInt(mContentResolver,
Secure.WIFI_WATCHDOG_NUM_DNS_PINGS,
DEFAULT_NUM_DNS_PINGS);
mMinDnsResponses = Secure.getInt(mContentResolver,
Secure.WIFI_WATCHDOG_MIN_DNS_RESPONSES,
DEFAULT_MIN_DNS_RESPONSES);
mDnsPingTimeoutMs = Secure.getInt(mContentResolver,
Secure.WIFI_WATCHDOG_DNS_PING_TIMEOUT_MS,
DEFAULT_DNS_PING_TIMEOUT_MS);
mBlacklistFollowupIntervalMs = Secure.getLong(mContentResolver,
Settings.Secure.WIFI_WATCHDOG_BLACKLIST_FOLLOWUP_INTERVAL_MS,
DEFAULT_BLACKLIST_FOLLOWUP_INTERVAL_MS);
//TODO: enable this by default after changing watchdog behavior
//Also, update settings description
mPoorNetworkDetectionEnabled = getSettingsBoolean(mContentResolver,
Settings.Secure.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, false);
mWalledGardenTestEnabled = getSettingsBoolean(mContentResolver,
Settings.Secure.WIFI_WATCHDOG_WALLED_GARDEN_TEST_ENABLED, true);
mWalledGardenUrl = getSettingsStr(mContentResolver,
Settings.Secure.WIFI_WATCHDOG_WALLED_GARDEN_URL,
DEFAULT_WALLED_GARDEN_URL);
mWalledGardenIntervalMs = Secure.getLong(mContentResolver,
Secure.WIFI_WATCHDOG_WALLED_GARDEN_INTERVAL_MS,
DEFAULT_WALLED_GARDEN_INTERVAL_MS);
mShowDisabledNotification = getSettingsBoolean(mContentResolver,
Settings.Secure.WIFI_WATCHDOG_SHOW_DISABLED_NETWORK_POPUP, true);
}
/**
* Helper to return wait time left given a min interval and last run
*
* @param interval minimum wait interval
* @param lastTime last time action was performed in
* SystemClock.elapsedRealtime(). Null if never.
* @return non negative time to wait
*/
private static long waitTime(long interval, Long lastTime) {
if (lastTime == null)
return 0;
long wait = interval + lastTime - SystemClock.elapsedRealtime();
return wait > 0 ? wait : 0;
}
private static String wifiInfoToStr(WifiInfo wifiInfo) {
if (wifiInfo == null)
return "null";
return "(" + wifiInfo.getSSID() + ", " + wifiInfo.getBSSID() + ")";
}
/**
* Uses {@link #mConnectionInfo}.
*/
private void updateBssids() {
String curSsid = mConnectionInfo.getSSID();
List<ScanResult> results = mWifiManager.getScanResults();
int oldNumBssids = mBssids.size();
if (results == null) {
if (DBG) {
log("updateBssids: Got null scan results!");
}
return;
}
for (ScanResult result : results) {
if (result == null || result.SSID == null) {
if (DBG) {
log("Received invalid scan result: " + result);
}
continue;
}
if (curSsid.equals(result.SSID))
mBssids.add(result.BSSID);
}
}
private void resetWatchdogState() {
if (DBG) {
log("Resetting watchdog state...");
}
mConnectionInfo = null;
mDisableAPNextFailure = false;
mLastWalledGardenCheckTime = null;
mNumCheckFailures = 0;
mBssids.clear();
setDisabledNetworkNotificationVisible(false);
setWalledGardenNotificationVisible(false);
}
private void setWalledGardenNotificationVisible(boolean visible) {
// If it should be hidden and it is already hidden, then noop
if (!visible && !mWalledGardenNotificationShown) {
return;
}
Resources r = Resources.getSystem();
NotificationManager notificationManager = (NotificationManager) mContext
.getSystemService(Context.NOTIFICATION_SERVICE);
if (visible) {
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(mWalledGardenUrl));
intent.setFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT | Intent.FLAG_ACTIVITY_NEW_TASK);
CharSequence title = r.getString(R.string.wifi_available_sign_in, 0);
CharSequence details = r.getString(R.string.wifi_available_sign_in_detailed,
mConnectionInfo.getSSID());
Notification notification = new Notification();
notification.when = 0;
notification.icon = com.android.internal.R.drawable.stat_notify_wifi_in_range;
notification.flags = Notification.FLAG_AUTO_CANCEL;
notification.contentIntent = PendingIntent.getActivity(mContext, 0, intent, 0);
notification.tickerText = title;
notification.setLatestEventInfo(mContext, title, details, notification.contentIntent);
notificationManager.notify(WALLED_GARDEN_NOTIFICATION_ID, 1, notification);
} else {
notificationManager.cancel(WALLED_GARDEN_NOTIFICATION_ID, 1);
}
mWalledGardenNotificationShown = visible;
}
private void setDisabledNetworkNotificationVisible(boolean visible) {
// If it should be hidden and it is already hidden, then noop
if (!visible && !mDisabledNotificationShown) {
return;
}
Resources r = Resources.getSystem();
NotificationManager notificationManager = (NotificationManager) mContext
.getSystemService(Context.NOTIFICATION_SERVICE);
if (visible) {
CharSequence title = r.getText(R.string.wifi_watchdog_network_disabled);
String msg = mConnectionInfo.getSSID() +
r.getText(R.string.wifi_watchdog_network_disabled_detailed);
Notification wifiDisabledWarning = new Notification.Builder(mContext)
.setSmallIcon(R.drawable.stat_sys_warning)
.setDefaults(Notification.DEFAULT_ALL)
.setTicker(title)
.setContentTitle(title)
.setContentText(msg)
.setContentIntent(PendingIntent.getActivity(mContext, 0,
new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK)
.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK), 0))
.setWhen(System.currentTimeMillis())
.setAutoCancel(true)
.getNotification();
notificationManager.notify(DISABLED_NETWORK_NOTIFICATION_ID, 1, wifiDisabledWarning);
} else {
notificationManager.cancel(DISABLED_NETWORK_NOTIFICATION_ID, 1);
}
mDisabledNotificationShown = visible;
}
class DefaultState extends State {
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
case EVENT_WATCHDOG_SETTINGS_CHANGE:
updateSettings();
if (DBG) {
log("Updating wifi-watchdog secure settings");
}
return HANDLED;
}
if (DBG) {
log("Caught message " + msg.what + " in state " +
getCurrentState().getName());
}
return HANDLED;
}
}
class WatchdogDisabledState extends State {
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
case EVENT_WATCHDOG_TOGGLED:
if (isWatchdogEnabled())
transitionTo(mNotConnectedState);
return HANDLED;
}
return NOT_HANDLED;
}
}
class WatchdogEnabledState extends State {
@Override
public void enter() {
resetWatchdogState();
mContext.registerReceiver(mBroadcastReceiver, mIntentFilter);
if (DBG) log("WifiWatchdogService enabled");
}
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
case EVENT_WATCHDOG_TOGGLED:
if (!isWatchdogEnabled())
transitionTo(mWatchdogDisabledState);
return HANDLED;
case EVENT_NETWORK_STATE_CHANGE:
Intent stateChangeIntent = (Intent) msg.obj;
NetworkInfo networkInfo = (NetworkInfo)
stateChangeIntent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
setDisabledNetworkNotificationVisible(false);
setWalledGardenNotificationVisible(false);
switch (networkInfo.getState()) {
case CONNECTED:
WifiInfo wifiInfo = (WifiInfo)
stateChangeIntent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO);
if (wifiInfo == null) {
loge("Connected --> WifiInfo object null!");
return HANDLED;
}
if (wifiInfo.getSSID() == null || wifiInfo.getBSSID() == null) {
loge("Received wifiInfo object with null elts: "
+ wifiInfoToStr(wifiInfo));
return HANDLED;
}
initConnection(wifiInfo);
mConnectionInfo = wifiInfo;
mNetEventCounter++;
if (mPoorNetworkDetectionEnabled) {
updateBssids();
transitionTo(mDnsCheckingState);
} else {
transitionTo(mDelayWalledGardenState);
}
break;
default:
mNetEventCounter++;
transitionTo(mNotConnectedState);
break;
}
return HANDLED;
case EVENT_WIFI_RADIO_STATE_CHANGE:
if ((Integer) msg.obj == WifiManager.WIFI_STATE_DISABLING) {
if (DBG) log("WifiStateDisabling -- Resetting WatchdogState");
resetWatchdogState();
mNetEventCounter++;
transitionTo(mNotConnectedState);
}
return HANDLED;
}
return NOT_HANDLED;
}
/**
* @param wifiInfo Info object with non-null ssid and bssid
*/
private void initConnection(WifiInfo wifiInfo) {
if (DBG) {
log("Connected:: old " + wifiInfoToStr(mConnectionInfo) +
" ==> new " + wifiInfoToStr(wifiInfo));
}
if (mConnectionInfo == null || !wifiInfo.getSSID().equals(mConnectionInfo.getSSID())) {
resetWatchdogState();
} else if (!wifiInfo.getBSSID().equals(mConnectionInfo.getBSSID())) {
mDisableAPNextFailure = false;
}
}
@Override
public void exit() {
mContext.unregisterReceiver(mBroadcastReceiver);
if (DBG) log("WifiWatchdogService disabled");
}
}
class NotConnectedState extends State {
}
class ConnectedState extends State {
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
case EVENT_SCAN_RESULTS_AVAILABLE:
if (mPoorNetworkDetectionEnabled) {
updateBssids();
}
return HANDLED;
case EVENT_WATCHDOG_SETTINGS_CHANGE:
updateSettings();
if (mPoorNetworkDetectionEnabled) {
transitionTo(mOnlineWatchState);
} else {
transitionTo(mOnlineState);
}
return HANDLED;
}
return NOT_HANDLED;
}
}
class DnsCheckingState extends State {
List<InetAddress> mDnsList;
int[] dnsCheckSuccesses;
String dnsCheckLogStr;
String[] dnsResponseStrs;
/** Keeps track of active dns pings. Map is from pingID to index in mDnsList */
HashMap<Integer, Integer> idDnsMap = new HashMap<Integer, Integer>();
@Override
public void enter() {
mDnsList = mDnsPinger.getDnsList();
int numDnses = mDnsList.size();
dnsCheckSuccesses = new int[numDnses];
dnsResponseStrs = new String[numDnses];
for (int i = 0; i < numDnses; i++)
dnsResponseStrs[i] = "";
if (DBG) {
dnsCheckLogStr = String.format("Pinging %s on ssid [%s]: ",
mDnsList, mConnectionInfo.getSSID());
log(dnsCheckLogStr);
}
idDnsMap.clear();
for (int i=0; i < mNumDnsPings; i++) {
for (int j = 0; j < numDnses; j++) {
idDnsMap.put(mDnsPinger.pingDnsAsync(mDnsList.get(j), mDnsPingTimeoutMs,
DNS_START_DELAY_MS + DNS_INTRATEST_PING_INTERVAL_MS * i), j);
}
}
}
@Override
public boolean processMessage(Message msg) {
if (msg.what != DnsPinger.DNS_PING_RESULT) {
return NOT_HANDLED;
}
int pingID = msg.arg1;
int pingResponseTime = msg.arg2;
Integer dnsServerId = idDnsMap.get(pingID);
if (dnsServerId == null) {
loge("Received a Dns response with unknown ID!");
return HANDLED;
}
idDnsMap.remove(pingID);
if (pingResponseTime >= 0)
dnsCheckSuccesses[dnsServerId]++;
if (DBG) {
if (pingResponseTime >= 0) {
dnsResponseStrs[dnsServerId] += "|" + pingResponseTime;
} else {
dnsResponseStrs[dnsServerId] += "|x";
}
}
/**
* After a full ping count, if we have more responses than this
* cutoff, the outcome is success; else it is 'failure'.
*/
/**
* Our final success count will be at least this big, so we're
* guaranteed to succeed.
*/
if (dnsCheckSuccesses[dnsServerId] >= mMinDnsResponses) {
// DNS CHECKS OK, NOW WALLED GARDEN
if (DBG) {
log(makeLogString() + " SUCCESS");
}
if (!shouldCheckWalledGarden()) {
transitionTo(mOnlineWatchState);
return HANDLED;
}
transitionTo(mDelayWalledGardenState);
return HANDLED;
}
if (idDnsMap.isEmpty()) {
if (DBG) {
log(makeLogString() + " FAILURE");
}
transitionTo(mDnsCheckFailureState);
return HANDLED;
}
return HANDLED;
}
private String makeLogString() {
String logStr = dnsCheckLogStr;
for (String respStr : dnsResponseStrs)
logStr += " [" + respStr + "]";
return logStr;
}
@Override
public void exit() {
mDnsPinger.cancelPings();
}
private boolean shouldCheckWalledGarden() {
if (!mWalledGardenTestEnabled) {
if (DBG)
log("Skipping walled garden check - disabled");
return false;
}
long waitTime = waitTime(mWalledGardenIntervalMs,
mLastWalledGardenCheckTime);
if (waitTime > 0) {
if (DBG) {
log("Skipping walled garden check - wait " +
waitTime + " ms.");
}
return false;
}
return true;
}
}
class DelayWalledGardenState extends State {
@Override
public void enter() {
sendMessageDelayed(MESSAGE_DELAYED_WALLED_GARDEN_CHECK, WALLED_GARDEN_START_DELAY_MS);
}
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
case MESSAGE_DELAYED_WALLED_GARDEN_CHECK:
mLastWalledGardenCheckTime = SystemClock.elapsedRealtime();
if (isWalledGardenConnection()) {
if (DBG) log("Walled garden test complete - walled garden detected");
transitionTo(mWalledGardenState);
} else {
if (DBG) log("Walled garden test complete - online");
if (mPoorNetworkDetectionEnabled) {
transitionTo(mOnlineWatchState);
} else {
transitionTo(mOnlineState);
}
}
return HANDLED;
default:
return NOT_HANDLED;
}
}
}
class OnlineWatchState extends State {
/**
* Signals a short-wait message is enqueued for the current 'guard' counter
*/
boolean unstableSignalChecks = false;
/**
* The signal is unstable. We should enqueue a short-wait check, if one is enqueued
* already
*/
boolean signalUnstable = false;
/**
* A monotonic counter to ensure that at most one check message will be processed from any
* set of check messages currently enqueued. Avoids duplicate checks when a low-signal
* event is observed.
*/
int checkGuard = 0;
Long lastCheckTime = null;
/** Keeps track of dns pings. Map is from pingID to InetAddress used for ping */
HashMap<Integer, InetAddress> pingInfoMap = new HashMap<Integer, InetAddress>();
@Override
public void enter() {
lastCheckTime = SystemClock.elapsedRealtime();
signalUnstable = false;
checkGuard++;
unstableSignalChecks = false;
pingInfoMap.clear();
triggerSingleDnsCheck();
}
@Override
public boolean processMessage(Message msg) {
switch (msg.what) {
case EVENT_RSSI_CHANGE:
if (msg.arg1 != mNetEventCounter) {
if (DBG) {
log("Rssi change message out of sync, ignoring");
}
return HANDLED;
}
int newRssi = msg.arg2;
signalUnstable = !rssiStrengthAboveCutoff(newRssi);
if (DBG) {
log("OnlineWatchState:: new rssi " + newRssi + " --> level " +
WifiManager.calculateSignalLevel(newRssi, WIFI_SIGNAL_LEVELS));
}
if (signalUnstable && !unstableSignalChecks) {
if (DBG) {
log("Sending triggered check msg");
}
triggerSingleDnsCheck();
}
return HANDLED;
case MESSAGE_SINGLE_DNS_CHECK:
if (msg.arg1 != checkGuard) {
if (DBG) {
log("Single check msg out of sync, ignoring.");
}
return HANDLED;
}
lastCheckTime = SystemClock.elapsedRealtime();
pingInfoMap.clear();
for (InetAddress curDns: mDnsPinger.getDnsList()) {
pingInfoMap.put(mDnsPinger.pingDnsAsync(curDns, mDnsPingTimeoutMs, 0),
curDns);
}
return HANDLED;
case DnsPinger.DNS_PING_RESULT:
InetAddress curDnsServer = pingInfoMap.get(msg.arg1);
if (curDnsServer == null) {
return HANDLED;
}
pingInfoMap.remove(msg.arg1);
int responseTime = msg.arg2;
if (responseTime >= 0) {
if (DBG) {
log("Single DNS ping OK. Response time: "
+ responseTime + " from DNS " + curDnsServer);
}
pingInfoMap.clear();
checkGuard++;
unstableSignalChecks = false;
triggerSingleDnsCheck();
} else {
if (pingInfoMap.isEmpty()) {
if (DBG) {
log("Single dns ping failure. All dns servers failed, "
+ "starting full checks.");
}
transitionTo(mDnsCheckingState);
}
}
return HANDLED;
}
return NOT_HANDLED;
}
@Override
public void exit() {
mDnsPinger.cancelPings();
}
/**
* Times a dns check with an interval based on {@link #signalUnstable}
*/
private void triggerSingleDnsCheck() {
long waitInterval;
if (signalUnstable) {
waitInterval = mDnsCheckShortIntervalMs;
unstableSignalChecks = true;
} else {
waitInterval = mDnsCheckLongIntervalMs;
}
sendMessageDelayed(obtainMessage(MESSAGE_SINGLE_DNS_CHECK, checkGuard, 0),
waitTime(waitInterval, lastCheckTime));
}
}
/* Child state of ConnectedState indicating that we are online
* and there is nothing to do
*/
class OnlineState extends State {
}
class DnsCheckFailureState extends State {
@Override
public void enter() {
mNumCheckFailures++;
obtainMessage(MESSAGE_HANDLE_BAD_AP, mNetEventCounter, 0).sendToTarget();
}
@Override
public boolean processMessage(Message msg) {
if (msg.what != MESSAGE_HANDLE_BAD_AP) {
return NOT_HANDLED;
}
if (msg.arg1 != mNetEventCounter) {
if (DBG) {
log("Msg out of sync, ignoring...");
}
return HANDLED;
}
if (mDisableAPNextFailure || mNumCheckFailures >= mBssids.size()
|| mNumCheckFailures >= mMaxSsidBlacklists) {
if (sWifiOnly) {
log("Would disable bad network, but device has no mobile data!" +
" Going idle...");
// This state should be called idle -- will be changing flow.
transitionTo(mNotConnectedState);
return HANDLED;
}
// TODO : Unban networks if they had low signal ?
log("Disabling current SSID " + wifiInfoToStr(mConnectionInfo)
+ ". " + "numCheckFailures " + mNumCheckFailures
+ ", numAPs " + mBssids.size());
int networkId = mConnectionInfo.getNetworkId();
if (!mHasConnectedWifiManager) {
mWifiManager.asyncConnect(mContext, getHandler());
mHasConnectedWifiManager = true;
}
mWifiManager.disableNetwork(networkId, WifiConfiguration.DISABLED_DNS_FAILURE);
if (mShowDisabledNotification && mConnectionInfo.isExplicitConnect()) {
setDisabledNetworkNotificationVisible(true);
}
transitionTo(mNotConnectedState);
} else {
log("Blacklisting current BSSID. " + wifiInfoToStr(mConnectionInfo)
+ "numCheckFailures " + mNumCheckFailures + ", numAPs " + mBssids.size());
mWifiManager.addToBlacklist(mConnectionInfo.getBSSID());
mWifiManager.reassociate();
transitionTo(mBlacklistedApState);
}
return HANDLED;
}
}
class WalledGardenState extends State {
@Override
public void enter() {
obtainMessage(MESSAGE_HANDLE_WALLED_GARDEN, mNetEventCounter, 0).sendToTarget();
}
@Override
public boolean processMessage(Message msg) {
if (msg.what != MESSAGE_HANDLE_WALLED_GARDEN) {
return NOT_HANDLED;
}
if (msg.arg1 != mNetEventCounter) {
if (DBG) {
log("WalledGardenState::Msg out of sync, ignoring...");
}
return HANDLED;
}
setWalledGardenNotificationVisible(true);
if (mPoorNetworkDetectionEnabled) {
transitionTo(mOnlineWatchState);
} else {
transitionTo(mOnlineState);
}
return HANDLED;
}
}
class BlacklistedApState extends State {
@Override
public void enter() {
mDisableAPNextFailure = true;
sendMessageDelayed(obtainMessage(MESSAGE_NETWORK_FOLLOWUP, mNetEventCounter, 0),
mBlacklistFollowupIntervalMs);
}
@Override
public boolean processMessage(Message msg) {
if (msg.what != MESSAGE_NETWORK_FOLLOWUP) {
return NOT_HANDLED;
}
if (msg.arg1 != mNetEventCounter) {
if (DBG) {
log("BlacklistedApState::Msg out of sync, ignoring...");
}
return HANDLED;
}
transitionTo(mDnsCheckingState);
return HANDLED;
}
}
/**
* Convenience function for retrieving a single secure settings value
* as a string with a default value.
*
* @param cr The ContentResolver to access.
* @param name The name of the setting to retrieve.
* @param def Value to return if the setting is not defined.
*
* @return The setting's current value, or 'def' if it is not defined
*/
private static String getSettingsStr(ContentResolver cr, String name, String def) {
String v = Settings.Secure.getString(cr, name);
return v != null ? v : def;
}
/**
* Convenience function for retrieving a single secure settings value
* as a boolean. Note that internally setting values are always
* stored as strings; this function converts the string to a boolean
* for you. The default value will be returned if the setting is
* not defined or not a valid boolean.
*
* @param cr The ContentResolver to access.
* @param name The name of the setting to retrieve.
* @param def Value to return if the setting is not defined.
*
* @return The setting's current value, or 'def' if it is not defined
* or not a valid boolean.
*/
private static boolean getSettingsBoolean(ContentResolver cr, String name, boolean def) {
return Settings.Secure.getInt(cr, name, def ? 1 : 0) == 1;
}
/**
* Convenience function for updating a single settings value as an
* integer. This will either create a new entry in the table if the
* given name does not exist, or modify the value of the existing row
* with that name. Note that internally setting values are always
* stored as strings, so this function converts the given value to a
* string before storing it.
*
* @param cr The ContentResolver to access.
* @param name The name of the setting to modify.
* @param value The new value for the setting.
* @return true if the value was set, false on database errors
*/
private static boolean putSettingsBoolean(ContentResolver cr, String name, boolean value) {
return Settings.Secure.putInt(cr, name, value ? 1 : 0);
}
private void log(String s) {
Log.d(TAG, s);
}
private void loge(String s) {
Log.e(TAG, s);
}
}