import android.os.IBinder;
import android.os.INetworkManagementService;
import android.os.Message;
+import android.os.Messenger;
import android.os.PowerManager;
import android.os.Process;
import android.os.RemoteException;
private String mLastBssid;
private int mLastNetworkId;
private boolean mEnableRssiPolling = false;
+ private boolean mEnableBackgroundScan = false;
private int mRssiPollToken = 0;
private int mReconnectCount = 0;
private boolean mIsScanMode = false;
+ private boolean mScanResultIsPending = false;
private boolean mBluetoothConnectionActive = false;
static final int CMD_START_WPS = 89;
/* Set the frequency band */
static final int CMD_SET_FREQUENCY_BAND = 90;
+ /* Enable background scan for configured networks */
+ static final int CMD_ENABLE_BACKGROUND_SCAN = 91;
/* Commands from/to the SupplicantStateTracker */
/* Reset the supplicant state tracker */
sendMessage(obtainMessage(CMD_FORGET_NETWORK, netId, 0));
}
- public WpsResult startWps(AsyncChannel channel, WpsConfiguration config) {
- WpsResult result;
- switch (config.setup) {
- case PIN_FROM_DEVICE:
- case PBC:
- case PIN_FROM_ACCESS_POINT:
- //TODO: will go away with AsyncChannel use from settings
- Message resultMsg = channel.sendMessageSynchronously(CMD_START_WPS, config);
- result = (WpsResult) resultMsg.obj;
- resultMsg.recycle();
- break;
- default:
- result = new WpsResult(Status.FAILURE);
- break;
- }
- return result;
+ public void startWps(Messenger replyTo, WpsConfiguration config) {
+ Message msg = obtainMessage(CMD_START_WPS, config);
+ msg.replyTo = replyTo;
+ sendMessage(msg);
}
public void enableRssiPolling(boolean enabled) {
sendMessage(obtainMessage(CMD_ENABLE_RSSI_POLL, enabled ? 1 : 0, 0));
}
+ public void enableBackgroundScan(boolean enabled) {
+ sendMessage(obtainMessage(CMD_ENABLE_BACKGROUND_SCAN, enabled ? 1 : 0, 0));
+ }
+
public void enableAllNetworks() {
sendMessage(CMD_ENABLE_ALL_NETWORKS);
}
case CMD_ENABLE_RSSI_POLL:
mEnableRssiPolling = (message.arg1 == 1);
break;
+ case CMD_ENABLE_BACKGROUND_SCAN:
+ mEnableBackgroundScan = (message.arg1 == 1);
+ break;
/* Discard */
case CMD_LOAD_DRIVER:
case CMD_UNLOAD_DRIVER:
break;
case CMD_START_WPS:
/* Return failure when the state machine cannot handle WPS initiation*/
- mReplyChannel.replyToMessage(message, message.what,
+ mReplyChannel.replyToMessage(message, WifiManager.CMD_WPS_COMPLETED,
new WpsResult(Status.FAILURE));
break;
default:
eventLoggingEnabled = false;
setScanResults(WifiNative.scanResultsCommand());
sendScanResultsAvailableBroadcast();
+ mScanResultIsPending = false;
break;
case CMD_PING_SUPPLICANT:
boolean ok = WifiNative.pingCommand();
case CMD_START_SCAN:
eventLoggingEnabled = false;
WifiNative.scanCommand(message.arg1 == SCAN_ACTIVE);
+ mScanResultIsPending = true;
break;
case CMD_SET_HIGH_PERF_MODE:
setHighPerfModeEnabledNative(message.arg1 == 1);
* back to CONNECT_MODE.
*/
WifiNative.setScanResultHandlingCommand(SCAN_ONLY_MODE);
- WifiNative.scanCommand(message.arg1 == SCAN_ACTIVE);
- break;
+ /* Have the parent state handle the rest */
+ return NOT_HANDLED;
/* Ignore connection to same network */
case CMD_CONNECT_NETWORK:
int netId = message.arg1;
}
class DisconnectedState extends HierarchicalState {
+ private boolean mAlarmEnabled = false;
+ private long mScanIntervalMs;
+
+ private void setScanAlarm(boolean enabled) {
+ if (enabled == mAlarmEnabled) return;
+ if (enabled) {
+ mAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
+ System.currentTimeMillis() + mScanIntervalMs,
+ mScanIntervalMs,
+ mScanIntent);
+
+ mAlarmEnabled = true;
+ } else {
+ mAlarmManager.cancel(mScanIntent);
+ mAlarmEnabled = false;
+ }
+ }
+
@Override
public void enter() {
if (DBG) Log.d(TAG, getName() + "\n");
EventLog.writeEvent(EVENTLOG_WIFI_STATE_CHANGED, getName());
- /**
- * In a disconnected state, an infrequent scan that wakes
- * up the device is needed to ensure a user connects to
- * an access point on the move
- */
- long scanMs = Settings.Secure.getLong(mContext.getContentResolver(),
+ mScanIntervalMs = Settings.Secure.getLong(mContext.getContentResolver(),
Settings.Secure.WIFI_SCAN_INTERVAL_MS, DEFAULT_SCAN_INTERVAL_MS);
-
- mAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
- System.currentTimeMillis() + scanMs, scanMs, mScanIntent);
+ /*
+ * We initiate background scanning if it is enabled, otherwise we
+ * initiate an infrequent scan that wakes up the device to ensure
+ * a user connects to an access point on the move
+ */
+ if (mEnableBackgroundScan) {
+ /* If a regular scan result is pending, do not initiate background
+ * scan until the scan results are returned. This is needed because
+ * initiating a background scan will cancel the regular scan and
+ * scan results will not be returned until background scanning is
+ * cleared
+ */
+ if (!mScanResultIsPending) {
+ WifiNative.enableBackgroundScan(true);
+ }
+ } else {
+ setScanAlarm(true);
+ }
}
@Override
public boolean processMessage(Message message) {
transitionTo(mScanModeState);
}
break;
+ case CMD_ENABLE_BACKGROUND_SCAN:
+ mEnableBackgroundScan = (message.arg1 == 1);
+ if (mEnableBackgroundScan) {
+ WifiNative.enableBackgroundScan(true);
+ setScanAlarm(false);
+ } else {
+ WifiNative.enableBackgroundScan(false);
+ setScanAlarm(true);
+ }
+ break;
/* Ignore network disconnect */
case NETWORK_DISCONNECTION_EVENT:
break;
setNetworkDetailedState(WifiInfo.getDetailedStateOf(stateChangeResult.state));
/* DriverStartedState does the rest of the handling */
return NOT_HANDLED;
+ case CMD_START_SCAN:
+ /* Disable background scan temporarily during a regular scan */
+ if (mEnableBackgroundScan) {
+ WifiNative.enableBackgroundScan(false);
+ }
+ /* Handled in parent state */
+ return NOT_HANDLED;
+ case SCAN_RESULTS_EVENT:
+ /* Re-enable background scan when a pending scan result is received */
+ if (mEnableBackgroundScan && mScanResultIsPending) {
+ WifiNative.enableBackgroundScan(true);
+ }
+ /* Handled in parent state */
+ return NOT_HANDLED;
default:
return NOT_HANDLED;
}
@Override
public void exit() {
- mAlarmManager.cancel(mScanIntent);
+ /* No need for a background scan upon exit from a disconnected state */
+ if (mEnableBackgroundScan) {
+ WifiNative.enableBackgroundScan(false);
+ }
+ setScanAlarm(false);
}
}
OSDN Git Service
