Restructure wifiservice for clarity (b8c0e009) · Commits · e / os / android_frameworks_base

services/java/com/android/server/wifi/WifiNotificationController.java

0 → 100644

+292 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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.app.Notification;
		import android.app.NotificationManager;
		import android.app.TaskStackBuilder;
		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.NetworkInfo;
		import android.net.wifi.ScanResult;
		import android.net.wifi.WifiManager;
		import android.net.wifi.WifiStateMachine;
		import android.os.Handler;
		import android.os.Message;
		import android.os.UserHandle;
		import android.provider.Settings;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.util.List;

		/* Takes care of handling the "open wi-fi network available" notification @hide */
		final class WifiNotificationController {
		/**
		* The icon to show in the 'available networks' notification. This will also
		* be the ID of the Notification given to the NotificationManager.
		*/
		private static final int ICON_NETWORKS_AVAILABLE =
		com.android.internal.R.drawable.stat_notify_wifi_in_range;
		/**
		* When a notification is shown, we wait this amount before possibly showing it again.
		*/
		private final long NOTIFICATION_REPEAT_DELAY_MS;
		/**
		* Whether the user has set the setting to show the 'available networks' notification.
		*/
		private boolean mNotificationEnabled;
		/**
		* Observes the user setting to keep {@link #mNotificationEnabled} in sync.
		*/
		private NotificationEnabledSettingObserver mNotificationEnabledSettingObserver;
		/**
		* The {@link System#currentTimeMillis()} must be at least this value for us
		* to show the notification again.
		*/
		private long mNotificationRepeatTime;
		/**
		* The Notification object given to the NotificationManager.
		*/
		private Notification mNotification;
		/**
		* Whether the notification is being shown, as set by us. That is, if the
		* user cancels the notification, we will not receive the callback so this
		* will still be true. We only guarantee if this is false, then the
		* notification is not showing.
		*/
		private boolean mNotificationShown;
		/**
		* The number of continuous scans that must occur before consider the
		* supplicant in a scanning state. This allows supplicant to associate with
		* remembered networks that are in the scan results.
		*/
		private static final int NUM_SCANS_BEFORE_ACTUALLY_SCANNING = 3;
		/**
		* The number of scans since the last network state change. When this
		* exceeds {@link #NUM_SCANS_BEFORE_ACTUALLY_SCANNING}, we consider the
		* supplicant to actually be scanning. When the network state changes to
		* something other than scanning, we reset this to 0.
		*/
		private int mNumScansSinceNetworkStateChange;

		private final Context mContext;
		private final WifiStateMachine mWifiStateMachine;
		private NetworkInfo mNetworkInfo;

		WifiNotificationController(Context context, WifiStateMachine wsm) {
		mContext = context;
		mWifiStateMachine = wsm;

		IntentFilter filter = new IntentFilter();
		filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
		filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
		filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);

		mContext.registerReceiver(
		new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		if (intent.getAction().equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
		resetNotification();
		} else if (intent.getAction().equals(
		WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
		mNetworkInfo = (NetworkInfo) intent.getParcelableExtra(
		WifiManager.EXTRA_NETWORK_INFO);
		// reset & clear notification on a network connect & disconnect
		switch(mNetworkInfo.getDetailedState()) {
		case CONNECTED:
		case DISCONNECTED:
		case CAPTIVE_PORTAL_CHECK:
		resetNotification();
		break;
		}
		} else if (intent.getAction().equals(
		WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
		checkAndSetNotification(mNetworkInfo,
		mWifiStateMachine.syncGetScanResultsList());
		}
		}
		}, filter);

		// Setting is in seconds
		NOTIFICATION_REPEAT_DELAY_MS = Settings.Global.getInt(context.getContentResolver(),
		Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 900) * 1000l;
		mNotificationEnabledSettingObserver = new NotificationEnabledSettingObserver(new Handler());
		mNotificationEnabledSettingObserver.register();
		}

		private synchronized void checkAndSetNotification(NetworkInfo networkInfo,
		List<ScanResult> scanResults) {
		// TODO: unregister broadcast so we do not have to check here
		// If we shouldn't place a notification on available networks, then
		// don't bother doing any of the following
		if (!mNotificationEnabled) return;
		if (networkInfo == null) return;

		NetworkInfo.State state = networkInfo.getState();
		if ((state == NetworkInfo.State.DISCONNECTED)
		\|\| (state == NetworkInfo.State.UNKNOWN)) {
		if (scanResults != null) {
		int numOpenNetworks = 0;
		for (int i = scanResults.size() - 1; i >= 0; i--) {
		ScanResult scanResult = scanResults.get(i);

		//A capability of [ESS] represents an open access point
		//that is available for an STA to connect
		if (scanResult.capabilities != null &&
		scanResult.capabilities.equals("[ESS]")) {
		numOpenNetworks++;
		}
		}

		if (numOpenNetworks > 0) {
		if (++mNumScansSinceNetworkStateChange >= NUM_SCANS_BEFORE_ACTUALLY_SCANNING) {
		/*
		* We've scanned continuously at least
		* NUM_SCANS_BEFORE_NOTIFICATION times. The user
		* probably does not have a remembered network in range,
		* since otherwise supplicant would have tried to
		* associate and thus resetting this counter.
		*/
		setNotificationVisible(true, numOpenNetworks, false, 0);
		}
		return;
		}
		}
		}

		// No open networks in range, remove the notification
		setNotificationVisible(false, 0, false, 0);
		}

		/**
		* Clears variables related to tracking whether a notification has been
		* shown recently and clears the current notification.
		*/
		private synchronized void resetNotification() {
		mNotificationRepeatTime = 0;
		mNumScansSinceNetworkStateChange = 0;
		setNotificationVisible(false, 0, false, 0);
		}

		/**
		* Display or don't display a notification that there are open Wi-Fi networks.
		* @param visible {@code true} if notification should be visible, {@code false} otherwise
		* @param numNetworks the number networks seen
		* @param force {@code true} to force notification to be shown/not-shown,
		* even if it is already shown/not-shown.
		* @param delay time in milliseconds after which the notification should be made
		* visible or invisible.
		*/
		private void setNotificationVisible(boolean visible, int numNetworks, boolean force,
		int delay) {

		// Since we use auto cancel on the notification, when the
		// mNetworksAvailableNotificationShown is true, the notification may
		// have actually been canceled. However, when it is false we know
		// for sure that it is not being shown (it will not be shown any other
		// place than here)

		// If it should be hidden and it is already hidden, then noop
		if (!visible && !mNotificationShown && !force) {
		return;
		}

		NotificationManager notificationManager = (NotificationManager) mContext
		.getSystemService(Context.NOTIFICATION_SERVICE);

		Message message;
		if (visible) {

		// Not enough time has passed to show the notification again
		if (System.currentTimeMillis() < mNotificationRepeatTime) {
		return;
		}

		if (mNotification == null) {
		// Cache the Notification object.
		mNotification = new Notification();
		mNotification.when = 0;
		mNotification.icon = ICON_NETWORKS_AVAILABLE;
		mNotification.flags = Notification.FLAG_AUTO_CANCEL;
		mNotification.contentIntent = TaskStackBuilder.create(mContext)
		.addNextIntentWithParentStack(
		new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK))
		.getPendingIntent(0, 0, null, UserHandle.CURRENT);
		}

		CharSequence title = mContext.getResources().getQuantityText(
		com.android.internal.R.plurals.wifi_available, numNetworks);
		CharSequence details = mContext.getResources().getQuantityText(
		com.android.internal.R.plurals.wifi_available_detailed, numNetworks);
		mNotification.tickerText = title;
		mNotification.setLatestEventInfo(mContext, title, details, mNotification.contentIntent);

		mNotificationRepeatTime = System.currentTimeMillis() + NOTIFICATION_REPEAT_DELAY_MS;

		notificationManager.notifyAsUser(null, ICON_NETWORKS_AVAILABLE, mNotification,
		UserHandle.ALL);
		} else {
		notificationManager.cancelAsUser(null, ICON_NETWORKS_AVAILABLE, UserHandle.ALL);
		}

		mNotificationShown = visible;
		}

		void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
		pw.println("mNotificationEnabled " + mNotificationEnabled);
		pw.println("mNotificationRepeatTime " + mNotificationRepeatTime);
		pw.println("mNotificationShown " + mNotificationShown);
		pw.println("mNumScansSinceNetworkStateChange " + mNumScansSinceNetworkStateChange);
		}

		private class NotificationEnabledSettingObserver extends ContentObserver {
		public NotificationEnabledSettingObserver(Handler handler) {
		super(handler);
		}

		public void register() {
		ContentResolver cr = mContext.getContentResolver();
		cr.registerContentObserver(Settings.Global.getUriFor(
		Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON), true, this);
		synchronized (WifiNotificationController.this) {
		mNotificationEnabled = getValue();
		}
		}

		@Override
		public void onChange(boolean selfChange) {
		super.onChange(selfChange);

		synchronized (WifiNotificationController.this) {
		mNotificationEnabled = getValue();
		resetNotification();
		}
		}

		private boolean getValue() {
		return Settings.Global.getInt(mContext.getContentResolver(),
		Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1) == 1;
		}
		}

		}

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

