WifiController: softap mode untethered

Remove SoftAp mode from the state machine in WifiController.  In doing
so, also utilize the WSMP shutdownWifi call to disable all active mode
managers in airplane and emergency modes. This also fixes a few
updates from Client mode as it exits and moves them to the default
state.

Bug: 31346104
Test: frameworks/opt/net/wifi/tests/wifitests/runtests.sh
Test: manually toggled between modes on multiple devices
Test: wifi integration tests
Test: android.net.wifi.cts
Change-Id: I9fb0a47a46e87a923ed82c65ce42d705209414fb

5 files changed, 174 insertions, 173 deletions

diff --git a/service/java/com/android/server/wifi/ClientModeManager.java b/service/java/com/android/server/wifi/ClientModeManager.java
index f45623663..8aecd1ebd 100644
--- a/service/java/com/android/server/wifi/ClientModeManager.java
+++ b/service/java/com/android/server/wifi/ClientModeManager.java
@@ -189,6 +189,8 @@ public class ClientModeManager implements ActiveModeManager {
                             break;
                         }
                         sendScanAvailableBroadcast(false);
+                        mScanRequestProxy.enableScanningForHiddenNetworks(false);
+                        mScanRequestProxy.clearScanResults();
                         transitionTo(mStartedState);
                         break;
                     default:
@@ -258,6 +260,7 @@ public class ClientModeManager implements ActiveModeManager {
 
                         updateWifiState(WifiManager.WIFI_STATE_DISABLING,
                                         WifiManager.WIFI_STATE_ENABLED);
+                        mClientInterfaceName = null;
                         transitionTo(mIdleState);
                         break;
                     default:
@@ -267,24 +270,20 @@ public class ClientModeManager implements ActiveModeManager {
             }
 
             /**
-             * Clean up state, unregister listeners and send broadcast to tell WifiScanner
-             * that wifi is disabled.
+             * Clean up state, unregister listeners and update wifi state.
              */
             @Override
             public void exit() {
-                if (mClientInterfaceName == null) {
-                    return;
-                }
                 mWifiStateMachine.setOperationalMode(WifiStateMachine.DISABLED_MODE, null);
-                mWifiNative.teardownInterface(mClientInterfaceName);
-                // let WifiScanner know that wifi is down.
-                sendScanAvailableBroadcast(false);
+
+                if (mClientInterfaceName != null) {
+                    mWifiNative.teardownInterface(mClientInterfaceName);
+                    mClientInterfaceName = null;
+                    mIfaceIsUp = false;
+                }
+
                 updateWifiState(WifiManager.WIFI_STATE_DISABLED,
                                 WifiManager.WIFI_STATE_DISABLING);
-                mScanRequestProxy.enableScanningForHiddenNetworks(false);
-                mScanRequestProxy.clearScanResults();
-                mClientInterfaceName = null;
-                mIfaceIsUp = false;
             }
         }
 
diff --git a/service/java/com/android/server/wifi/ScanOnlyModeManager.java b/service/java/com/android/server/wifi/ScanOnlyModeManager.java
index ed08a20a4..985d025db 100644
--- a/service/java/com/android/server/wifi/ScanOnlyModeManager.java
+++ b/service/java/com/android/server/wifi/ScanOnlyModeManager.java
@@ -161,8 +161,13 @@ public class ScanOnlyModeManager implements ActiveModeManager {
                             break;
                         }
                         // we have a new scanning interface, make sure scanner knows we aren't
-                        // ready yet
+                        // ready yet and clear out the ScanRequestProxy
                         sendScanAvailableBroadcast(false);
+                        // explicitly disable scanning for hidden networks in case we were
+                        // previously in client mode
+                        mScanRequestProxy.enableScanningForHiddenNetworks(false);
+                        mScanRequestProxy.clearScanResults();
+
                         transitionTo(mStartedState);
                         break;
                     default:
