/*
|
* Copyright (C) 2016 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 com.android.server.wifi;
|
|
import android.annotation.NonNull;
|
import android.content.Context;
|
import android.net.wifi.WifiConfiguration;
|
import android.net.wifi.WifiManager;
|
import android.os.BatteryStats;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.os.RemoteException;
|
import android.util.ArraySet;
|
import android.util.Log;
|
|
import com.android.internal.app.IBatteryStats;
|
import com.android.internal.util.Protocol;
|
import com.android.internal.util.State;
|
import com.android.internal.util.StateMachine;
|
import com.android.server.wifi.WifiNative.StatusListener;
|
|
import java.io.FileDescriptor;
|
import java.io.PrintWriter;
|
|
/**
|
* This class provides the implementation for different WiFi operating modes.
|
*/
|
public class ActiveModeWarden {
|
private static final String TAG = "WifiActiveModeWarden";
|
|
private ModeStateMachine mModeStateMachine;
|
|
// Holder for active mode managers
|
private final ArraySet<ActiveModeManager> mActiveModeManagers;
|
// DefaultModeManager used to service API calls when there are not active mode managers.
|
private DefaultModeManager mDefaultModeManager;
|
|
private final WifiInjector mWifiInjector;
|
private final Context mContext;
|
private final Looper mLooper;
|
private final Handler mHandler;
|
private final WifiNative mWifiNative;
|
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;
|
|
// The message identifiers below are mapped to those in ClientModeImpl when applicable.
|
// Start the soft access point
|
static final int CMD_START_AP = BASE + 21;
|
// Indicates soft ap start failed
|
static final int CMD_START_AP_FAILURE = BASE + 22;
|
// Stop the soft access point
|
static final int CMD_STOP_AP = BASE + 23;
|
// Soft access point teardown is completed
|
static final int CMD_AP_STOPPED = BASE + 24;
|
|
// Start Scan Only mode
|
static final int CMD_START_SCAN_ONLY_MODE = BASE + 200;
|
// Indicates that start Scan only mode failed
|
static final int CMD_START_SCAN_ONLY_MODE_FAILURE = BASE + 201;
|
// Indicates that scan only mode stopped
|
static final int CMD_STOP_SCAN_ONLY_MODE = BASE + 202;
|
// ScanOnly mode teardown is complete
|
static final int CMD_SCAN_ONLY_MODE_STOPPED = BASE + 203;
|
// ScanOnly mode failed
|
static final int CMD_SCAN_ONLY_MODE_FAILED = BASE + 204;
|
|
// Start Client mode
|
static final int CMD_START_CLIENT_MODE = BASE + 300;
|
// Indicates that start client mode failed
|
static final int CMD_START_CLIENT_MODE_FAILURE = BASE + 301;
|
// Indicates that client mode stopped
|
static final int CMD_STOP_CLIENT_MODE = BASE + 302;
|
// Client mode teardown is complete
|
static final int CMD_CLIENT_MODE_STOPPED = BASE + 303;
|
// Client mode failed
|
static final int CMD_CLIENT_MODE_FAILED = BASE + 304;
|
|
private StatusListener mWifiNativeStatusListener;
|
|
private WifiManager.SoftApCallback mSoftApCallback;
|
private ScanOnlyModeManager.Listener mScanOnlyCallback;
|
private ClientModeManager.Listener mClientModeCallback;
|
|
/**
|
* Called from WifiServiceImpl to register a callback for notifications from SoftApManager
|
*/
|
public void registerSoftApCallback(@NonNull WifiManager.SoftApCallback callback) {
|
mSoftApCallback = callback;
|
}
|
|
/**
|
* Called from WifiController to register a callback for notifications from ScanOnlyModeManager
|
*/
|
public void registerScanOnlyCallback(@NonNull ScanOnlyModeManager.Listener callback) {
|
mScanOnlyCallback = callback;
|
}
|
|
/**
|
* Called from WifiController to register a callback for notifications from ClientModeManager
|
*/
|
public void registerClientModeCallback(@NonNull ClientModeManager.Listener callback) {
|
mClientModeCallback = callback;
|
}
|
|
ActiveModeWarden(WifiInjector wifiInjector,
|
Context context,
|
Looper looper,
|
WifiNative wifiNative,
|
DefaultModeManager defaultModeManager,
|
IBatteryStats batteryStats) {
|
mWifiInjector = wifiInjector;
|
mContext = context;
|
mLooper = looper;
|
mHandler = new Handler(looper);
|
mWifiNative = wifiNative;
|
mActiveModeManagers = new ArraySet();
|
mDefaultModeManager = defaultModeManager;
|
mBatteryStats = batteryStats;
|
mSelfRecovery = mWifiInjector.getSelfRecovery();
|
mWifiDiagnostics = mWifiInjector.getWifiDiagnostics();
|
mScanRequestProxy = mWifiInjector.getScanRequestProxy();
|
mModeStateMachine = new ModeStateMachine();
|
mWifiNativeStatusListener = new WifiNativeStatusListener();
|
mWifiNative.registerStatusListener(mWifiNativeStatusListener);
|
}
|
|
/**
|
* Method to switch wifi into client mode where connections to configured networks will be
|
* attempted.
|
*/
|
public void enterClientMode() {
|
changeMode(ModeStateMachine.CMD_START_CLIENT_MODE);
|
}
|
|
/**
|
* Method to switch wifi into scan only mode where network connection attempts will not be made.
|
*
|
* This mode is utilized by location scans. If wifi is disabled by a user, but they have
|
* previously configured their device to perform location scans, this mode allows wifi to
|
* fulfill the location scan requests but will not be used for connectivity.
|
*/
|
public void enterScanOnlyMode() {
|
changeMode(ModeStateMachine.CMD_START_SCAN_ONLY_MODE);
|
}
|
|
/**
|
* Method to enable soft ap for wifi hotspot.
|
*
|
* The supplied SoftApModeConfiguration includes the target softap WifiConfiguration (or null if
|
* the persisted config is to be used) and the target operating mode (ex,
|
* {@link WifiManager.IFACE_IP_MODE_TETHERED} {@link WifiManager.IFACE_IP_MODE_LOCAL_ONLY}).
|
*
|
* @param wifiConfig SoftApModeConfiguration for the hostapd softap
|
*/
|
public void enterSoftAPMode(@NonNull SoftApModeConfiguration wifiConfig) {
|
mHandler.post(() -> {
|
startSoftAp(wifiConfig);
|
});
|
}
|
|
/**
|
* Method to stop soft ap for wifi hotspot.
|
*
|
* This method will stop any active softAp mode managers.
|
*
|
* @param mode the operating mode of APs to bring down (ex,
|
* {@link WifiManager.IFACE_IP_MODE_TETHERED} or
|
* {@link WifiManager.IFACE_IP_MODE_LOCAL_ONLY}).
|
* Use {@link WifiManager.IFACE_IP_MODE_UNSPECIFIED} to stop all APs.
|
*/
|
public void stopSoftAPMode(int mode) {
|
mHandler.post(() -> {
|
for (ActiveModeManager manager : mActiveModeManagers) {
|
if (!(manager instanceof SoftApManager)) continue;
|
SoftApManager softApManager = (SoftApManager) manager;
|
|
if (mode != WifiManager.IFACE_IP_MODE_UNSPECIFIED
|
&& mode != softApManager.getIpMode()) {
|
continue;
|
}
|
softApManager.stop();
|
}
|
updateBatteryStatsWifiState(false);
|
});
|
}
|
|
/**
|
* Method to disable wifi in sta/client mode scenarios.
|
*
|
* This mode will stop any client/scan modes and will not perform any network scans.
|
*/
|
public void disableWifi() {
|
changeMode(ModeStateMachine.CMD_DISABLE_WIFI);
|
}
|
|
/**
|
* Method to stop all active modes, for example, when toggling airplane mode.
|
*/
|
public void shutdownWifi() {
|
mHandler.post(() -> {
|
for (ActiveModeManager manager : mActiveModeManagers) {
|
manager.stop();
|
}
|
updateBatteryStatsWifiState(false);
|
});
|
}
|
|
/**
|
* Dump current state for active mode managers.
|
*
|
* Must be called from ClientModeImpl thread.
|
*/
|
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
|
pw.println("Dump of " + TAG);
|
|
pw.println("Current wifi mode: " + getCurrentMode());
|
pw.println("NumActiveModeManagers: " + mActiveModeManagers.size());
|
for (ActiveModeManager manager : mActiveModeManagers) {
|
manager.dump(fd, pw, args);
|
}
|
}
|
|
protected String getCurrentMode() {
|
return mModeStateMachine.getCurrentMode();
|
}
|
|
private void changeMode(int newMode) {
|
mModeStateMachine.sendMessage(newMode);
|
}
|
|
/**
|
* Helper class to wrap the ActiveModeManager callback objects.
|
*/
|
private class ModeCallback {
|
ActiveModeManager mActiveManager;
|
|
void setActiveModeManager(ActiveModeManager manager) {
|
mActiveManager = manager;
|
}
|
|
ActiveModeManager getActiveModeManager() {
|
return mActiveManager;
|
}
|
}
|
|
private class ModeStateMachine extends StateMachine {
|
// Commands for the state machine - these will be removed,
|
// along with the StateMachine itself
|
public static final int CMD_START_CLIENT_MODE = 0;
|
public static final int CMD_START_SCAN_ONLY_MODE = 1;
|
public static final int CMD_DISABLE_WIFI = 3;
|
|
private final State mWifiDisabledState = new WifiDisabledState();
|
private final State mClientModeActiveState = new ClientModeActiveState();
|
private final State mScanOnlyModeActiveState = new ScanOnlyModeActiveState();
|
|
ModeStateMachine() {
|
super(TAG, mLooper);
|
|
addState(mClientModeActiveState);
|
addState(mScanOnlyModeActiveState);
|
addState(mWifiDisabledState);
|
|
Log.d(TAG, "Starting Wifi in WifiDisabledState");
|
setInitialState(mWifiDisabledState);
|
start();
|
}
|
|
private String getCurrentMode() {
|
return getCurrentState().getName();
|
}
|
|
private boolean checkForAndHandleModeChange(Message message) {
|
switch(message.what) {
|
case ModeStateMachine.CMD_START_CLIENT_MODE:
|
Log.d(TAG, "Switching from " + getCurrentMode() + " to ClientMode");
|
mModeStateMachine.transitionTo(mClientModeActiveState);
|
break;
|
case ModeStateMachine.CMD_START_SCAN_ONLY_MODE:
|
Log.d(TAG, "Switching from " + getCurrentMode() + " to ScanOnlyMode");
|
mModeStateMachine.transitionTo(mScanOnlyModeActiveState);
|
break;
|
case ModeStateMachine.CMD_DISABLE_WIFI:
|
Log.d(TAG, "Switching from " + getCurrentMode() + " to WifiDisabled");
|
mModeStateMachine.transitionTo(mWifiDisabledState);
|
break;
|
default:
|
return NOT_HANDLED;
|
}
|
return HANDLED;
|
}
|
|
class ModeActiveState extends State {
|
ActiveModeManager mManager;
|
@Override
|
public boolean processMessage(Message message) {
|
// handle messages for changing modes here
|
return NOT_HANDLED;
|
}
|
|
@Override
|
public void exit() {
|
// Active states must have a mode manager, so this should not be null, but it isn't
|
// obvious from the structure - add a null check here, just in case this is missed
|
// in the future
|
if (mManager != null) {
|
mManager.stop();
|
mActiveModeManagers.remove(mManager);
|
updateScanMode();
|
}
|
updateBatteryStatsWifiState(false);
|
}
|
|
// Hook to be used by sub-classes of ModeActiveState to indicate the completion of
|
// bringup of the corresponding mode.
|
public void onModeActivationComplete() {
|
updateScanMode();
|
}
|
|
// Update the scan state based on all active mode managers.
|
// Note: This is an overkill currently because there is only 1 of scan-only or client
|
// mode present today.
|
private void updateScanMode() {
|
boolean scanEnabled = false;
|
boolean scanningForHiddenNetworksEnabled = false;
|
for (ActiveModeManager modeManager : mActiveModeManagers) {
|
@ActiveModeManager.ScanMode int scanState = modeManager.getScanMode();
|
switch (scanState) {
|
case ActiveModeManager.SCAN_NONE:
|
break;
|
case ActiveModeManager.SCAN_WITHOUT_HIDDEN_NETWORKS:
|
scanEnabled = true;
|
break;
|
case ActiveModeManager.SCAN_WITH_HIDDEN_NETWORKS:
|
scanEnabled = true;
|
scanningForHiddenNetworksEnabled = true;
|
break;
|
}
|
}
|
mScanRequestProxy.enableScanning(scanEnabled, scanningForHiddenNetworksEnabled);
|
}
|
}
|
|
class WifiDisabledState extends ModeActiveState {
|
@Override
|
public void enter() {
|
Log.d(TAG, "Entering WifiDisabledState");
|
}
|
|
@Override
|
public boolean processMessage(Message message) {
|
Log.d(TAG, "received a message in WifiDisabledState: " + message);
|
if (checkForAndHandleModeChange(message)) {
|
return HANDLED;
|
}
|
return NOT_HANDLED;
|
}
|
|
@Override
|
public void exit() {
|
// do not have an active mode manager... nothing to clean up
|
}
|
|
}
|
|
class ClientModeActiveState extends ModeActiveState {
|
ClientListener mListener;
|
private class ClientListener implements ClientModeManager.Listener {
|
@Override
|
public void onStateChanged(int state) {
|
// make sure this listener is still active
|
if (this != mListener) {
|
Log.d(TAG, "Client mode state change from previous manager");
|
return;
|
}
|
|
Log.d(TAG, "State changed from client mode. state = " + state);
|
|
if (state == WifiManager.WIFI_STATE_UNKNOWN) {
|
// error while setting up client mode or an unexpected failure.
|
mModeStateMachine.sendMessage(CMD_CLIENT_MODE_FAILED, this);
|
} else if (state == WifiManager.WIFI_STATE_DISABLED) {
|
// client mode stopped
|
mModeStateMachine.sendMessage(CMD_CLIENT_MODE_STOPPED, this);
|
} else if (state == WifiManager.WIFI_STATE_ENABLED) {
|
// client mode is ready to go
|
Log.d(TAG, "client mode active");
|
onModeActivationComplete();
|
} else {
|
// only care if client mode stopped or started, dropping
|
}
|
}
|
}
|
|
@Override
|
public void enter() {
|
Log.d(TAG, "Entering ClientModeActiveState");
|
|
mListener = new ClientListener();
|
mManager = mWifiInjector.makeClientModeManager(mListener);
|
mManager.start();
|
mActiveModeManagers.add(mManager);
|
|
updateBatteryStatsWifiState(true);
|
}
|
|
@Override
|
public void exit() {
|
super.exit();
|
mListener = null;
|
}
|
|
@Override
|
public boolean processMessage(Message message) {
|
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:
|
if (mListener != message.obj) {
|
Log.d(TAG, "Client mode state change from previous manager");
|
return HANDLED;
|
}
|
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:
|
if (mListener != message.obj) {
|
Log.d(TAG, "Client mode state change from previous manager");
|
return HANDLED;
|
}
|
|
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;
|
}
|
}
|
|
class ScanOnlyModeActiveState extends ModeActiveState {
|
ScanOnlyListener mListener;
|
private class ScanOnlyListener implements ScanOnlyModeManager.Listener {
|
@Override
|
public void onStateChanged(int state) {
|
if (this != mListener) {
|
Log.d(TAG, "ScanOnly mode state change from previous manager");
|
return;
|
}
|
|
if (state == WifiManager.WIFI_STATE_UNKNOWN) {
|
Log.d(TAG, "ScanOnlyMode mode failed");
|
// error while setting up scan mode or an unexpected failure.
|
mModeStateMachine.sendMessage(CMD_SCAN_ONLY_MODE_FAILED, this);
|
} else if (state == WifiManager.WIFI_STATE_DISABLED) {
|
Log.d(TAG, "ScanOnlyMode stopped");
|
//scan only mode stopped
|
mModeStateMachine.sendMessage(CMD_SCAN_ONLY_MODE_STOPPED, this);
|
} else if (state == WifiManager.WIFI_STATE_ENABLED) {
|
// scan mode is ready to go
|
Log.d(TAG, "scan mode active");
|
onModeActivationComplete();
|
} else {
|
Log.d(TAG, "unexpected state update: " + state);
|
}
|
}
|
}
|
|
@Override
|
public void enter() {
|
Log.d(TAG, "Entering ScanOnlyModeActiveState");
|
|
mListener = new ScanOnlyListener();
|
mManager = mWifiInjector.makeScanOnlyModeManager(mListener);
|
mManager.start();
|
mActiveModeManagers.add(mManager);
|
|
updateBatteryStatsWifiState(true);
|
updateBatteryStatsScanModeActive();
|
}
|
|
@Override
|
public void exit() {
|
super.exit();
|
mListener = null;
|
}
|
|
@Override
|
public boolean processMessage(Message message) {
|
if (checkForAndHandleModeChange(message)) {
|
return HANDLED;
|
}
|
|
switch(message.what) {
|
case CMD_START_SCAN_ONLY_MODE:
|
Log.d(TAG, "Received CMD_START_SCAN_ONLY_MODE when active - drop");
|
break;
|
case CMD_SCAN_ONLY_MODE_FAILED:
|
if (mListener != message.obj) {
|
Log.d(TAG, "ScanOnly mode state change from previous manager");
|
return HANDLED;
|
}
|
|
Log.d(TAG, "ScanOnlyMode failed, return to WifiDisabledState.");
|
// notify WifiController that ScanOnlyMode failed
|
mScanOnlyCallback.onStateChanged(WifiManager.WIFI_STATE_UNKNOWN);
|
mModeStateMachine.transitionTo(mWifiDisabledState);
|
break;
|
case CMD_SCAN_ONLY_MODE_STOPPED:
|
if (mListener != message.obj) {
|
Log.d(TAG, "ScanOnly mode state change from previous manager");
|
return HANDLED;
|
}
|
|
Log.d(TAG, "ScanOnlyMode stopped, return to WifiDisabledState.");
|
// notify WifiController that ScanOnlyMode stopped
|
mScanOnlyCallback.onStateChanged(WifiManager.WIFI_STATE_DISABLED);
|
mModeStateMachine.transitionTo(mWifiDisabledState);
|
break;
|
default:
|
return NOT_HANDLED;
|
}
|
return HANDLED;
|
}
|
}
|
} // class ModeStateMachine
|
|
private class SoftApCallbackImpl extends ModeCallback implements WifiManager.SoftApCallback {
|
private int mMode;
|
|
private SoftApCallbackImpl(int mode) {
|
mMode = mode;
|
}
|
|
@Override
|
public void onStateChanged(int state, int reason) {
|
if (state == WifiManager.WIFI_AP_STATE_DISABLED) {
|
mActiveModeManagers.remove(getActiveModeManager());
|
updateBatteryStatsWifiState(false);
|
} else if (state == WifiManager.WIFI_AP_STATE_FAILED) {
|
mActiveModeManagers.remove(getActiveModeManager());
|
updateBatteryStatsWifiState(false);
|
}
|
|
if (mSoftApCallback != null && mMode == WifiManager.IFACE_IP_MODE_TETHERED) {
|
mSoftApCallback.onStateChanged(state, reason);
|
}
|
}
|
|
@Override
|
public void onNumClientsChanged(int numClients) {
|
if (mSoftApCallback == null) {
|
Log.d(TAG, "SoftApCallback is null. Dropping NumClientsChanged event.");
|
} else if (mMode == WifiManager.IFACE_IP_MODE_TETHERED) {
|
mSoftApCallback.onNumClientsChanged(numClients);
|
}
|
}
|
}
|
|
private void startSoftAp(SoftApModeConfiguration softapConfig) {
|
Log.d(TAG, "Starting SoftApModeManager");
|
|
WifiConfiguration config = softapConfig.getWifiConfiguration();
|
if (config != null && config.SSID != null) {
|
Log.d(TAG, "Passing config to SoftApManager! " + config);
|
} else {
|
config = null;
|
}
|
|
SoftApCallbackImpl callback = new SoftApCallbackImpl(softapConfig.getTargetMode());
|
ActiveModeManager manager = mWifiInjector.makeSoftApManager(callback, softapConfig);
|
callback.setActiveModeManager(manager);
|
manager.start();
|
mActiveModeManagers.add(manager);
|
updateBatteryStatsWifiState(true);
|
}
|
|
/**
|
* Helper method to report wifi state as on/off (doesn't matter which mode).
|
*
|
* @param enabled boolean indicating that some mode has been turned on or off
|
*/
|
private void updateBatteryStatsWifiState(boolean enabled) {
|
try {
|
if (enabled) {
|
if (mActiveModeManagers.size() == 1) {
|
// only report wifi on if we haven't already
|
mBatteryStats.noteWifiOn();
|
}
|
} else {
|
if (mActiveModeManagers.size() == 0) {
|
// only report if we don't have any active modes
|
mBatteryStats.noteWifiOff();
|
}
|
}
|
} catch (RemoteException e) {
|
Log.e(TAG, "Failed to note battery stats in wifi");
|
}
|
}
|
|
private void updateBatteryStatsScanModeActive() {
|
try {
|
mBatteryStats.noteWifiState(BatteryStats.WIFI_STATE_OFF_SCANNING, null);
|
} catch (RemoteException e) {
|
Log.e(TAG, "Failed to note battery stats in wifi");
|
}
|
}
|
|
// callback used to receive callbacks about underlying native failures
|
private final class WifiNativeStatusListener implements StatusListener {
|
|
@Override
|
public void onStatusChanged(boolean isReady) {
|
if (!isReady) {
|
mHandler.post(() -> {
|
Log.e(TAG, "One of the native daemons died. Triggering recovery");
|
mWifiDiagnostics.captureBugReportData(
|
WifiDiagnostics.REPORT_REASON_WIFINATIVE_FAILURE);
|
|
// immediately trigger SelfRecovery if we receive a notice about an
|
// underlying daemon failure
|
mWifiInjector.getSelfRecovery().trigger(SelfRecovery.REASON_WIFINATIVE_FAILURE);
|
});
|
}
|
}
|
};
|
}
|
