/* * 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.content.BroadcastReceiver; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.database.ContentObserver; import android.net.ConnectivityManager; import android.net.LinkProperties; import android.net.NetworkInfo; import android.net.wifi.RssiPacketCountInfo; import android.os.Message; import android.os.SystemClock; import android.provider.Settings; import android.provider.Settings.Secure; import android.util.Log; import android.util.LruCache; 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.FileDescriptor; import java.io.PrintWriter; import java.text.DecimalFormat; /** * WifiWatchdogStateMachine monitors the connection to a WiFi network. When WiFi * 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 WiFi using packet loss ratio as * an indicator to decide if the link is good enough to switch to Wi-Fi as the * uplink. *

* When WiFi is connected, the WiFi watchdog keeps sampling the RSSI and the * instant packet loss, and record it as per-AP loss-to-rssi statistics. When * the instant packet loss is higher than a threshold, the WiFi watchdog sends a * poor link notification to avoid WiFi connection temporarily. *

* While WiFi is being avoided, the WiFi watchdog keep watching the RSSI to * bring the WiFi connection back. Once the RSSI is high enough to achieve a * lower packet loss, a good link detection is sent such that the WiFi * connection become available again. *

* BSSID roaming has been taken into account. When user is moving across * multiple APs, the WiFi watchdog will detect that and keep watching the * currently connected AP. *

* Power impact should be minimal since much of the measurement relies on * passive statistics already being tracked at the driver and the polling is * done when screen is turned on and the RSSI is in a certain range. * * @hide */ public class WifiWatchdogStateMachine extends StateMachine { private static final boolean DBG = false; private static final int BASE = Protocol.BASE_WIFI_WATCHDOG; /* Internal events */ private static final int EVENT_WATCHDOG_TOGGLED = BASE + 1; private static final int EVENT_NETWORK_STATE_CHANGE = BASE + 2; private static final int EVENT_RSSI_CHANGE = BASE + 3; private static final int EVENT_SUPPLICANT_STATE_CHANGE = 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 EVENT_BSSID_CHANGE = BASE + 7; private static final int EVENT_SCREEN_ON = BASE + 8; private static final int EVENT_SCREEN_OFF = BASE + 9; /* Internal messages */ private static final int CMD_RSSI_FETCH = BASE + 11; /* Notifications from/to WifiStateMachine */ static final int POOR_LINK_DETECTED = BASE + 21; static final int GOOD_LINK_DETECTED = BASE + 22; public static final boolean DEFAULT_POOR_NETWORK_AVOIDANCE_ENABLED = false; /* * 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 */ /** * WiFi link statistics is monitored and recorded actively below this threshold. *

* Larger threshold is more adaptive but increases sampling cost. */ private static final int LINK_MONITOR_LEVEL_THRESHOLD = WifiManager.RSSI_LEVELS - 1; /** * Remember packet loss statistics of how many BSSIDs. *

* Larger size is usually better but requires more space. */ private static final int BSSID_STAT_CACHE_SIZE = 20; /** * RSSI range of a BSSID statistics. * Within the range, (RSSI -> packet loss %) mappings are stored. *

* Larger range is usually better but requires more space. */ private static final int BSSID_STAT_RANGE_LOW_DBM = -105; /** * See {@link #BSSID_STAT_RANGE_LOW_DBM}. */ private static final int BSSID_STAT_RANGE_HIGH_DBM = -45; /** * How many consecutive empty data point to trigger a empty-cache detection. * In this case, a preset/default loss value (function on RSSI) is used. *

* In normal uses, some RSSI values may never be seen due to channel randomness. * However, the size of such empty RSSI chunk in normal use is generally 1~2. */ private static final int BSSID_STAT_EMPTY_COUNT = 3; /** * Sample interval for packet loss statistics, in msec. *

* Smaller interval is more accurate but increases sampling cost (battery consumption). */ private static final long LINK_SAMPLING_INTERVAL_MS = 1 * 1000; /** * Coefficients (alpha) for moving average for packet loss tracking. * Must be within (0.0, 1.0). *

* Equivalent number of samples: N = 2 / alpha - 1 . * We want the historic loss to base on more data points to be statistically reliable. * We want the current instant loss to base on less data points to be responsive. */ private static final double EXP_COEFFICIENT_RECORD = 0.1; /** * See {@link #EXP_COEFFICIENT_RECORD}. */ private static final double EXP_COEFFICIENT_MONITOR = 0.5; /** * Thresholds for sending good/poor link notifications, in packet loss %. * Good threshold must be smaller than poor threshold. * Use smaller poor threshold to avoid WiFi more aggressively. * Use smaller good threshold to bring back WiFi more conservatively. *

* When approaching the boundary, loss ratio jumps significantly within a few dBs. * 50% loss threshold is a good balance between accuracy and reponsiveness. * <=10% good threshold is a safe value to avoid jumping back to WiFi too easily. */ private static final double POOR_LINK_LOSS_THRESHOLD = 0.5; /** * See {@link #POOR_LINK_LOSS_THRESHOLD}. */ private static final double GOOD_LINK_LOSS_THRESHOLD = 0.1; /** * Number of samples to confirm before sending a poor link notification. * Response time = confirm_count * sample_interval . *

* A smaller threshold improves response speed but may suffer from randomness. * According to experiments, 3~5 are good values to achieve a balance. * These parameters should be tuned along with {@link #LINK_SAMPLING_INTERVAL_MS}. */ private static final int POOR_LINK_SAMPLE_COUNT = 3; /** * Minimum volume (converted from pkt/sec) to detect a poor link, to avoid randomness. *

* According to experiments, 1pkt/sec is too sensitive but 3pkt/sec is slightly unresponsive. */ private static final double POOR_LINK_MIN_VOLUME = 2.0 * LINK_SAMPLING_INTERVAL_MS / 1000.0; /** * When a poor link is detected, we scan over this range (based on current * poor link RSSI) for a target RSSI that satisfies a target packet loss. * Refer to {@link #GOOD_LINK_TARGET}. *

* We want range_min not too small to avoid jumping back to WiFi too easily. */ private static final int GOOD_LINK_RSSI_RANGE_MIN = 3; /** * See {@link #GOOD_LINK_RSSI_RANGE_MIN}. */ private static final int GOOD_LINK_RSSI_RANGE_MAX = 20; /** * Adaptive good link target to avoid flapping. * When a poor link is detected, a good link target is calculated as follows: *

* targetRSSI = min { rssi | loss(rssi) < GOOD_LINK_LOSS_THRESHOLD } + rssi_adj[i], * where rssi is within the above GOOD_LINK_RSSI_RANGE. * targetCount = sample_count[i] . *

* While WiFi is being avoided, we keep monitoring its signal strength. * Good link notification is sent when we see current RSSI >= targetRSSI * for targetCount consecutive times. *

* Index i is incremented each time after a poor link detection. * Index i is decreased to at most k if the last poor link was at lease reduce_time[k] ago. *

* Intuitively, larger index i makes it more difficult to get back to WiFi, avoiding flapping. * In experiments, (+9 dB / 30 counts) makes it quite difficult to achieve. * Avoid using it unless flapping is really bad (say, last poor link is < 1 min ago). */ private static final GoodLinkTarget[] GOOD_LINK_TARGET = { /* rssi_adj, sample_count, reduce_time */ new GoodLinkTarget( 0, 3, 30 * 60000 ), new GoodLinkTarget( 3, 5, 5 * 60000 ), new GoodLinkTarget( 6, 10, 1 * 60000 ), new GoodLinkTarget( 9, 30, 0 * 60000 ), }; /** * The max time to avoid a BSSID, to prevent avoiding forever. * If current RSSI is at least min_rssi[i], the max avoidance time is at most max_time[i] *

* It is unusual to experience high packet loss at high RSSI. Something unusual must be * happening (e.g. strong interference). For higher signal strengths, we set the avoidance * time to be low to allow for quick turn around from temporary interference. *

* See {@link BssidStatistics#poorLinkDetected}. */ private static final MaxAvoidTime[] MAX_AVOID_TIME = { /* max_time, min_rssi */ new MaxAvoidTime( 30 * 60000, -200 ), new MaxAvoidTime( 5 * 60000, -70 ), new MaxAvoidTime( 0 * 60000, -55 ), }; /* Framework related */ private Context mContext; private ContentResolver mContentResolver; private WifiManager mWifiManager; private IntentFilter mIntentFilter; private BroadcastReceiver mBroadcastReceiver; private AsyncChannel mWsmChannel = new AsyncChannel(); private WifiInfo mWifiInfo; private LinkProperties mLinkProperties; /* System settingss related */ private static boolean sWifiOnly = false; private boolean mPoorNetworkDetectionEnabled; /* Poor link detection related */ private LruCache mBssidCache = new LruCache(BSSID_STAT_CACHE_SIZE); private int mRssiFetchToken = 0; private int mCurrentSignalLevel; private BssidStatistics mCurrentBssid; private VolumeWeightedEMA mCurrentLoss; private boolean mIsScreenOn = true; private static double sPresetLoss[]; /* WiFi watchdog state machine related */ 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 OnlineWatchState mOnlineWatchState = new OnlineWatchState(); private LinkMonitoringState mLinkMonitoringState = new LinkMonitoringState(); private OnlineState mOnlineState = new OnlineState(); /** * STATE MAP * Default * / \ * Disabled Enabled * / \ \ * NotConnected Verifying Connected * /---------\ * (all other states) */ private WifiWatchdogStateMachine(Context context) { super("WifiWatchdogStateMachine"); 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(mOnlineWatchState, mConnectedState); addState(mLinkMonitoringState, mConnectedState); addState(mOnlineState, mConnectedState); if (isWatchdogEnabled()) { setInitialState(mNotConnectedState); } else { setInitialState(mWatchdogDisabledState); } setLogRecSize(25); setLogOnlyTransitions(true); 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 can be seperately turned on/off // TODO: Remove this setting & clean up state machine since we always have // watchdog in an enabled state putSettingsGlobalBoolean(contentResolver, Settings.Global.WIFI_WATCHDOG_ON, true); 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.RSSI_CHANGED_ACTION)) { obtainMessage(EVENT_RSSI_CHANGE, intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200), 0).sendToTarget(); } else if (action.equals(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)) { sendMessage(EVENT_SUPPLICANT_STATE_CHANGE, intent); } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) { sendMessage(EVENT_NETWORK_STATE_CHANGE, intent); } else if (action.equals(Intent.ACTION_SCREEN_ON)) { sendMessage(EVENT_SCREEN_ON); } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { sendMessage(EVENT_SCREEN_OFF); } 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.SUPPLICANT_STATE_CHANGED_ACTION); mIntentFilter.addAction(Intent.ACTION_SCREEN_ON); mIntentFilter.addAction(Intent.ACTION_SCREEN_OFF); 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.Global.getUriFor(Settings.Global.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.Global.getUriFor(Settings.Global.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED), false, contentObserver); } public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { super.dump(fd, pw, args); pw.println("mWifiInfo: [" + mWifiInfo + "]"); pw.println("mLinkProperties: [" + mLinkProperties + "]"); pw.println("mCurrentSignalLevel: [" + mCurrentSignalLevel + "]"); pw.println("mPoorNetworkDetectionEnabled: [" + mPoorNetworkDetectionEnabled + "]"); } private boolean isWatchdogEnabled() { boolean ret = getSettingsGlobalBoolean( mContentResolver, Settings.Global.WIFI_WATCHDOG_ON, true); if (DBG) logd("Watchdog enabled " + ret); return ret; } private void updateSettings() { if (DBG) logd("Updating secure settings"); // disable poor network avoidance if (sWifiOnly) { logd("Disabling poor network avoidance for wi-fi only device"); mPoorNetworkDetectionEnabled = false; } else { mPoorNetworkDetectionEnabled = getSettingsGlobalBoolean(mContentResolver, Settings.Global.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, DEFAULT_POOR_NETWORK_AVOIDANCE_ENABLED); } } /** * Default state, guard for unhandled messages. */ class DefaultState extends State { @Override public void enter() { if (DBG) logd(getName()); } @Override public boolean processMessage(Message msg) { switch (msg.what) { case EVENT_WATCHDOG_SETTINGS_CHANGE: updateSettings(); if (DBG) logd("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 EVENT_SUPPLICANT_STATE_CHANGE: case EVENT_BSSID_CHANGE: case CMD_RSSI_FETCH: case WifiManager.RSSI_PKTCNT_FETCH_SUCCEEDED: case WifiManager.RSSI_PKTCNT_FETCH_FAILED: // ignore break; case EVENT_SCREEN_ON: mIsScreenOn = true; break; case EVENT_SCREEN_OFF: mIsScreenOn = false; break; default: loge("Unhandled message " + msg + " in state " + getCurrentState().getName()); break; } return HANDLED; } } /** * WiFi watchdog is disabled by the setting. */ class WatchdogDisabledState extends State { @Override public void enter() { if (DBG) logd(getName()); } @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) logd("Watchdog disabled, verify link"); sendLinkStatusNotification(true); break; default: break; } break; } return NOT_HANDLED; } } /** * WiFi watchdog is enabled by the setting. */ class WatchdogEnabledState extends State { @Override public void enter() { if (DBG) logd(getName()); } @Override public boolean processMessage(Message msg) { Intent intent; switch (msg.what) { case EVENT_WATCHDOG_TOGGLED: if (!isWatchdogEnabled()) transitionTo(mWatchdogDisabledState); break; case EVENT_NETWORK_STATE_CHANGE: intent = (Intent) msg.obj; NetworkInfo networkInfo = (NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); if (DBG) logd("Network state change " + networkInfo.getDetailedState()); mWifiInfo = (WifiInfo) intent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO); updateCurrentBssid(mWifiInfo != null ? mWifiInfo.getBSSID() : null); switch (networkInfo.getDetailedState()) { case VERIFYING_POOR_LINK: mLinkProperties = (LinkProperties) intent.getParcelableExtra( WifiManager.EXTRA_LINK_PROPERTIES); if (mPoorNetworkDetectionEnabled) { if (mWifiInfo == null || mCurrentBssid == null) { loge("Ignore, wifiinfo " + mWifiInfo +" bssid " + mCurrentBssid); sendLinkStatusNotification(true); } else { transitionTo(mVerifyingLinkState); } } else { sendLinkStatusNotification(true); } break; case CONNECTED: transitionTo(mOnlineWatchState); break; default: transitionTo(mNotConnectedState); break; } break; case EVENT_SUPPLICANT_STATE_CHANGE: intent = (Intent) msg.obj; SupplicantState supplicantState = (SupplicantState) intent.getParcelableExtra( WifiManager.EXTRA_NEW_STATE); if (supplicantState == SupplicantState.COMPLETED) { mWifiInfo = mWifiManager.getConnectionInfo(); updateCurrentBssid(mWifiInfo.getBSSID()); } break; case EVENT_WIFI_RADIO_STATE_CHANGE: if (msg.arg1 == WifiManager.WIFI_STATE_DISABLING) { transitionTo(mNotConnectedState); } break; default: return NOT_HANDLED; } return HANDLED; } } /** * WiFi is disconnected. */ class NotConnectedState extends State { @Override public void enter() { if (DBG) logd(getName()); } } /** * WiFi is connected, but waiting for good link detection message. */ class VerifyingLinkState extends State { private int mSampleCount; @Override public void enter() { if (DBG) logd(getName()); mSampleCount = 0; mCurrentBssid.newLinkDetected(); sendMessage(obtainMessage(CMD_RSSI_FETCH, ++mRssiFetchToken, 0)); } @Override public boolean processMessage(Message msg) { switch (msg.what) { case EVENT_WATCHDOG_SETTINGS_CHANGE: updateSettings(); if (!mPoorNetworkDetectionEnabled) { sendLinkStatusNotification(true); } break; case EVENT_BSSID_CHANGE: transitionTo(mVerifyingLinkState); break; case CMD_RSSI_FETCH: if (msg.arg1 == mRssiFetchToken) { mWsmChannel.sendMessage(WifiManager.RSSI_PKTCNT_FETCH); sendMessageDelayed(obtainMessage(CMD_RSSI_FETCH, ++mRssiFetchToken, 0), LINK_SAMPLING_INTERVAL_MS); } break; case WifiManager.RSSI_PKTCNT_FETCH_SUCCEEDED: RssiPacketCountInfo info = (RssiPacketCountInfo) msg.obj; int rssi = info.rssi; if (DBG) logd("Fetch RSSI succeed, rssi=" + rssi); long time = mCurrentBssid.mBssidAvoidTimeMax - SystemClock.elapsedRealtime(); if (time <= 0) { // max avoidance time is met if (DBG) logd("Max avoid time elapsed"); sendLinkStatusNotification(true); } else { if (rssi >= mCurrentBssid.mGoodLinkTargetRssi) { if (++mSampleCount >= mCurrentBssid.mGoodLinkTargetCount) { // link is good again if (DBG) logd("Good link detected, rssi=" + rssi); mCurrentBssid.mBssidAvoidTimeMax = 0; sendLinkStatusNotification(true); } } else { mSampleCount = 0; if (DBG) logd("Link is still poor, time left=" + time); } } break; case WifiManager.RSSI_PKTCNT_FETCH_FAILED: if (DBG) logd("RSSI_FETCH_FAILED"); break; default: return NOT_HANDLED; } return HANDLED; } } /** * WiFi is connected and link is verified. */ class ConnectedState extends State { @Override public void enter() { if (DBG) logd(getName()); } @Override public boolean processMessage(Message msg) { switch (msg.what) { case EVENT_WATCHDOG_SETTINGS_CHANGE: updateSettings(); if (mPoorNetworkDetectionEnabled) { transitionTo(mOnlineWatchState); } else { transitionTo(mOnlineState); } return HANDLED; } return NOT_HANDLED; } } /** * RSSI is high enough and don't need link monitoring. */ class OnlineWatchState extends State { @Override public void enter() { if (DBG) logd(getName()); if (mPoorNetworkDetectionEnabled) { // treat entry as an rssi change handleRssiChange(); } else { transitionTo(mOnlineState); } } private void handleRssiChange() { if (mCurrentSignalLevel <= LINK_MONITOR_LEVEL_THRESHOLD && mCurrentBssid != null) { transitionTo(mLinkMonitoringState); } else { // stay here } } @Override public boolean processMessage(Message msg) { switch (msg.what) { case EVENT_RSSI_CHANGE: mCurrentSignalLevel = calculateSignalLevel(msg.arg1); handleRssiChange(); break; default: return NOT_HANDLED; } return HANDLED; } } /** * Keep sampling the link and monitor any poor link situation. */ class LinkMonitoringState extends State { private int mSampleCount; private int mLastRssi; private int mLastTxGood; private int mLastTxBad; @Override public void enter() { if (DBG) logd(getName()); mSampleCount = 0; mCurrentLoss = new VolumeWeightedEMA(EXP_COEFFICIENT_MONITOR); sendMessage(obtainMessage(CMD_RSSI_FETCH, ++mRssiFetchToken, 0)); } @Override public boolean processMessage(Message msg) { switch (msg.what) { case EVENT_RSSI_CHANGE: mCurrentSignalLevel = calculateSignalLevel(msg.arg1); if (mCurrentSignalLevel <= LINK_MONITOR_LEVEL_THRESHOLD) { // stay here; } else { // we don't need frequent RSSI monitoring any more transitionTo(mOnlineWatchState); } break; case EVENT_BSSID_CHANGE: transitionTo(mLinkMonitoringState); break; case CMD_RSSI_FETCH: if (!mIsScreenOn) { transitionTo(mOnlineState); } else if (msg.arg1 == mRssiFetchToken) { mWsmChannel.sendMessage(WifiManager.RSSI_PKTCNT_FETCH); sendMessageDelayed(obtainMessage(CMD_RSSI_FETCH, ++mRssiFetchToken, 0), LINK_SAMPLING_INTERVAL_MS); } break; case WifiManager.RSSI_PKTCNT_FETCH_SUCCEEDED: RssiPacketCountInfo info = (RssiPacketCountInfo) msg.obj; int rssi = info.rssi; int mrssi = (mLastRssi + rssi) / 2; int txbad = info.txbad; int txgood = info.txgood; if (DBG) logd("Fetch RSSI succeed, rssi=" + rssi + " mrssi=" + mrssi + " txbad=" + txbad + " txgood=" + txgood); // skip the first data point as we want incremental values long now = SystemClock.elapsedRealtime(); if (now - mCurrentBssid.mLastTimeSample < LINK_SAMPLING_INTERVAL_MS * 2) { // update packet loss statistics int dbad = txbad - mLastTxBad; int dgood = txgood - mLastTxGood; int dtotal = dbad + dgood; if (dtotal > 0) { // calculate packet loss in the last sampling interval double loss = ((double) dbad) / ((double) dtotal); mCurrentLoss.update(loss, dtotal); if (DBG) { DecimalFormat df = new DecimalFormat("#.##"); logd("Incremental loss=" + dbad + "/" + dtotal + " Current loss=" + df.format(mCurrentLoss.mValue * 100) + "% volume=" + df.format(mCurrentLoss.mVolume)); } mCurrentBssid.updateLoss(mrssi, loss, dtotal); // check for high packet loss and send poor link notification if (mCurrentLoss.mValue > POOR_LINK_LOSS_THRESHOLD && mCurrentLoss.mVolume > POOR_LINK_MIN_VOLUME) { if (++mSampleCount >= POOR_LINK_SAMPLE_COUNT) if (mCurrentBssid.poorLinkDetected(rssi)) { sendLinkStatusNotification(false); ++mRssiFetchToken; } } else { mSampleCount = 0; } } } mCurrentBssid.mLastTimeSample = now; mLastTxBad = txbad; mLastTxGood = txgood; mLastRssi = rssi; break; case WifiManager.RSSI_PKTCNT_FETCH_FAILED: // can happen if we are waiting to get a disconnect notification if (DBG) logd("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) logd(getName()); } @Override public boolean processMessage(Message msg) { switch (msg.what) { case EVENT_SCREEN_ON: mIsScreenOn = true; if (mPoorNetworkDetectionEnabled) transitionTo(mOnlineWatchState); break; default: return NOT_HANDLED; } return HANDLED; } } private void updateCurrentBssid(String bssid) { if (DBG) logd("Update current BSSID to " + (bssid != null ? bssid : "null")); // if currently not connected, then set current BSSID to null if (bssid == null) { if (mCurrentBssid == null) return; mCurrentBssid = null; if (DBG) logd("BSSID changed"); sendMessage(EVENT_BSSID_CHANGE); return; } // if it is already the current BSSID, then done if (mCurrentBssid != null && bssid.equals(mCurrentBssid.mBssid)) return; // search for the new BSSID in the cache, add to cache if not found mCurrentBssid = mBssidCache.get(bssid); if (mCurrentBssid == null) { mCurrentBssid = new BssidStatistics(bssid); mBssidCache.put(bssid, mCurrentBssid); } // send BSSID change notification if (DBG) logd("BSSID changed"); sendMessage(EVENT_BSSID_CHANGE); } private int calculateSignalLevel(int rssi) { int signalLevel = WifiManager.calculateSignalLevel(rssi, WifiManager.RSSI_LEVELS); if (DBG) logd("RSSI current: " + mCurrentSignalLevel + " new: " + rssi + ", " + signalLevel); return signalLevel; } private void sendLinkStatusNotification(boolean isGood) { if (DBG) logd("########################################"); if (isGood) { mWsmChannel.sendMessage(GOOD_LINK_DETECTED); if (mCurrentBssid != null) { mCurrentBssid.mLastTimeGood = SystemClock.elapsedRealtime(); } if (DBG) logd("Good link notification is sent"); } else { mWsmChannel.sendMessage(POOR_LINK_DETECTED); if (mCurrentBssid != null) { mCurrentBssid.mLastTimePoor = SystemClock.elapsedRealtime(); } logd("Poor link notification is sent"); } } /** * 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 getSettingsGlobalBoolean(ContentResolver cr, String name, boolean def) { return Settings.Global.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 putSettingsGlobalBoolean(ContentResolver cr, String name, boolean value) { return Settings.Global.putInt(cr, name, value ? 1 : 0); } /** * Bundle of good link count parameters */ private static class GoodLinkTarget { public final int RSSI_ADJ_DBM; public final int SAMPLE_COUNT; public final int REDUCE_TIME_MS; public GoodLinkTarget(int adj, int count, int time) { RSSI_ADJ_DBM = adj; SAMPLE_COUNT = count; REDUCE_TIME_MS = time; } } /** * Bundle of max avoidance time parameters */ private static class MaxAvoidTime { public final int TIME_MS; public final int MIN_RSSI_DBM; public MaxAvoidTime(int time, int rssi) { TIME_MS = time; MIN_RSSI_DBM = rssi; } } /** * Volume-weighted Exponential Moving Average (V-EMA) * - volume-weighted: each update has its own weight (number of packets) * - exponential: O(1) time and O(1) space for both update and query * - moving average: reflect most recent results and expire old ones */ private class VolumeWeightedEMA { private double mValue; private double mVolume; private double mProduct; private final double mAlpha; public VolumeWeightedEMA(double coefficient) { mValue = 0.0; mVolume = 0.0; mProduct = 0.0; mAlpha = coefficient; } public void update(double newValue, int newVolume) { if (newVolume <= 0) return; // core update formulas double newProduct = newValue * newVolume; mProduct = mAlpha * newProduct + (1 - mAlpha) * mProduct; mVolume = mAlpha * newVolume + (1 - mAlpha) * mVolume; mValue = mProduct / mVolume; } } /** * Record (RSSI -> pakce loss %) mappings of one BSSID */ private class BssidStatistics { /* MAC address of this BSSID */ private final String mBssid; /* RSSI -> packet loss % mappings */ private VolumeWeightedEMA[] mEntries; private int mRssiBase; private int mEntriesSize; /* Target to send good link notification, set when poor link is detected */ private int mGoodLinkTargetRssi; private int mGoodLinkTargetCount; /* Index of GOOD_LINK_TARGET array */ private int mGoodLinkTargetIndex; /* Timestamps of some last events */ private long mLastTimeSample; private long mLastTimeGood; private long mLastTimePoor; /* Max time to avoid this BSSID */ private long mBssidAvoidTimeMax; /** * Constructor * * @param bssid is the address of this BSSID */ public BssidStatistics(String bssid) { this.mBssid = bssid; mRssiBase = BSSID_STAT_RANGE_LOW_DBM; mEntriesSize = BSSID_STAT_RANGE_HIGH_DBM - BSSID_STAT_RANGE_LOW_DBM + 1; mEntries = new VolumeWeightedEMA[mEntriesSize]; for (int i = 0; i < mEntriesSize; i++) mEntries[i] = new VolumeWeightedEMA(EXP_COEFFICIENT_RECORD); } /** * Update this BSSID cache * * @param rssi is the RSSI * @param value is the new instant loss value at this RSSI * @param volume is the volume for this single update */ public void updateLoss(int rssi, double value, int volume) { if (volume <= 0) return; int index = rssi - mRssiBase; if (index < 0 || index >= mEntriesSize) return; mEntries[index].update(value, volume); if (DBG) { DecimalFormat df = new DecimalFormat("#.##"); logd("Cache updated: loss[" + rssi + "]=" + df.format(mEntries[index].mValue * 100) + "% volume=" + df.format(mEntries[index].mVolume)); } } /** * Get preset loss if the cache has insufficient data, observed from experiments. * * @param rssi is the input RSSI * @return preset loss of the given RSSI */ public double presetLoss(int rssi) { if (rssi <= -90) return 1.0; if (rssi > 0) return 0.0; if (sPresetLoss == null) { // pre-calculate all preset losses only once, then reuse them final int size = 90; sPresetLoss = new double[size]; for (int i = 0; i < size; i++) sPresetLoss[i] = 1.0 / Math.pow(90 - i, 1.5); } return sPresetLoss[-rssi]; } /** * A poor link is detected, calculate a target RSSI to bring WiFi back. * * @param rssi is the current RSSI * @return true iff the current BSSID should be avoided */ public boolean poorLinkDetected(int rssi) { if (DBG) logd("Poor link detected, rssi=" + rssi); long now = SystemClock.elapsedRealtime(); long lastGood = now - mLastTimeGood; long lastPoor = now - mLastTimePoor; // reduce the difficulty of good link target if last avoidance was long time ago while (mGoodLinkTargetIndex > 0 && lastPoor >= GOOD_LINK_TARGET[mGoodLinkTargetIndex - 1].REDUCE_TIME_MS) mGoodLinkTargetIndex--; mGoodLinkTargetCount = GOOD_LINK_TARGET[mGoodLinkTargetIndex].SAMPLE_COUNT; // scan for a target RSSI at which the link is good int from = rssi + GOOD_LINK_RSSI_RANGE_MIN; int to = rssi + GOOD_LINK_RSSI_RANGE_MAX; mGoodLinkTargetRssi = findRssiTarget(from, to, GOOD_LINK_LOSS_THRESHOLD); mGoodLinkTargetRssi += GOOD_LINK_TARGET[mGoodLinkTargetIndex].RSSI_ADJ_DBM; if (mGoodLinkTargetIndex < GOOD_LINK_TARGET.length - 1) mGoodLinkTargetIndex++; // calculate max avoidance time to prevent avoiding forever int p = 0, pmax = MAX_AVOID_TIME.length - 1; while (p < pmax && rssi >= MAX_AVOID_TIME[p + 1].MIN_RSSI_DBM) p++; long avoidMax = MAX_AVOID_TIME[p].TIME_MS; // don't avoid if max avoidance time is 0 (RSSI is super high) if (avoidMax <= 0) return false; // set max avoidance time, send poor link notification mBssidAvoidTimeMax = now + avoidMax; if (DBG) logd("goodRssi=" + mGoodLinkTargetRssi + " goodCount=" + mGoodLinkTargetCount + " lastGood=" + lastGood + " lastPoor=" + lastPoor + " avoidMax=" + avoidMax); return true; } /** * A new BSSID is connected, recalculate target RSSI threshold */ public void newLinkDetected() { // if this BSSID is currently being avoided, the reuse those values if (mBssidAvoidTimeMax > 0) { if (DBG) logd("Previous avoidance still in effect, rssi=" + mGoodLinkTargetRssi + " count=" + mGoodLinkTargetCount); return; } // calculate a new RSSI threshold for new link verifying int from = BSSID_STAT_RANGE_LOW_DBM; int to = BSSID_STAT_RANGE_HIGH_DBM; mGoodLinkTargetRssi = findRssiTarget(from, to, GOOD_LINK_LOSS_THRESHOLD); mGoodLinkTargetCount = 1; mBssidAvoidTimeMax = SystemClock.elapsedRealtime() + MAX_AVOID_TIME[0].TIME_MS; if (DBG) logd("New link verifying target set, rssi=" + mGoodLinkTargetRssi + " count=" + mGoodLinkTargetCount); } /** * Return the first RSSI within the range where loss[rssi] < threshold * * @param from start scanning from this RSSI * @param to stop scanning at this RSSI * @param threshold target threshold for scanning * @return target RSSI */ public int findRssiTarget(int from, int to, double threshold) { from -= mRssiBase; to -= mRssiBase; int emptyCount = 0; int d = from < to ? 1 : -1; for (int i = from; i != to; i += d) // don't use a data point if it volume is too small (statistically unreliable) if (i >= 0 && i < mEntriesSize && mEntries[i].mVolume > 1.0) { emptyCount = 0; if (mEntries[i].mValue < threshold) { // scan target found int rssi = mRssiBase + i; if (DBG) { DecimalFormat df = new DecimalFormat("#.##"); logd("Scan target found: rssi=" + rssi + " threshold=" + df.format(threshold * 100) + "% value=" + df.format(mEntries[i].mValue * 100) + "% volume=" + df.format(mEntries[i].mVolume)); } return rssi; } } else if (++emptyCount >= BSSID_STAT_EMPTY_COUNT) { // cache has insufficient data around this RSSI, use preset loss instead int rssi = mRssiBase + i; double lossPreset = presetLoss(rssi); if (lossPreset < threshold) { if (DBG) { DecimalFormat df = new DecimalFormat("#.##"); logd("Scan target found: rssi=" + rssi + " threshold=" + df.format(threshold * 100) + "% value=" + df.format(lossPreset * 100) + "% volume=preset"); } return rssi; } } return mRssiBase + to; } } }