+45 −492

File changed.

Preview size limit exceeded, changes collapsed.

services/java/com/android/server/wifi/WifiSettingsStore.java

0 → 100644

+167 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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.content.ContentResolver;
		import android.content.Context;
		import android.provider.Settings;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;

		/* Tracks persisted settings for Wi-Fi and airplane mode interaction */
		final class WifiSettingsStore {
		/* Values tracked in Settings.Global.WIFI_ON */
		private static final int WIFI_DISABLED = 0;
		private static final int WIFI_ENABLED = 1;
		/* Wifi enabled while in airplane mode */
		private static final int WIFI_ENABLED_AIRPLANE_OVERRIDE = 2;
		/* Wifi disabled due to airplane mode on */
		private static final int WIFI_DISABLED_AIRPLANE_ON = 3;

		/* Persisted state that tracks the wifi & airplane interaction from settings */
		private int mPersistWifiState = WIFI_DISABLED;
		/* Tracks current airplane mode state */
		private boolean mAirplaneModeOn = false;
		/* Tracks whether wifi is enabled from WifiStateMachine's perspective */
		private final Context mContext;

		/* Tracks if we have checked the saved wi-fi state after boot */
		private boolean mCheckSavedStateAtBoot = false;

		WifiSettingsStore(Context context) {
		mContext = context;
		mAirplaneModeOn = getPersistedAirplaneModeOn();
		mPersistWifiState = getPersistedWifiState();
		}

		synchronized boolean shouldWifiBeEnabled() {
		if (!mCheckSavedStateAtBoot) {
		mCheckSavedStateAtBoot = true;
		if (testAndClearWifiSavedState()) return true;
		}

		if (mAirplaneModeOn) {
		return mPersistWifiState == WIFI_ENABLED_AIRPLANE_OVERRIDE;
		} else {
		return mPersistWifiState != WIFI_DISABLED;
		}
		}

		/**
		* Returns true if airplane mode is currently on.
		* @return {@code true} if airplane mode is on.
		*/
		synchronized boolean isAirplaneModeOn() {
		return mAirplaneModeOn;
		}

		synchronized void handleWifiToggled(boolean wifiEnabled) {
		boolean airplaneEnabled = mAirplaneModeOn && isAirplaneToggleable();
		if (wifiEnabled) {
		if (airplaneEnabled) {
		persistWifiState(WIFI_ENABLED_AIRPLANE_OVERRIDE);
		} else {
		persistWifiState(WIFI_ENABLED);
		}
		} else {
		// When wifi state is disabled, we do not care
		// if airplane mode is on or not. The scenario of
		// wifi being disabled due to airplane mode being turned on
		// is handled handleAirplaneModeToggled()
		persistWifiState(WIFI_DISABLED);
		}
		}

		synchronized void handleAirplaneModeToggled() {
		mAirplaneModeOn = getPersistedAirplaneModeOn();
		if (mAirplaneModeOn) {
		// Wifi disabled due to airplane on
		if (mPersistWifiState == WIFI_ENABLED) {
		persistWifiState(WIFI_DISABLED_AIRPLANE_ON);
		}
		} else {
		/* On airplane mode disable, restore wifi state if necessary */
		if (testAndClearWifiSavedState() \|\|
		mPersistWifiState == WIFI_ENABLED_AIRPLANE_OVERRIDE) {
		persistWifiState(WIFI_ENABLED);
		}
		}
		}

		void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
		pw.println("mPersistWifiState " + mPersistWifiState);
		pw.println("mAirplaneModeOn " + mAirplaneModeOn);
		}

		private void persistWifiState(int state) {
		final ContentResolver cr = mContext.getContentResolver();
		mPersistWifiState = state;
		Settings.Global.putInt(cr, Settings.Global.WIFI_ON, state);
		}

		/* Does Wi-Fi need to be disabled when airplane mode is on ? */
		private boolean isAirplaneSensitive() {
		String airplaneModeRadios = Settings.Global.getString(mContext.getContentResolver(),
		Settings.Global.AIRPLANE_MODE_RADIOS);
		return airplaneModeRadios == null
		\|\| airplaneModeRadios.contains(Settings.Global.RADIO_WIFI);
		}

		/* Is Wi-Fi allowed to be re-enabled while airplane mode is on ? */
		private boolean isAirplaneToggleable() {
		String toggleableRadios = Settings.Global.getString(mContext.getContentResolver(),
		Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS);
		return toggleableRadios != null
		&& toggleableRadios.contains(Settings.Global.RADIO_WIFI);
		}

		/* After a reboot, we restore wi-fi to be on if it was turned off temporarily for tethering.
		* The settings app tracks the saved state, but the framework has to check it at boot to
		* make sure the wi-fi is turned on in case it was turned off for the purpose of tethering.
		*
		* Note that this is not part of the regular WIFI_ON setting because this only needs to
		* be controlled through the settings app and not the Wi-Fi public API.
		*/
		private boolean testAndClearWifiSavedState() {
		final ContentResolver cr = mContext.getContentResolver();
		int wifiSavedState = 0;
		try {
		wifiSavedState = Settings.Global.getInt(cr, Settings.Global.WIFI_SAVED_STATE);
		if(wifiSavedState == 1)
		Settings.Global.putInt(cr, Settings.Global.WIFI_SAVED_STATE, 0);
		} catch (Settings.SettingNotFoundException e) {
		;
		}
		return (wifiSavedState == 1);
		}

		private int getPersistedWifiState() {
		final ContentResolver cr = mContext.getContentResolver();
		try {
		return Settings.Global.getInt(cr, Settings.Global.WIFI_ON);
		} catch (Settings.SettingNotFoundException e) {
		Settings.Global.putInt(cr, Settings.Global.WIFI_ON, WIFI_DISABLED);
		return WIFI_DISABLED;
		}
		}

		private boolean getPersistedAirplaneModeOn() {
		return isAirplaneSensitive() && Settings.Global.getInt(mContext.getContentResolver(),
		Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
		}
		}