@@ -228,19 +233,16 @@ public class ScanOnlyModeManager implements ActiveModeManager {
             }
 
             /**
-             * Clean up state, unregister listeners and send broadcast to tell WifiScanner
-             * that wifi is disabled.
+             * Clean up state and unregister listeners.
              */
             @Override
             public void exit() {
                 mWakeupController.stop();
-                if (mClientInterfaceName == null) {
-                    return;
+                if (mClientInterfaceName != null) {
+                    mWifiNative.teardownInterface(mClientInterfaceName);
+                    mClientInterfaceName = null;
                 }
-                mWifiNative.teardownInterface(mClientInterfaceName);
-                mClientInterfaceName = null;
                 updateWifiState(WifiManager.WIFI_STATE_DISABLED);
-                mScanRequestProxy.clearScanResults();
             }
         }
     }
diff --git a/service/java/com/android/server/wifi/WifiController.java b/service/java/com/android/server/wifi/WifiController.java
index 7fb223535..05ce47300 100644
--- a/service/java/com/android/server/wifi/WifiController.java
+++ b/service/java/com/android/server/wifi/WifiController.java
@@ -99,9 +99,8 @@ public class WifiController extends StateMachine {
 
     private DefaultState mDefaultState = new DefaultState();
     private StaEnabledState mStaEnabledState = new StaEnabledState();
-    private ApStaDisabledState mApStaDisabledState = new ApStaDisabledState();
+    private StaDisabledState mStaDisabledState = new StaDisabledState();
     private StaDisabledWithScanState mStaDisabledWithScanState = new StaDisabledWithScanState();
-    private ApEnabledState mApEnabledState = new ApEnabledState();
     private DeviceActiveState mDeviceActiveState = new DeviceActiveState();
     private EcmState mEcmState = new EcmState();
 
@@ -121,11 +120,10 @@ public class WifiController extends StateMachine {
 
         // CHECKSTYLE:OFF IndentationCheck
         addState(mDefaultState);
-            addState(mApStaDisabledState, mDefaultState);
+            addState(mStaDisabledState, mDefaultState);
             addState(mStaEnabledState, mDefaultState);
                 addState(mDeviceActiveState, mStaEnabledState);
             addState(mStaDisabledWithScanState, mDefaultState);
-            addState(mApEnabledState, mDefaultState);
             addState(mEcmState, mDefaultState);
         // CHECKSTYLE:ON IndentationCheck
 
@@ -144,7 +142,7 @@ public class WifiController extends StateMachine {
         if (checkScanOnlyModeAvailable()) {
             setInitialState(mStaDisabledWithScanState);
         } else {
-            setInitialState(mApStaDisabledState);
+            setInitialState(mStaDisabledState);
         }
 
         setLogRecSize(100);
@@ -254,25 +252,23 @@ public class WifiController extends StateMachine {
         @Override
         public boolean processMessage(Message msg) {
             switch (msg.what) {
-                case CMD_SET_AP:
                 case CMD_SCAN_ALWAYS_MODE_CHANGED:
                 case CMD_WIFI_TOGGLED:
-                case CMD_AIRPLANE_TOGGLED:
-                case CMD_EMERGENCY_MODE_CHANGED:
-                case CMD_EMERGENCY_CALL_STATE_CHANGED:
                 case CMD_AP_START_FAILURE:
-                case CMD_AP_STOPPED:
                 case CMD_SCANNING_STOPPED:
                 case CMD_STA_STOPPED:
                 case CMD_STA_START_FAILURE:
                 case CMD_RECOVERY_RESTART_WIFI_CONTINUE:
+                    break;
                 case CMD_RECOVERY_DISABLE_WIFI:
+                    log("Recovery has been throttled, disable wifi");
+                    mWifiStateMachinePrime.shutdownWifi();
+                    transitionTo(mStaDisabledState);
                     break;
                 case CMD_RECOVERY_RESTART_WIFI:
-                    // TODO:b/72850700 : when softap is split out, we need to fully disable wifi
-                    // here (like airplane mode toggle).
                     deferMessage(obtainMessage(CMD_RECOVERY_RESTART_WIFI_CONTINUE));
-                    transitionTo(mApStaDisabledState);
+                    mWifiStateMachinePrime.shutdownWifi();
+                    transitionTo(mStaDisabledState);
                     break;
                 case CMD_USER_PRESENT:
                     mFirstUserSignOnSeen = true;
@@ -280,6 +276,55 @@ public class WifiController extends StateMachine {
                 case CMD_DEFERRED_TOGGLE:
                     log("DEFERRED_TOGGLE ignored due to state change");
                     break;
+                case CMD_SET_AP:
+                    // note: CMD_SET_AP is handled/dropped in ECM mode - will not start here
+
+                    // first make sure we aren't in airplane mode
+                    if (mSettingsStore.isAirplaneModeOn()) {
+                        log("drop softap requests when in airplane mode");
+                        break;
+                    }
+                    if (msg.arg1 == 1) {
+                        SoftApModeConfiguration config = (SoftApModeConfiguration) msg.obj;
+                        mWifiStateMachinePrime.enterSoftAPMode((SoftApModeConfiguration) msg.obj);
+                    } else {
+                        mWifiStateMachinePrime.stopSoftAPMode();
+                    }
+                    break;
+                case CMD_AIRPLANE_TOGGLED:
+                    if (mSettingsStore.isAirplaneModeOn()) {
+                        log("Airplane mode toggled, shutdown all modes");
+                        mWifiStateMachinePrime.shutdownWifi();
+                        transitionTo(mStaDisabledState);
+                    } else {
+                        log("Airplane mode disabled, determine next state");
+                        if (mSettingsStore.isWifiToggleEnabled()) {
+                            transitionTo(mDeviceActiveState);
+                        } else if (checkScanOnlyModeAvailable()) {
+                            transitionTo(mStaDisabledWithScanState);
+                        }
+                        // wifi should remain disabled, do not need to transition
+                    }
+                    break;
+                case CMD_EMERGENCY_CALL_STATE_CHANGED:
+                case CMD_EMERGENCY_MODE_CHANGED:
+                    boolean configWiFiDisableInECBM =
+                            mFacade.getConfigWiFiDisableInECBM(mContext);
+                    log("WifiController msg " + msg + " getConfigWiFiDisableInECBM "
+                            + configWiFiDisableInECBM);
+                    if ((msg.arg1 == 1) && configWiFiDisableInECBM) {
+                        transitionTo(mEcmState);
+                    }
+                    break;
+                case CMD_AP_STOPPED:
+                    log("SoftAp mode disabled, determine next state");
+                    if (mSettingsStore.isWifiToggleEnabled()) {
+                        transitionTo(mDeviceActiveState);
+                    } else if (checkScanOnlyModeAvailable()) {
+                        transitionTo(mStaDisabledWithScanState);
+                    }
+                    // wifi should remain disabled, do not need to transition
+                    break;
                 default:
                     throw new RuntimeException("WifiController.handleMessage " + msg.what);
             }
@@ -288,7 +333,7 @@ public class WifiController extends StateMachine {
 
     }
 
-    class ApStaDisabledState extends State {
+    class StaDisabledState extends State {
         private int mDeferredEnableSerialNumber = 0;
         private boolean mHaveDeferredEnable = false;
         private long mDisabledTimestamp;
@@ -306,11 +351,10 @@ public class WifiController extends StateMachine {
         public boolean processMessage(Message msg) {
             switch (msg.what) {
                 case CMD_WIFI_TOGGLED:
-                case CMD_AIRPLANE_TOGGLED:
                     if (mSettingsStore.isWifiToggleEnabled()) {
                         if (doDeferEnable(msg)) {
                             if (mHaveDeferredEnable) {
-                                //  have 2 toggles now, inc serial number an ignore both
+                                //  have 2 toggles now, inc serial number and ignore both
                                 mDeferredEnableSerialNumber++;
                             }
                             mHaveDeferredEnable = !mHaveDeferredEnable;
@@ -318,7 +362,10 @@ public class WifiController extends StateMachine {
                         }
                         transitionTo(mDeviceActiveState);
                     } else if (checkScanOnlyModeAvailable()) {
-                        transitionTo(mStaDisabledWithScanState);
+                        // only go to scan mode if we aren't in airplane mode
+                        if (mSettingsStore.isAirplaneModeOn()) {
+                            transitionTo(mStaDisabledWithScanState);
+                        }
                     }
                     break;
                 case CMD_SCAN_ALWAYS_MODE_CHANGED:
@@ -334,13 +381,10 @@ public class WifiController extends StateMachine {
                         break;
                     }
                     if (msg.arg1 == 1) {
-                        if (msg.arg2 == 0) { // previous wifi state has not been saved yet
-                            mSettingsStore.setWifiSavedState(WifiSettingsStore.WIFI_DISABLED);
-                        }
-                        mWifiStateMachinePrime.enterSoftAPMode((SoftApModeConfiguration) msg.obj);
-                        transitionTo(mApEnabledState);
+                        // remember that we were disabled, but pass the command up to start softap
+                        mSettingsStore.setWifiSavedState(WifiSettingsStore.WIFI_DISABLED);
                     }
-                    break;
+                    return NOT_HANDLED;
                 case CMD_DEFERRED_TOGGLE:
                     if (msg.arg1 != mDeferredEnableSerialNumber) {
                         log("DEFERRED_TOGGLE ignored due to serial mismatch");
@@ -399,45 +443,40 @@ public class WifiController extends StateMachine {
                         if (checkScanOnlyModeAvailable()) {
                             transitionTo(mStaDisabledWithScanState);
                         } else {
-                            transitionTo(mApStaDisabledState);
+                            transitionTo(mStaDisabledState);
                         }
                     }
                     break;
                 case CMD_AIRPLANE_TOGGLED:
-                    /* When wi-fi is turned off due to airplane,
-                    * disable entirely (including scan)
-                    */
-                    if (! mSettingsStore.isWifiToggleEnabled()) {
-                        transitionTo(mApStaDisabledState);
+                    // airplane mode toggled on is handled in the default state
+                    if (mSettingsStore.isAirplaneModeOn()) {
+                        return NOT_HANDLED;
+                    } else {
+                        // when airplane mode is toggled off, but wifi is on, we can keep it on
+                        log("airplane mode toggled - and airplane mode is off.  return handled");
+                        return HANDLED;
                     }
-                    break;
                 case CMD_STA_START_FAILURE:
                     if (!checkScanOnlyModeAvailable()) {
-                        transitionTo(mApStaDisabledState);
+                        transitionTo(mStaDisabledState);
                     } else {
                         transitionTo(mStaDisabledWithScanState);
                     }
                     break;
-                case CMD_EMERGENCY_CALL_STATE_CHANGED:
-                case CMD_EMERGENCY_MODE_CHANGED:
-                    boolean getConfigWiFiDisableInECBM = mFacade.getConfigWiFiDisableInECBM(mContext);
-                    log("WifiController msg " + msg + " getConfigWiFiDisableInECBM "
-                            + getConfigWiFiDisableInECBM);
-                    if ((msg.arg1 == 1) && getConfigWiFiDisableInECBM) {
-                        transitionTo(mEcmState);
-                    }
-                    break;
                 case CMD_SET_AP:
                     if (msg.arg1 == 1) {
-                        // remember that we were enabled
+                        // remember that we were enabled, but pass the command up to start softap
                         mSettingsStore.setWifiSavedState(WifiSettingsStore.WIFI_ENABLED);
-                        // since softap is not split out in WifiController, need to explicitly
-                        // disable client and scan modes
-                        mWifiStateMachinePrime.disableWifi();
-
-                        mWifiStateMachinePrime.enterSoftAPMode((SoftApModeConfiguration) msg.obj);
-                        transitionTo(mApEnabledState);
                     }
+                    return NOT_HANDLED;
+                case CMD_AP_START_FAILURE:
+                case CMD_AP_STOPPED:
+                    // already in a wifi mode, no need to check where we should go with softap
+                    // stopped
+                    break;
+                case CMD_STA_STOPPED:
+                    // Client mode stopped.  head to Disabled to wait for next command
+                    transitionTo(mStaDisabledState);
                     break;
                 default:
                     return NOT_HANDLED;
@@ -480,30 +519,18 @@ public class WifiController extends StateMachine {
                         transitionTo(mDeviceActiveState);
                     }
                     break;
-                case CMD_AIRPLANE_TOGGLED:
-                    if (mSettingsStore.isAirplaneModeOn() &&
-                            ! mSettingsStore.isWifiToggleEnabled()) {
-                        transitionTo(mApStaDisabledState);
-                    }
-                    break;
                 case CMD_SCAN_ALWAYS_MODE_CHANGED:
                     if (!checkScanOnlyModeAvailable()) {
                         log("StaDisabledWithScanState: scan no longer available");
-                        transitionTo(mApStaDisabledState);
+                        transitionTo(mStaDisabledState);
                     }
                     break;
                 case CMD_SET_AP:
-                    // Before starting tethering, turn off supplicant for scan mode
                     if (msg.arg1 == 1) {
+                        // remember that we were disabled, but pass the command up to start softap
                         mSettingsStore.setWifiSavedState(WifiSettingsStore.WIFI_DISABLED);
-                        // since softap is not split out in WifiController, need to explicitly
-                        // disable client and scan modes
-                        mWifiStateMachinePrime.disableWifi();
-
-                        mWifiStateMachinePrime.enterSoftAPMode((SoftApModeConfiguration) msg.obj);
-                        transitionTo(mApEnabledState);
                     }
-                    break;
+                    return NOT_HANDLED;
                 case CMD_DEFERRED_TOGGLE:
                     if (msg.arg1 != mDeferredEnableSerialNumber) {
                         log("DEFERRED_TOGGLE ignored due to serial mismatch");
@@ -512,6 +539,16 @@ public class WifiController extends StateMachine {
                     logd("DEFERRED_TOGGLE handled");
                     sendMessage((Message)(msg.obj));
                     break;
+                case CMD_AP_START_FAILURE:
+                case CMD_AP_STOPPED:
+                    // already in a wifi mode, no need to check where we should go with softap
+                    // stopped
+                    break;
+                case CMD_SCANNING_STOPPED:
+                    // stopped due to interface destruction - return to disabled and wait
+                    log("WifiController: SCANNING_STOPPED when in scan mode -> StaDisabled");
+                    transitionTo(mStaDisabledState);
+                    break;
                 default:
                     return NOT_HANDLED;
             }
@@ -538,88 +575,19 @@ public class WifiController extends StateMachine {
     }
 
     /**
-     * Only transition out of this state when AP failed to start or AP is stopped.
+     * Determine the next state based on the current settings (e.g. saved
+     * wifi state).
      */
-    class ApEnabledState extends State {
-        /**
-         * Save the pending state when stopping the AP, so that it will transition
-         * to the correct state when AP is stopped.  This is to avoid a possible
-         * race condition where the new state might try to update the driver/interface
-         * state before AP is completely torn down.
-         */
-        private State mPendingState = null;
-
-        /**
-         * Determine the next state based on the current settings (e.g. saved
-         * wifi state).
-         */
-        private State getNextWifiState() {
-            if (mSettingsStore.getWifiSavedState() == WifiSettingsStore.WIFI_ENABLED) {
-                return mDeviceActiveState;
-            }
-
-            if (checkScanOnlyModeAvailable()) {
-                return mStaDisabledWithScanState;
-            }
-
-            return mApStaDisabledState;
+    private State getNextWifiState() {
+        if (mSettingsStore.getWifiSavedState() == WifiSettingsStore.WIFI_ENABLED) {
+            return mDeviceActiveState;
         }
 
-        @Override
-        public void exit() {
-            mWifiStateMachinePrime.stopSoftAPMode();
+        if (checkScanOnlyModeAvailable()) {
+            return mStaDisabledWithScanState;
         }
 
-        @Override
-        public boolean processMessage(Message msg) {
-            switch (msg.what) {
-                case CMD_AIRPLANE_TOGGLED:
-                    if (mSettingsStore.isAirplaneModeOn()) {
-                        transitionTo(mApStaDisabledState);
-                    }
-                    break;
-                case CMD_WIFI_TOGGLED:
-                    if (mSettingsStore.isWifiToggleEnabled()) {
-                        transitionTo(mDeviceActiveState);
-                    }
-                    break;
-                case CMD_SET_AP:
-                    if (msg.arg1 == 0) {
-                        transitionTo(getNextWifiState());
-                    }
-                    break;
-                case CMD_AP_STOPPED:
-                    if (mPendingState == null) {
-                        /**
-                         * Stop triggered internally, either tether notification
-                         * timed out or wifi is untethered for some reason.
-                         */
-                        mPendingState = getNextWifiState();
-                    }
-                    transitionTo(mPendingState);
-                    break;
-                case CMD_EMERGENCY_CALL_STATE_CHANGED:
-                case CMD_EMERGENCY_MODE_CHANGED:
-                    if (msg.arg1 == 1) {
-                        transitionTo(mEcmState);
-                    }
-                    break;
-                case CMD_AP_START_FAILURE:
-                    transitionTo(getNextWifiState());
-                    break;
-                case CMD_RECOVERY_RESTART_WIFI:
-                case CMD_RECOVERY_DISABLE_WIFI:
-                    // note: this will need to fully shutdown wifi when softap mode is removed from
-                    // the state machine
-                    loge("Recovery triggered while in softap active, disable");
-                    mWifiStateMachinePrime.disableWifi();
-                    transitionTo(getNextWifiState());
-                    break;
-                default:
-                    return NOT_HANDLED;
-            }
-            return HANDLED;
-        }
+        return mStaDisabledState;
     }
 
     class EcmState extends State {
@@ -630,11 +598,16 @@ public class WifiController extends StateMachine {
         private int mEcmEntryCount;
         @Override
         public void enter() {
-            mWifiStateMachinePrime.disableWifi();
+            mWifiStateMachinePrime.shutdownWifi();
             mWifiStateMachine.clearANQPCache();
             mEcmEntryCount = 1;
         }
 
+        /**
+         * Hanles messages received while in EcmMode.
+         *
+         * TODO (b/78244565): move from many ifs to a switch
+         */
         @Override
         public boolean processMessage(Message msg) {
             if (msg.what == CMD_EMERGENCY_CALL_STATE_CHANGED) {
@@ -660,6 +633,13 @@ public class WifiController extends StateMachine {
                     || msg.what == CMD_RECOVERY_DISABLE_WIFI) {
                 // do not want to restart wifi if we are in emergency mode
                 return HANDLED;
+            } else if (msg.what == CMD_AP_STOPPED || msg.what == CMD_SCANNING_STOPPED
+                    || msg.what == CMD_STA_STOPPED) {
+                // do not want to trigger a mode switch if we are in emergency mode
+                return HANDLED;
+            } else if (msg.what == CMD_SET_AP) {
+                // do not want to start softap if we are in emergency mode
+                return HANDLED;
             } else {
                 return NOT_HANDLED;
             }
@@ -681,13 +661,17 @@ public class WifiController extends StateMachine {
                 } else if (checkScanOnlyModeAvailable()) {
                     transitionTo(mStaDisabledWithScanState);
                 } else {
-                    transitionTo(mApStaDisabledState);
+                    transitionTo(mStaDisabledState);
                 }
             }
         }
     }
 
-    /* Parent: StaEnabledState */
+    /**
+     * Parent: StaEnabledState
+     *
+     * TODO (b/79209870): merge DeviceActiveState and StaEnabledState into a single state
+     */
     class DeviceActiveState extends State {
         @Override
         public void enter() {
@@ -721,12 +705,7 @@ public class WifiController extends StateMachine {
                         mWifiStateMachine.takeBugReport(bugTitle, bugDetail);
                     });
                 }
-                deferMessage(obtainMessage(CMD_RECOVERY_RESTART_WIFI_CONTINUE));
-                transitionTo(mApStaDisabledState);
-                return HANDLED;
-            } else if (msg.what == CMD_RECOVERY_DISABLE_WIFI) {
-                loge("Recovery has been throttled, disable wifi");
-                transitionTo(mApStaDisabledState);
+                return NOT_HANDLED;
             }
             return NOT_HANDLED;
         }
diff --git a/service/java/com/android/server/wifi/WifiServiceImpl.java b/service/java/com/android/server/wifi/WifiServiceImpl.java
index 04be38daa..eb1746e87 100644
--- a/service/java/com/android/server/wifi/WifiServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiServiceImpl.java
@@ -825,7 +825,7 @@ public class WifiServiceImpl extends IWifiManager.Stub {
         }
 
         // If SoftAp is enabled, only Settings is allowed to toggle wifi
-        boolean apEnabled = mWifiApState != WifiManager.WIFI_AP_STATE_DISABLED;
+        boolean apEnabled = mWifiApState == WifiManager.WIFI_AP_STATE_ENABLED;
 
         if (apEnabled && !isFromSettings) {
             mLog.info("setWifiEnabled SoftAp not disabled: only Settings can enable wifi").flush();
@@ -1006,7 +1006,6 @@ public class WifiServiceImpl extends IWifiManager.Stub {
             if (!mLocalOnlyHotspotRequests.isEmpty()) {
                 stopSoftApInternal();
             }
-
             return startSoftApInternal(wifiConfig, WifiManager.IFACE_IP_MODE_TETHERED);
         }
     }
diff --git a/service/java/com/android/server/wifi/WifiStateMachinePrime.java b/service/java/com/android/server/wifi/WifiStateMachinePrime.java
index fea191614..aea9e3819 100644
--- a/service/java/com/android/server/wifi/WifiStateMachinePrime.java
+++ b/service/java/com/android/server/wifi/WifiStateMachinePrime.java
@@ -58,6 +58,7 @@ public class WifiStateMachinePrime {
     private final IBatteryStats mBatteryStats;
     private final SelfRecovery mSelfRecovery;
     private BaseWifiDiagnostics mWifiDiagnostics;
+    private final ScanRequestProxy mScanRequestProxy;
 
     // The base for wifi message types
     static final int BASE = Protocol.BASE_WIFI;
@@ -138,6 +139,7 @@ public class WifiStateMachinePrime {
         mSelfRecovery = mWifiInjector.getSelfRecovery();
         mWifiDiagnostics = mWifiInjector.makeWifiDiagnostics(mWifiNative);
         mModeStateMachine = new ModeStateMachine();
+        mScanRequestProxy = mWifiInjector.getScanRequestProxy();
         mWifiNativeStatusListener = new WifiNativeStatusListener();
         mWifiNative.registerStatusListener(mWifiNativeStatusListener);
     }
@@ -179,7 +181,7 @@ public class WifiStateMachinePrime {
     /**
      * Method to stop soft ap for wifi hotspot.
      *
-     * This method will stop any active softAp mode managers, if there is one.
+     * This method will stop any active softAp mode managers.
      */
     public void stopSoftAPMode() {
         mHandler.post(() -> {
@@ -187,7 +189,6 @@ public class WifiStateMachinePrime {
                 if (manager instanceof SoftApManager) {
                     Log.d(TAG, "Stopping SoftApModeManager");
                     manager.stop();
-                    mActiveModeManagers.remove(manager);
                 }
             }
             updateBatteryStatsWifiState(false);
@@ -311,6 +312,8 @@ public class WifiStateMachinePrime {
             public void enter() {
                 Log.d(TAG, "Entering WifiDisabledState");
                 mDefaultModeManager.sendScanAvailableBroadcast(mContext, false);
+                mScanRequestProxy.enableScanningForHiddenNetworks(false);
+                mScanRequestProxy.clearScanResults();
             }
 
             @Override
@@ -365,6 +368,26 @@ public class WifiStateMachinePrime {
                 if (checkForAndHandleModeChange(message)) {
                     return HANDLED;
                 }
+
+                switch(message.what) {
+                    case CMD_START_CLIENT_MODE:
+                        Log.d(TAG, "Received CMD_START_CLIENT_MODE when active - drop");
+                        break;
+                    case CMD_CLIENT_MODE_FAILED:
+                        Log.d(TAG, "ClientMode failed, return to WifiDisabledState.");
+                        // notify WifiController that ClientMode failed
+                        mClientModeCallback.onStateChanged(WifiManager.WIFI_STATE_UNKNOWN);
+                        mModeStateMachine.transitionTo(mWifiDisabledState);
+                        break;
+                    case CMD_CLIENT_MODE_STOPPED:
+                        Log.d(TAG, "ClientMode stopped, return to WifiDisabledState.");
+                        // notify WifiController that ClientMode stopped
+                        mClientModeCallback.onStateChanged(WifiManager.WIFI_STATE_DISABLED);
+                        mModeStateMachine.transitionTo(mWifiDisabledState);
+                        break;
+                    default:
+                        return NOT_HANDLED;
+                }
                 return NOT_HANDLED;
             }
         }
@@ -462,7 +485,6 @@ public class WifiStateMachinePrime {
         Log.d(TAG, "Starting SoftApModeManager");
 
         WifiConfiguration config = softapConfig.getWifiConfiguration();
-        // TODO (b/67601382): add checks for valid softap configs
         if (config != null && config.SSID != null) {
             Log.d(TAG, "Passing config to SoftApManager! " + config);
         } else {