| /* |
| * 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.arp.ArpPeer; |
| import android.net.ConnectivityManager; |
| import android.net.LinkAddress; |
| import android.net.LinkProperties; |
| import android.net.NetworkInfo; |
| import android.net.RouteInfo; |
| 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.AsyncChannel; |
| 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.SocketException; |
| import java.net.URL; |
| |
| /** |
| * WifiWatchdogStateMachine monitors the connection to a Wi-Fi |
| * network. After the framework notifies that it has connected to an |
| * acccess point and is waiting for link to be verified, the watchdog |
| * takes over and verifies if the link is good by doing ARP pings to |
| * the gateway using {@link ArpPeer}. |
| * |
| * Upon successful verification, the watchdog notifies and continues |
| * to monitor the link afterwards when the RSSI level falls below |
| * a certain threshold. |
| |
| * When Wi-fi connects at L2 layer, the beacons from access point reach |
| * the device and it can maintain a connection, but the application |
| * connectivity can be flaky (due to bigger packet size exchange). |
| * |
| * We now monitor the quality of the last hop on |
| * Wi-Fi using signal strength and ARP connectivity as indicators |
| * to decide if the link is good enough to switch to Wi-Fi as the uplink. |
| * |
| * ARP pings are useful for link validation but can still get through |
| * when the application traffic fails to go through and are thus not |
| * the best indicator of real packet loss since they are tiny packets |
| * (28 bytes) and have a much low chance of packet corruption than the |
| * regular data packets. |
| * |
| * When signal strength and ARP are used together, it ends up working well in tests. |
| * The goal is to switch to Wi-Fi after validating ARP transfer |
| * and RSSI and then switching out of Wi-Fi when we hit a low |
| * signal strength threshold and then waiting until the signal strength |
| * improves and validating ARP transfer. |
| * |
| * @hide |
| */ |
| public class WifiWatchdogStateMachine extends StateMachine { |
| |
| /* STOPSHIP: Keep this configurable for debugging until ship */ |
| private static boolean DBG = false; |
| private static final String TAG = "WifiWatchdogStateMachine"; |
| private static final String WALLED_GARDEN_NOTIFICATION_ID = "WifiWatchdog.walledgarden"; |
| |
| /* RSSI Levels as used by notification icon |
| Level 4 -55 <= RSSI |
| Level 3 -66 <= RSSI < -55 |
| Level 2 -77 <= RSSI < -67 |
| Level 1 -88 <= RSSI < -78 |
| Level 0 RSSI < -88 */ |
| |
| /* Wi-fi connection is monitored actively below this |
| threshold */ |
| private static final int RSSI_LEVEL_MONITOR = 0; |
| /* Rssi threshold is at level 0 (-88dBm) */ |
| private static final int RSSI_MONITOR_THRESHOLD = -88; |
| /* Number of times RSSI is measured to be low before being avoided */ |
| private static final int RSSI_MONITOR_COUNT = 5; |
| private int mRssiMonitorCount = 0; |
| |
| /* Avoid flapping. The interval is changed over time as long as we continue to avoid |
| * under the max interval after which we reset the interval again */ |
| private static final int MIN_INTERVAL_AVOID_BSSID_MS[] = {0, 30 * 1000, 60 * 1000, |
| 5 * 60 * 1000, 30 * 60 * 1000}; |
| /* Index into the interval array MIN_INTERVAL_AVOID_BSSID_MS */ |
| private int mMinIntervalArrayIndex = 0; |
| |
| private long mLastBssidAvoidedTime; |
| |
| private int mCurrentSignalLevel; |
| |
| private static final long DEFAULT_ARP_CHECK_INTERVAL_MS = 2 * 60 * 1000; |
| private static final long DEFAULT_RSSI_FETCH_INTERVAL_MS = 1000; |
| private static final long DEFAULT_WALLED_GARDEN_INTERVAL_MS = 30 * 60 * 1000; |
| |
| private static final int DEFAULT_NUM_ARP_PINGS = 5; |
| private static final int DEFAULT_MIN_ARP_RESPONSES = 1; |
| |
| private static final int DEFAULT_ARP_PING_TIMEOUT_MS = 100; |
| |
| // 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 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; |
| /* Passed with RSSI information */ |
| private static final int EVENT_RSSI_CHANGE = BASE + 3; |
| private static final int EVENT_WIFI_RADIO_STATE_CHANGE = BASE + 5; |
| private static final int EVENT_WATCHDOG_SETTINGS_CHANGE = BASE + 6; |
| |
| /* Internal messages */ |
| private static final int CMD_ARP_CHECK = BASE + 11; |
| private static final int CMD_DELAYED_WALLED_GARDEN_CHECK = BASE + 12; |
| private static final int CMD_RSSI_FETCH = BASE + 13; |
| |
| /* Notifications to WifiStateMachine */ |
| static final int POOR_LINK_DETECTED = BASE + 21; |
| static final int GOOD_LINK_DETECTED = BASE + 22; |
| static final int RSSI_FETCH = BASE + 23; |
| static final int RSSI_FETCH_SUCCEEDED = BASE + 24; |
| static final int RSSI_FETCH_FAILED = BASE + 25; |
| |
| private static final int SINGLE_ARP_CHECK = 0; |
| private static final int FULL_ARP_CHECK = 1; |
| |
| private Context mContext; |
| private ContentResolver mContentResolver; |
| private WifiManager mWifiManager; |
| private IntentFilter mIntentFilter; |
| private BroadcastReceiver mBroadcastReceiver; |
| private AsyncChannel mWsmChannel = new AsyncChannel();; |
| |
| private DefaultState mDefaultState = new DefaultState(); |
| private WatchdogDisabledState mWatchdogDisabledState = new WatchdogDisabledState(); |
| private WatchdogEnabledState mWatchdogEnabledState = new WatchdogEnabledState(); |
| private NotConnectedState mNotConnectedState = new NotConnectedState(); |
| private VerifyingLinkState mVerifyingLinkState = new VerifyingLinkState(); |
| private ConnectedState mConnectedState = new ConnectedState(); |
| private WalledGardenCheckState mWalledGardenCheckState = new WalledGardenCheckState(); |
| /* Online and watching link connectivity */ |
| private OnlineWatchState mOnlineWatchState = new OnlineWatchState(); |
| /* RSSI level is below RSSI_LEVEL_MONITOR and needs close monitoring */ |
| private RssiMonitoringState mRssiMonitoringState = new RssiMonitoringState(); |
| /* Online and doing nothing */ |
| private OnlineState mOnlineState = new OnlineState(); |
| |
| private int mArpToken = 0; |
| private long mArpCheckIntervalMs; |
| private int mRssiFetchToken = 0; |
| private long mRssiFetchIntervalMs; |
| private long mWalledGardenIntervalMs; |
| private int mNumArpPings; |
| private int mMinArpResponses; |
| private int mArpPingTimeoutMs; |
| private boolean mPoorNetworkDetectionEnabled; |
| private boolean mWalledGardenTestEnabled; |
| private String mWalledGardenUrl; |
| |
| private WifiInfo mWifiInfo; |
| private LinkProperties mLinkProperties; |
| |
| private long mLastWalledGardenCheckTime = 0; |
| |
| private static boolean sWifiOnly = false; |
| private boolean mWalledGardenNotificationShown; |
| |
| /** |
| * STATE MAP |
| * Default |
| * / \ |
| * Disabled Enabled |
| * / \ \ |
| * NotConnected Verifying Connected |
| * /---------\ |
| * (all other states) |
| */ |
| private WifiWatchdogStateMachine(Context context) { |
| super(TAG); |
| mContext = context; |
| mContentResolver = context.getContentResolver(); |
| mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); |
| mWsmChannel.connectSync(mContext, getHandler(), |
| mWifiManager.getWifiStateMachineMessenger()); |
| |
| setupNetworkReceiver(); |
| |
| // The content observer to listen needs a handler |
| registerForSettingsChanges(); |
| registerForWatchdogToggle(); |
| addState(mDefaultState); |
| addState(mWatchdogDisabledState, mDefaultState); |
| addState(mWatchdogEnabledState, mDefaultState); |
| addState(mNotConnectedState, mWatchdogEnabledState); |
| addState(mVerifyingLinkState, mWatchdogEnabledState); |
| addState(mConnectedState, mWatchdogEnabledState); |
| addState(mWalledGardenCheckState, mConnectedState); |
| addState(mOnlineWatchState, mConnectedState); |
| addState(mRssiMonitoringState, mOnlineWatchState); |
| addState(mOnlineState, mConnectedState); |
| |
| if (isWatchdogEnabled()) { |
| setInitialState(mNotConnectedState); |
| } else { |
| 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); |
| |
| // Watchdog is always enabled. Poor network detection & walled garden detection |
| // can individually be turned on/off |
| // TODO: Remove this setting & clean up state machine since we always have |
| // watchdog in an enabled state |
| putSettingsBoolean(contentResolver, Settings.Secure.WIFI_WATCHDOG_ON, true); |
| |
| // Disable poor network avoidance, but keep watchdog active for walled garden detection |
| if (sWifiOnly) { |
| log("Disabling poor network avoidance for wi-fi only device"); |
| putSettingsBoolean(contentResolver, |
| Settings.Secure.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, false); |
| } |
| |
| WifiWatchdogStateMachine wwsm = new WifiWatchdogStateMachine(context); |
| wwsm.start(); |
| 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, |
| intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200), 0).sendToTarget(); |
| } 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); |
| mContext.registerReceiver(mBroadcastReceiver, mIntentFilter); |
| } |
| |
| /** |
| * 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_ARP_CHECK_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_NUM_ARP_PINGS), |
| false, contentObserver); |
| mContext.getContentResolver().registerContentObserver( |
| Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_MIN_ARP_RESPONSES), |
| false, contentObserver); |
| mContext.getContentResolver().registerContentObserver( |
| Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_ARP_PING_TIMEOUT_MS), |
| false, contentObserver); |
| mContext.getContentResolver().registerContentObserver( |
| Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED), |
| 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); |
| } |
| |
| /** |
| * 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(); |
| } |
| } |
| } |
| |
| public void dump(PrintWriter pw) { |
| pw.print("WatchdogStatus: "); |
| pw.print("State: " + getCurrentState()); |
| pw.println("mWifiInfo: [" + mWifiInfo + "]"); |
| pw.println("mLinkProperties: [" + mLinkProperties + "]"); |
| pw.println("mCurrentSignalLevel: [" + mCurrentSignalLevel + "]"); |
| pw.println("mArpCheckIntervalMs: [" + mArpCheckIntervalMs+ "]"); |
| pw.println("mRssiFetchIntervalMs: [" + mRssiFetchIntervalMs + "]"); |
| pw.println("mWalledGardenIntervalMs: [" + mWalledGardenIntervalMs + "]"); |
| pw.println("mNumArpPings: [" + mNumArpPings + "]"); |
| pw.println("mMinArpResponses: [" + mMinArpResponses + "]"); |
| pw.println("mArpPingTimeoutMs: [" + mArpPingTimeoutMs + "]"); |
| pw.println("mPoorNetworkDetectionEnabled: [" + mPoorNetworkDetectionEnabled + "]"); |
| pw.println("mWalledGardenTestEnabled: [" + mWalledGardenTestEnabled + "]"); |
| pw.println("mWalledGardenUrl: [" + mWalledGardenUrl + "]"); |
| } |
| |
| private boolean isWatchdogEnabled() { |
| boolean ret = getSettingsBoolean(mContentResolver, Settings.Secure.WIFI_WATCHDOG_ON, true); |
| if (DBG) log("watchdog enabled " + ret); |
| return ret; |
| } |
| |
| private void updateSettings() { |
| if (DBG) log("Updating secure settings"); |
| |
| mArpCheckIntervalMs = Secure.getLong(mContentResolver, |
| Secure.WIFI_WATCHDOG_ARP_CHECK_INTERVAL_MS, |
| DEFAULT_ARP_CHECK_INTERVAL_MS); |
| mRssiFetchIntervalMs = Secure.getLong(mContentResolver, |
| Secure.WIFI_WATCHDOG_RSSI_FETCH_INTERVAL_MS, |
| DEFAULT_RSSI_FETCH_INTERVAL_MS); |
| mNumArpPings = Secure.getInt(mContentResolver, |
| Secure.WIFI_WATCHDOG_NUM_ARP_PINGS, |
| DEFAULT_NUM_ARP_PINGS); |
| mMinArpResponses = Secure.getInt(mContentResolver, |
| Secure.WIFI_WATCHDOG_MIN_ARP_RESPONSES, |
| DEFAULT_MIN_ARP_RESPONSES); |
| mArpPingTimeoutMs = Secure.getInt(mContentResolver, |
| Secure.WIFI_WATCHDOG_ARP_PING_TIMEOUT_MS, |
| DEFAULT_ARP_PING_TIMEOUT_MS); |
| mPoorNetworkDetectionEnabled = getSettingsBoolean(mContentResolver, |
| Settings.Secure.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, true); |
| 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); |
| } |
| |
| 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, |
| mWifiInfo.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; |
| } |
| |
| class DefaultState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_WATCHDOG_SETTINGS_CHANGE: |
| updateSettings(); |
| if (DBG) { |
| log("Updating wifi-watchdog secure settings"); |
| } |
| break; |
| case EVENT_RSSI_CHANGE: |
| mCurrentSignalLevel = calculateSignalLevel(msg.arg1); |
| break; |
| case EVENT_WIFI_RADIO_STATE_CHANGE: |
| case EVENT_NETWORK_STATE_CHANGE: |
| case CMD_ARP_CHECK: |
| case CMD_DELAYED_WALLED_GARDEN_CHECK: |
| case CMD_RSSI_FETCH: |
| case RSSI_FETCH_SUCCEEDED: |
| case RSSI_FETCH_FAILED: |
| //ignore |
| break; |
| default: |
| log("Unhandled message " + msg + " in state " + getCurrentState().getName()); |
| break; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class WatchdogDisabledState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_WATCHDOG_TOGGLED: |
| if (isWatchdogEnabled()) |
| transitionTo(mNotConnectedState); |
| return HANDLED; |
| case EVENT_NETWORK_STATE_CHANGE: |
| Intent intent = (Intent) msg.obj; |
| NetworkInfo networkInfo = (NetworkInfo) |
| intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); |
| |
| switch (networkInfo.getDetailedState()) { |
| case VERIFYING_POOR_LINK: |
| if (DBG) log("Watchdog disabled, verify link"); |
| mWsmChannel.sendMessage(GOOD_LINK_DETECTED); |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| return NOT_HANDLED; |
| } |
| } |
| |
| class WatchdogEnabledState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log("WifiWatchdogService enabled"); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_WATCHDOG_TOGGLED: |
| if (!isWatchdogEnabled()) |
| transitionTo(mWatchdogDisabledState); |
| break; |
| case EVENT_NETWORK_STATE_CHANGE: |
| Intent intent = (Intent) msg.obj; |
| NetworkInfo networkInfo = (NetworkInfo) |
| intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); |
| |
| if (DBG) log("network state change " + networkInfo.getDetailedState()); |
| |
| switch (networkInfo.getDetailedState()) { |
| case VERIFYING_POOR_LINK: |
| mLinkProperties = (LinkProperties) intent.getParcelableExtra( |
| WifiManager.EXTRA_LINK_PROPERTIES); |
| mWifiInfo = (WifiInfo) intent.getParcelableExtra( |
| WifiManager.EXTRA_WIFI_INFO); |
| if (mPoorNetworkDetectionEnabled) { |
| if (mWifiInfo == null) { |
| log("Ignoring link verification, mWifiInfo is NULL"); |
| mWsmChannel.sendMessage(GOOD_LINK_DETECTED); |
| } else { |
| transitionTo(mVerifyingLinkState); |
| } |
| } else { |
| mWsmChannel.sendMessage(GOOD_LINK_DETECTED); |
| } |
| break; |
| case CONNECTED: |
| if (shouldCheckWalledGarden()) { |
| transitionTo(mWalledGardenCheckState); |
| } else { |
| transitionTo(mOnlineWatchState); |
| } |
| break; |
| default: |
| transitionTo(mNotConnectedState); |
| break; |
| } |
| break; |
| case EVENT_WIFI_RADIO_STATE_CHANGE: |
| if ((Integer) msg.obj == WifiManager.WIFI_STATE_DISABLING) { |
| if (DBG) log("WifiStateDisabling -- Resetting WatchdogState"); |
| transitionTo(mNotConnectedState); |
| } |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| |
| setWalledGardenNotificationVisible(false); |
| return HANDLED; |
| } |
| |
| @Override |
| public void exit() { |
| if (DBG) log("WifiWatchdogService disabled"); |
| } |
| } |
| |
| class NotConnectedState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| } |
| } |
| |
| class VerifyingLinkState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| //Treat entry as an rssi change |
| handleRssiChange(); |
| } |
| |
| private void handleRssiChange() { |
| if (mCurrentSignalLevel <= RSSI_LEVEL_MONITOR) { |
| //stay here |
| if (DBG) log("enter VerifyingLinkState, stay level: " + mCurrentSignalLevel); |
| } else { |
| if (DBG) log("enter VerifyingLinkState, arp check level: " + mCurrentSignalLevel); |
| sendMessage(obtainMessage(CMD_ARP_CHECK, ++mArpToken, 0)); |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_WATCHDOG_SETTINGS_CHANGE: |
| updateSettings(); |
| if (!mPoorNetworkDetectionEnabled) { |
| mWsmChannel.sendMessage(GOOD_LINK_DETECTED); |
| } |
| break; |
| case EVENT_RSSI_CHANGE: |
| mCurrentSignalLevel = calculateSignalLevel(msg.arg1); |
| handleRssiChange(); |
| break; |
| case CMD_ARP_CHECK: |
| if (msg.arg1 == mArpToken) { |
| if (doArpTest(FULL_ARP_CHECK) == true) { |
| if (DBG) log("Notify link is good " + mCurrentSignalLevel); |
| mWsmChannel.sendMessage(GOOD_LINK_DETECTED); |
| } else { |
| if (DBG) log("Continue ARP check, rssi level: " + mCurrentSignalLevel); |
| sendMessageDelayed(obtainMessage(CMD_ARP_CHECK, ++mArpToken, 0), |
| mArpCheckIntervalMs); |
| } |
| } |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class ConnectedState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| } |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_WATCHDOG_SETTINGS_CHANGE: |
| updateSettings(); |
| //STOPSHIP: Remove this at ship |
| DBG = true; |
| if (DBG) log("Updated secure settings and turned debug on"); |
| |
| if (mPoorNetworkDetectionEnabled) { |
| transitionTo(mOnlineWatchState); |
| } else { |
| transitionTo(mOnlineState); |
| } |
| return HANDLED; |
| } |
| return NOT_HANDLED; |
| } |
| } |
| |
| class WalledGardenCheckState extends State { |
| private int mWalledGardenToken = 0; |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| sendMessageDelayed(obtainMessage(CMD_DELAYED_WALLED_GARDEN_CHECK, |
| ++mWalledGardenToken, 0), WALLED_GARDEN_START_DELAY_MS); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case CMD_DELAYED_WALLED_GARDEN_CHECK: |
| if (msg.arg1 == mWalledGardenToken) { |
| mLastWalledGardenCheckTime = SystemClock.elapsedRealtime(); |
| if (isWalledGardenConnection()) { |
| if (DBG) log("Walled garden detected"); |
| setWalledGardenNotificationVisible(true); |
| } |
| transitionTo(mOnlineWatchState); |
| } |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class OnlineWatchState extends State { |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| if (mPoorNetworkDetectionEnabled) { |
| //Treat entry as an rssi change |
| handleRssiChange(); |
| } else { |
| transitionTo(mOnlineState); |
| } |
| } |
| |
| private void handleRssiChange() { |
| if (mCurrentSignalLevel <= RSSI_LEVEL_MONITOR) { |
| transitionTo(mRssiMonitoringState); |
| } else { |
| //stay here |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_RSSI_CHANGE: |
| mCurrentSignalLevel = calculateSignalLevel(msg.arg1); |
| //Ready to avoid bssid again ? |
| long time = android.os.SystemClock.elapsedRealtime(); |
| if (time - mLastBssidAvoidedTime > MIN_INTERVAL_AVOID_BSSID_MS[ |
| mMinIntervalArrayIndex]) { |
| handleRssiChange(); |
| } else { |
| if (DBG) log("Early to avoid " + mWifiInfo + " time: " + time + |
| " last avoided: " + mLastBssidAvoidedTime + |
| " mMinIntervalArrayIndex: " + mMinIntervalArrayIndex); |
| } |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| class RssiMonitoringState extends State { |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| sendMessage(obtainMessage(CMD_RSSI_FETCH, ++mRssiFetchToken, 0)); |
| } |
| |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_RSSI_CHANGE: |
| mCurrentSignalLevel = calculateSignalLevel(msg.arg1); |
| if (mCurrentSignalLevel <= RSSI_LEVEL_MONITOR) { |
| //stay here; |
| } else { |
| //We dont need frequent RSSI monitoring any more |
| transitionTo(mOnlineWatchState); |
| } |
| break; |
| case CMD_RSSI_FETCH: |
| if (msg.arg1 == mRssiFetchToken) { |
| mWsmChannel.sendMessage(RSSI_FETCH); |
| sendMessageDelayed(obtainMessage(CMD_RSSI_FETCH, ++mRssiFetchToken, 0), |
| mRssiFetchIntervalMs); |
| } |
| break; |
| case RSSI_FETCH_SUCCEEDED: |
| int rssi = msg.arg1; |
| if (DBG) log("RSSI_FETCH_SUCCEEDED: " + rssi); |
| if (msg.arg1 < RSSI_MONITOR_THRESHOLD) { |
| mRssiMonitorCount++; |
| } else { |
| mRssiMonitorCount = 0; |
| } |
| |
| if (mRssiMonitorCount > RSSI_MONITOR_COUNT) { |
| sendPoorLinkDetected(); |
| ++mRssiFetchToken; |
| } |
| break; |
| case RSSI_FETCH_FAILED: |
| //can happen if we are waiting to get a disconnect notification |
| if (DBG) log("RSSI_FETCH_FAILED"); |
| break; |
| default: |
| return NOT_HANDLED; |
| } |
| return HANDLED; |
| } |
| } |
| |
| /* Child state of ConnectedState indicating that we are online |
| * and there is nothing to do |
| */ |
| class OnlineState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log(getName() + "\n"); |
| } |
| } |
| |
| private boolean shouldCheckWalledGarden() { |
| if (!mWalledGardenTestEnabled) { |
| if (DBG) log("Skipping walled garden check - disabled"); |
| return false; |
| } |
| |
| long waitTime = (mWalledGardenIntervalMs + mLastWalledGardenCheckTime) |
| - SystemClock.elapsedRealtime(); |
| |
| if (mLastWalledGardenCheckTime != 0 && waitTime > 0) { |
| if (DBG) { |
| log("Skipping walled garden check - wait " + |
| waitTime + " ms."); |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| private boolean doArpTest(int type) { |
| boolean success; |
| |
| String iface = mLinkProperties.getInterfaceName(); |
| String mac = mWifiInfo.getMacAddress(); |
| InetAddress inetAddress = null; |
| InetAddress gateway = null; |
| |
| for (LinkAddress la : mLinkProperties.getLinkAddresses()) { |
| inetAddress = la.getAddress(); |
| break; |
| } |
| |
| for (RouteInfo route : mLinkProperties.getRoutes()) { |
| gateway = route.getGateway(); |
| break; |
| } |
| |
| if (DBG) log("ARP " + iface + "addr: " + inetAddress + "mac: " + mac + "gw: " + gateway); |
| |
| try { |
| ArpPeer peer = new ArpPeer(iface, inetAddress, mac, gateway); |
| if (type == SINGLE_ARP_CHECK) { |
| success = (peer.doArp(mArpPingTimeoutMs) != null); |
| if (DBG) log("single ARP test result: " + success); |
| } else { |
| int responses = 0; |
| for (int i=0; i < mNumArpPings; i++) { |
| if(peer.doArp(mArpPingTimeoutMs) != null) responses++; |
| } |
| if (DBG) log("full ARP test result: " + responses + "/" + mNumArpPings); |
| success = (responses >= mMinArpResponses); |
| } |
| peer.close(); |
| } catch (SocketException se) { |
| //Consider an Arp socket creation issue as a successful Arp |
| //test to avoid any wifi connectivity issues |
| loge("ARP test initiation failure: " + se); |
| success = true; |
| } |
| |
| return success; |
| } |
| |
| private int calculateSignalLevel(int rssi) { |
| int signalLevel = WifiManager.calculateSignalLevel(rssi, |
| WifiManager.RSSI_LEVELS); |
| if (DBG) log("RSSI current: " + mCurrentSignalLevel + "new: " + rssi + ", " + signalLevel); |
| return signalLevel; |
| } |
| |
| private void sendPoorLinkDetected() { |
| if (DBG) log("send POOR_LINK_DETECTED " + mWifiInfo); |
| mWsmChannel.sendMessage(POOR_LINK_DETECTED); |
| |
| long time = android.os.SystemClock.elapsedRealtime(); |
| if (time - mLastBssidAvoidedTime > MIN_INTERVAL_AVOID_BSSID_MS[ |
| MIN_INTERVAL_AVOID_BSSID_MS.length - 1]) { |
| mMinIntervalArrayIndex = 1; |
| if (DBG) log("set mMinIntervalArrayIndex to 1"); |
| } else { |
| |
| if (mMinIntervalArrayIndex < MIN_INTERVAL_AVOID_BSSID_MS.length - 1) { |
| mMinIntervalArrayIndex++; |
| } |
| if (DBG) log("mMinIntervalArrayIndex: " + mMinIntervalArrayIndex); |
| } |
| |
| mLastBssidAvoidedTime = android.os.SystemClock.elapsedRealtime(); |
| } |
| |
| /** |
| * 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 static void log(String s) { |
| Log.d(TAG, s); |
| } |
| |
| private static void loge(String s) { |
| Log.e(TAG, s); |
| } |
| } |