services/java/com/android/server/wifi/WifiTrafficPoller.java

0 → 100644

+163 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.net.NetworkInfo;
		import static android.net.NetworkInfo.DetailedState.CONNECTED;
		import android.net.TrafficStats;
		import android.net.wifi.WifiManager;
		import android.os.Handler;
		import android.os.Message;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.util.List;
		import java.util.concurrent.atomic.AtomicBoolean;

		import com.android.internal.util.AsyncChannel;

		/* Polls for traffic stats and notifies the clients */
		final class WifiTrafficPoller {
		/**
		* Interval in milliseconds between polling for traffic
		* statistics
		*/
		private static final int POLL_TRAFFIC_STATS_INTERVAL_MSECS = 1000;

		private boolean mEnableTrafficStatsPoll = false;
		private int mTrafficStatsPollToken = 0;
		private long mTxPkts;
		private long mRxPkts;
		/* Tracks last reported data activity */
		private int mDataActivity;

		private final List<AsyncChannel> mClients;
		// err on the side of updating at boot since screen on broadcast may be missed
		// the first time
		private AtomicBoolean mScreenOn = new AtomicBoolean(true);
		private final TrafficHandler mTrafficHandler;
		private NetworkInfo mNetworkInfo;
		private final String mInterface;

		WifiTrafficPoller(Context context, List<AsyncChannel> clients, String iface) {
		mClients = clients;
		mInterface = iface;
		mTrafficHandler = new TrafficHandler();

		IntentFilter filter = new IntentFilter();
		filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
		filter.addAction(Intent.ACTION_SCREEN_OFF);
		filter.addAction(Intent.ACTION_SCREEN_ON);

		context.registerReceiver(
		new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		if (intent.getAction().equals(
		WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
		mNetworkInfo = (NetworkInfo) intent.getParcelableExtra(
		WifiManager.EXTRA_NETWORK_INFO);
		} else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
		mScreenOn.set(false);
		} else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
		mScreenOn.set(true);
		}
		evaluateTrafficStatsPolling();
		}
		}, filter);
		}


		private class TrafficHandler extends Handler {
		public void handleMessage(Message msg) {
		switch (msg.what) {
		case WifiManager.ENABLE_TRAFFIC_STATS_POLL: {
		mEnableTrafficStatsPoll = (msg.arg1 == 1);
		mTrafficStatsPollToken++;
		if (mEnableTrafficStatsPoll) {
		notifyOnDataActivity();
		sendMessageDelayed(Message.obtain(this, WifiManager.TRAFFIC_STATS_POLL,
		mTrafficStatsPollToken, 0), POLL_TRAFFIC_STATS_INTERVAL_MSECS);
		}
		break;
		}
		case WifiManager.TRAFFIC_STATS_POLL: {
		if (msg.arg1 == mTrafficStatsPollToken) {
		notifyOnDataActivity();
		sendMessageDelayed(Message.obtain(this, WifiManager.TRAFFIC_STATS_POLL,
		mTrafficStatsPollToken, 0), POLL_TRAFFIC_STATS_INTERVAL_MSECS);
		}
		break;
		}
		}

		}
		}

		private void evaluateTrafficStatsPolling() {
		Message msg;
		if (mNetworkInfo == null) return;
		if (mNetworkInfo.getDetailedState() == CONNECTED && mScreenOn.get()) {
		msg = Message.obtain(mTrafficHandler,
		WifiManager.ENABLE_TRAFFIC_STATS_POLL, 1, 0);
		} else {
		msg = Message.obtain(mTrafficHandler,
		WifiManager.ENABLE_TRAFFIC_STATS_POLL, 0, 0);
		}
		msg.sendToTarget();
		}

		private void notifyOnDataActivity() {
		long sent, received;
		long preTxPkts = mTxPkts, preRxPkts = mRxPkts;
		int dataActivity = WifiManager.DATA_ACTIVITY_NONE;

		mTxPkts = TrafficStats.getTxPackets(mInterface);
		mRxPkts = TrafficStats.getRxPackets(mInterface);

		if (preTxPkts > 0 \|\| preRxPkts > 0) {
		sent = mTxPkts - preTxPkts;
		received = mRxPkts - preRxPkts;
		if (sent > 0) {
		dataActivity \|= WifiManager.DATA_ACTIVITY_OUT;
		}
		if (received > 0) {
		dataActivity \|= WifiManager.DATA_ACTIVITY_IN;
		}

		if (dataActivity != mDataActivity && mScreenOn.get()) {
		mDataActivity = dataActivity;
		for (AsyncChannel client : mClients) {
		client.sendMessage(WifiManager.DATA_ACTIVITY_NOTIFICATION, mDataActivity);
		}
		}
		}
		}

		void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
		pw.println("mEnableTrafficStatsPoll " + mEnableTrafficStatsPoll);
		pw.println("mTrafficStatsPollToken " + mTrafficStatsPollToken);
		pw.println("mTxPkts " + mTxPkts);
		pw.println("mRxPkts " + mRxPkts);
		pw.println("mDataActivity " + mDataActivity);
		}

		}