Clean up native access from framework (0f344060) · Commits · e / os / android_frameworks_base

services/java/com/android/server/WifiService.java

+10 −10

Original line number	Diff line number	Diff line
		@@ -96,7 +96,6 @@ public class WifiService extends IWifiManager.Stub {
		private final WifiStateTracker mWifiStateTracker;

		private Context mContext;
		private int mWifiState;
		private int mWifiApState;

		private AlarmManager mAlarmManager;
		@@ -216,7 +215,7 @@ public class WifiService extends IWifiManager.Stub {
		wifiThread.start();
		mWifiHandler = new WifiHandler(wifiThread.getLooper());

		mWifiState = WIFI_STATE_DISABLED;
		mWifiStateTracker.setWifiState(WIFI_STATE_DISABLED);
		mWifiApState = WIFI_AP_STATE_DISABLED;
		boolean wifiEnabled = getPersistedWifiEnabled();
		boolean wifiAPEnabled = wifiEnabled ? false : getPersistedWifiApEnabled();
		@@ -406,8 +405,9 @@ public class WifiService extends IWifiManager.Stub {
		*/
		private boolean setWifiEnabledBlocking(boolean enable, boolean persist, int uid) {
		final int eventualWifiState = enable ? WIFI_STATE_ENABLED : WIFI_STATE_DISABLED;
		final int wifiState = mWifiStateTracker.getWifiState();

		if (mWifiState == eventualWifiState) {
		if (wifiState == eventualWifiState) {
		return true;
		}
		if (enable && isAirplaneModeOn() && !mAirplaneModeOverwridden) {
		@@ -421,7 +421,7 @@ public class WifiService extends IWifiManager.Stub {
		* Avoid doing a disable when the current Wifi state is UNKNOWN
		* TODO: Handle driver load fail and supplicant lost as seperate states
		*/
		if ((mWifiState == WIFI_STATE_UNKNOWN) && !enable) {
		if ((wifiState == WIFI_STATE_UNKNOWN) && !enable) {
		return false;
		}

		@@ -489,7 +489,7 @@ public class WifiService extends IWifiManager.Stub {
		}

		private void setWifiEnabledState(int wifiState, int uid) {
		final int previousWifiState = mWifiState;
		final int previousWifiState = mWifiStateTracker.getWifiState();

		long ident = Binder.clearCallingIdentity();
		try {
		@@ -504,7 +504,7 @@ public class WifiService extends IWifiManager.Stub {
		}

		// Update state
		mWifiState = wifiState;
		mWifiStateTracker.setWifiState(wifiState);

		// Broadcast
		final Intent intent = new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION);
		@@ -541,7 +541,7 @@ public class WifiService extends IWifiManager.Stub {
		*/
		public int getWifiEnabledState() {
		enforceAccessPermission();
		return mWifiState;
		return mWifiStateTracker.getWifiState();
		}

		/**
		@@ -639,7 +639,7 @@ public class WifiService extends IWifiManager.Stub {

		setWifiApEnabledState(enable ? WIFI_AP_STATE_ENABLING : WIFI_AP_STATE_DISABLING, uid);

		if (enable && (mWifiState == WIFI_STATE_ENABLED)) {
		if (enable && (mWifiStateTracker.getWifiState() == WIFI_STATE_ENABLED)) {
		setWifiEnabledBlocking(false, true, Process.myUid());
		}

		@@ -1721,7 +1721,7 @@ public class WifiService extends IWifiManager.Stub {
		}

		synchronized (mWifiHandler) {
		if (mWifiState == WIFI_STATE_ENABLING && !airplaneMode) {
		if ((mWifiStateTracker.getWifiState() == WIFI_STATE_ENABLING) && !airplaneMode) {
		return;
		}
		if (wifiShouldBeEnabled) {
		@@ -1864,7 +1864,7 @@ public class WifiService extends IWifiManager.Stub {
		+ ", uid=" + Binder.getCallingUid());
		return;
		}
		pw.println("Wi-Fi is " + stateName(mWifiState));
		pw.println("Wi-Fi is " + stateName(mWifiStateTracker.getWifiState()));
		pw.println("Stay-awake conditions: " +
		Settings.System.getInt(mContext.getContentResolver(),
		Settings.System.STAY_ON_WHILE_PLUGGED_IN, 0));

wifi/java/android/net/wifi/WifiStateTracker.java

+362 −11

Original line number	Diff line number	Diff line
		@@ -16,6 +16,12 @@

		package android.net.wifi;

		import static android.net.wifi.WifiManager.WIFI_STATE_DISABLED;
		import static android.net.wifi.WifiManager.WIFI_STATE_DISABLING;
		import static android.net.wifi.WifiManager.WIFI_STATE_ENABLED;
		import static android.net.wifi.WifiManager.WIFI_STATE_ENABLING;
		import static android.net.wifi.WifiManager.WIFI_STATE_UNKNOWN;

		import android.app.ActivityManagerNative;
		import android.net.NetworkInfo;
		import android.net.NetworkStateTracker;
		@@ -270,6 +276,14 @@ public class WifiStateTracker extends NetworkStateTracker {
		private boolean mIsScanModeActive;
		private boolean mEnableRssiPolling;

		/**
		* One of {@link WifiManager#WIFI_STATE_DISABLED},
		* {@link WifiManager#WIFI_STATE_DISABLING},
		* {@link WifiManager#WIFI_STATE_ENABLED},
		* {@link WifiManager#WIFI_STATE_ENABLING},
		* {@link WifiManager#WIFI_STATE_UNKNOWN}
		*/
		private int mWifiState;
		// Wi-Fi run states:
		private static final int RUN_STATE_STARTING = 1;
		private static final int RUN_STATE_RUNNING = 2;
		@@ -771,9 +785,8 @@ public class WifiStateTracker extends NetworkStateTracker {
		case EVENT_SUPPLICANT_DISCONNECT:
		mRunState = RUN_STATE_STOPPED;
		noteRunState();
		int wifiState = mWM.getWifiState();
		boolean died = wifiState != WifiManager.WIFI_STATE_DISABLED &&
		wifiState != WifiManager.WIFI_STATE_DISABLING;
		boolean died = mWifiState != WIFI_STATE_DISABLED &&
		mWifiState != WIFI_STATE_DISABLING;
		if (died) {
		if (LOCAL_LOGD) Log.v(TAG, "Supplicant died unexpectedly");
		} else {
		@@ -1487,143 +1500,436 @@ public class WifiStateTracker extends NetworkStateTracker {
		return true;
		}

		public synchronized int getWifiState() {
		return mWifiState;
		}

		public synchronized void setWifiState(int wifiState) {
		mWifiState = wifiState;
		}

		/**
		* TODO: add documentation to all the native calls
		* along with conditional checks to make sure
		* native calls dont happen when wifi is not enabled
		* The WifiNative interface functions are listed below.
		* The only native call that is not synchronized on
		* WifiStateTracker is waitForEvent() which waits on a
		* seperate monitor channel.
		*
		* All supplicant commands need the wifi to be in an
		* enabled state. This can be done by checking the
		* mWifiState to be WIFI_STATE_ENABLED.
		*
		* All commands that can cause commands to driver
		* initiated need the driver state to be started.
		* This is done by checking isDriverStopped() to
		* be false.
		*/

		/**
		* Load the driver and firmware
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean loadDriver() {
		return WifiNative.loadDriver();
		}

		/**
		* Unload the driver and firmware
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean unloadDriver() {
		return WifiNative.unloadDriver();
		}

		/**
		* Check the supplicant config and
		* start the supplicant daemon
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean startSupplicant() {
		return WifiNative.startSupplicant();
		}

		/**
		* Stop the supplicant daemon
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean stopSupplicant() {
		return WifiNative.stopSupplicant();
		}

		/**
		* Establishes two channels - control channel for commands
		* and monitor channel for notifying WifiMonitor
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean connectToSupplicant() {
		return WifiNative.connectToSupplicant();
		}

		/**
		* Close the control/monitor channels to supplicant
		*/
		public synchronized void closeSupplicantConnection() {
		WifiNative.closeSupplicantConnection();
		}

		/**
		* Check if the supplicant is alive
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean ping() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.pingCommand();
		}

		/**
		* initiate an active or passive scan
		*
		* @param forceActive true if it is a active scan
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean scan(boolean forceActive) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.scanCommand(forceActive);
		}

		/**
		* Specifies whether the supplicant or driver
		* take care of initiating scan and doing AP selection
		*
		* @param mode
		* SUPPL_SCAN_HANDLING_NORMAL
		* SUPPL_SCAN_HANDLING_LIST_ONLY
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean setScanResultHandling(int mode) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.setScanResultHandlingCommand(mode);
		}

		/**
		* Fetch the scan results from the supplicant
		*
		* @return example result string
		* 00:bb:cc:dd:cc:ee 2427 166 [WPA-EAP-TKIP][WPA2-EAP-CCMP] Net1
		* 00:bb:cc:dd:cc:ff 2412 165 [WPA-EAP-TKIP][WPA2-EAP-CCMP] Net2
		*/
		public synchronized String scanResults() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return null;
		}
		return WifiNative.scanResultsCommand();
		}

		public synchronized void setScanMode(boolean isScanModeActive) {
		/**
		* Set the scan mode - active or passive
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean setScanMode(boolean isScanModeActive) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		if (mIsScanModeActive != isScanModeActive) {
		WifiNative.setScanModeCommand(mIsScanModeActive = isScanModeActive);
		return WifiNative.setScanModeCommand(mIsScanModeActive = isScanModeActive);
		}
		return true;
		}

		/**
		* Disconnect from Access Point
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean disconnect() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.disconnectCommand();
		}

		/**
		* Initiate a reconnection to AP
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean reconnectCommand() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.reconnectCommand();
		}

		/**
		* Add a network
		*
		* @return network id of the new network
		*/
		public synchronized int addNetwork() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return -1;
		}
		return WifiNative.addNetworkCommand();
		}

		/**
		* Delete a network
		*
		* @param networkId id of the network to be removed
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean removeNetwork(int networkId) {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return mDisconnectExpected = WifiNative.removeNetworkCommand(networkId);
		}

		/**
		* Enable a network
		*
		* @param netId network id of the network
		* @param disableOthers true, if all other networks have to be disabled
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean enableNetwork(int netId, boolean disableOthers) {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.enableNetworkCommand(netId, disableOthers);
		}

		/**
		* Disable a network
		*
		* @param netId network id of the network
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean disableNetwork(int netId) {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.disableNetworkCommand(netId);
		}

		/**
		* Initiate a re-association in supplicant
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean reassociate() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.reassociateCommand();
		}

		/**
		* Blacklist a BSSID. This will avoid the AP if there are
		* alternate APs to connect
		*
		* @param bssid BSSID of the network
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean addToBlacklist(String bssid) {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.addToBlacklistCommand(bssid);
		}

		/**
		* Clear the blacklist list
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean clearBlacklist() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.clearBlacklistCommand();
		}

		/**
		* List all configured networks
		*
		* @return list of networks or null on failure
		*/
		public synchronized String listNetworks() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return null;
		}
		return WifiNative.listNetworksCommand();
		}

		/**
		* Get network setting by name
		*
		* @param netId network id of the network
		* @param name network variable key
		* @return value corresponding to key
		*/
		public synchronized String getNetworkVariable(int netId, String name) {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return null;
		}
		return WifiNative.getNetworkVariableCommand(netId, name);
		}

		/**
		* Set network setting by name
		*
		* @param netId network id of the network
		* @param name network variable key
		* @param value network variable value
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean setNetworkVariable(int netId, String name, String value) {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.setNetworkVariableCommand(netId, name, value);
		}

		/**
		* Get detailed status of the connection
		*
		* @return Example status result
		* bssid=aa:bb:cc:dd:ee:ff
		* ssid=TestNet
		* id=3
		* pairwise_cipher=NONE
		* group_cipher=NONE
		* key_mgmt=NONE
		* wpa_state=COMPLETED
		* ip_address=X.X.X.X
		*/
		public synchronized String status() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return null;
		}
		return WifiNative.statusCommand();
		}

		/**
		* Get RSSI to currently connected network
		*
		* @return RSSI value, -1 on failure
		*/
		public synchronized int getRssi() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return -1;
		}
		return WifiNative.getRssiApproxCommand();
		}

		/**
		* Get approx RSSI to currently connected network
		*
		* @return RSSI value, -1 on failure
		*/
		public synchronized int getRssiApprox() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return -1;
		}
		return WifiNative.getRssiApproxCommand();
		}

		/**
		* Get link speed to currently connected network
		*
		* @return link speed, -1 on failure
		*/
		public synchronized int getLinkSpeed() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return -1;
		}
		return WifiNative.getLinkSpeedCommand();
		}

		/**
		* Get MAC address of radio
		*
		* @return MAC address, null on failure
		*/
		public synchronized String getMacAddress() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return null;
		}
		return WifiNative.getMacAddressCommand();
		}

		/**
		* Start driver
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean startDriver() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.startDriverCommand();
		}

		/**
		* Stop driver
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean stopDriver() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.stopDriverCommand();
		}

		/**
		* Start packet filtering
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean startPacketFiltering() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.startPacketFiltering();
		}

		/**
		* Stop packet filtering
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean stopPacketFiltering() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.stopPacketFiltering();
		}

		/**
		* Set power mode
		* @param mode
		* DRIVER_POWER_MODE_AUTO
		* DRIVER_POWER_MODE_ACTIVE
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean setPowerMode(int mode) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.setPowerModeCommand(mode);
		}

		@@ -1634,6 +1940,9 @@ public class WifiStateTracker extends NetworkStateTracker {
		* the number of channels is invalid.
		*/
		public synchronized boolean setNumAllowedChannels() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		try {
		return setNumAllowedChannels(
		Settings.Secure.getInt(mContext.getContentResolver(),
		@@ -1656,15 +1965,38 @@ public class WifiStateTracker extends NetworkStateTracker {
		* {@code numChannels} is outside the valid range.
		*/
		public synchronized boolean setNumAllowedChannels(int numChannels) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		mNumAllowedChannels = numChannels;
		return WifiNative.setNumAllowedChannelsCommand(numChannels);
		}

		/**
		* Get number of allowed channels
		*
		* @return channel count, -1 on failure
		*/
		public synchronized int getNumAllowedChannels() {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return -1;
		}
		return WifiNative.getNumAllowedChannelsCommand();
		}

		/**
		* Set bluetooth coex mode:
		*
		* @param mode
		* BLUETOOTH_COEXISTENCE_MODE_ENABLED
		* BLUETOOTH_COEXISTENCE_MODE_DISABLED
		* BLUETOOTH_COEXISTENCE_MODE_SENSE
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean setBluetoothCoexistenceMode(int mode) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return false;
		}
		return WifiNative.setBluetoothCoexistenceModeCommand(mode);
		}

		@@ -1676,14 +2008,33 @@ public class WifiStateTracker extends NetworkStateTracker {
		* @param isBluetoothPlaying whether to enable or disable this mode
		*/
		public synchronized void setBluetoothScanMode(boolean isBluetoothPlaying) {
		if (mWifiState != WIFI_STATE_ENABLED && !isDriverStopped()) {
		return;
		}
		WifiNative.setBluetoothCoexistenceScanModeCommand(isBluetoothPlaying);
		}

		/**
		* Save configuration on supplicant
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean saveConfig() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.saveConfigCommand();
		}

		/**
		* Reload the configuration from file
		*
		* @return {@code true} if the operation succeeds, {@code false} otherwise
		*/
		public synchronized boolean reloadConfig() {
		if (mWifiState != WIFI_STATE_ENABLED) {
		return false;
		}
		return WifiNative.reloadConfigCommand();
		}