Merge "Add "Use open Wi-Fi automatically" setting." (0fea0d33) · Commits · e / os / android_packages_apps_Settings

res/values/strings.xml

+7 −4

Original line number	Diff line number	Diff line
		@@ -1595,18 +1595,21 @@
		<!-- Checkbox title for option to notify user when open networks are nearby -->
		<string name="wifi_notify_open_networks">Open network notification</string>
		<!-- Checkbox summary for option to notify user when open networks are nearby-->
		<string name="wifi_notify_open_networks_summary">Notify whenever a high quality open network is available</string>
		<string name="wifi_notify_open_networks_summary">Notify when a high\u2011quality open network is available that may require sign\u2011in</string>
		<!-- Checkbox title for option to enable Wi-Fi when saved networks are nearby -->
		<string name="wifi_wakeup">Turn Wi\u2011Fi back on</string>
		<!-- Checkbox summary for option to enable Wi-Fi when saved networks are nearby-->
		<string name="wifi_wakeup_summary">Automatically turn on Wi\u2011Fi near saved networks</string>
		<!-- Checkbox summary for option to enable Wi-Fi when high quality saved networks are nearby-->
		<string name="wifi_wakeup_summary">Automatically turn on Wi\u2011Fi near high\u2011quality saved networks</string>
		<!-- Checkbox title for option to toggle poor network detection -->
		<string name="wifi_poor_network_detection">Avoid poor connections</string>
		<!-- Checkbox summary for option to toggle poor network detection -->
		<string name="wifi_poor_network_detection_summary">Don\u2019t use a Wi\u2011Fi network unless it has a good Internet connection</string>
		<!-- Checkbox summary for option to toggle poor network detection [CHAR LIMIT=60] -->
		<string name="wifi_avoid_poor_network_detection_summary">Only use networks that have a good Internet connection</string>

		<!-- Checkbox title for option to connect to open Wi-Fi automatically [CHAR LIMIT=40] -->
		<string name="use_open_wifi_automatically_title">Connect to open networks</string>
		<!-- Checkbox summary for option to connect to open Wi-Fi automatically [CHAR LIMIT=100] -->
		<string name="use_open_wifi_automatically_summary">Automatically connect to high\u2011quality open networks </string>
		<!-- Preference title for option to install certificates -->
		<string name="wifi_install_credentials">Install certificates</string>
		<!-- Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off. The

res/xml/wifi_configure_settings.xml

+9 −3

Original line number	Diff line number	Diff line
		@@ -25,6 +25,12 @@
		android:icon="@drawable/ic_settings_home"
		android:summary="@string/wifi_wakeup_summary" />

		<SwitchPreference
		android:key="use_open_wifi_automatically"
		android:icon="@drawable/ic_vpn_key"
		android:title="@string/use_open_wifi_automatically_title"
		android:summary="@string/use_open_wifi_automatically_summary" />

		<SwitchPreference
		android:key="notify_open_networks"
		android:title="@string/wifi_notify_open_networks"

src/com/android/settings/wifi/ConfigureWifiSettings.java

+24 −10

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@ import static android.content.Context.NETWORK_SCORE_SERVICE;
		import static android.content.Context.WIFI_SERVICE;

		import android.content.Context;
		import android.content.Intent;
		import android.net.NetworkScoreManager;
		import android.net.wifi.WifiManager;
		import android.provider.SearchIndexableResource;
		@@ -43,7 +44,7 @@ public class ConfigureWifiSettings extends DashboardFragment {

		private static final String TAG = "ConfigureWifiSettings";

		private WifiManager mWifiManager;
		private UseOpenWifiPreferenceController mUseOpenWifiPreferenceController;

		@Override
		public int getMetricsCategory() {
		@@ -58,7 +59,8 @@ public class ConfigureWifiSettings extends DashboardFragment {
		@Override
		public void onAttach(Context context) {
		super.onAttach(context);
		mProgressiveDisclosureMixin.setTileLimit(2);
		mProgressiveDisclosureMixin.setTileLimit(
		mUseOpenWifiPreferenceController.isAvailable() ? 3 : 2);
		((SettingsActivity) getActivity()).setDisplaySearchMenu(true);
		}

		@@ -69,23 +71,35 @@ public class ConfigureWifiSettings extends DashboardFragment {

		@Override
		protected List<PreferenceController> getPreferenceControllers(Context context) {
		mWifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
		final NetworkScoreManagerWrapper networkScoreManagerWrapper =
		new NetworkScoreManagerWrapper(context.getSystemService(NetworkScoreManager.class));
		mUseOpenWifiPreferenceController = new UseOpenWifiPreferenceController(context, this,
		networkScoreManagerWrapper, getLifecycle());
		final WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
		final List<PreferenceController> controllers = new ArrayList<>();
		controllers.add(new WifiInfoPreferenceController(context, getLifecycle(), mWifiManager));
		controllers.add(new CellularFallbackPreferenceController(context));
		controllers.add(new NotifyOpenNetworksPreferenceController(context, getLifecycle()));
		controllers.add(new WifiWakeupPreferenceController(context, getLifecycle()));
		controllers.add(new NetworkScorerPickerPreferenceController(context,
		new NetworkScoreManagerWrapper(
		(NetworkScoreManager) getSystemService(NETWORK_SCORE_SERVICE))));
		networkScoreManagerWrapper));
		controllers.add(new NotifyOpenNetworksPreferenceController(context, getLifecycle()));
		controllers.add(mUseOpenWifiPreferenceController);
		controllers.add(new WifiSleepPolicyPreferenceController(context));
		controllers.add(new WifiP2pPreferenceController(context, getLifecycle(), mWifiManager));
		controllers.add(new WifiInfoPreferenceController(context, getLifecycle(), wifiManager));
		controllers.add(new CellularFallbackPreferenceController(context));
		controllers.add(new WifiP2pPreferenceController(context, getLifecycle(), wifiManager));
		controllers.add(new WifiCallingPreferenceController(context));
		controllers.add(new WpsPreferenceController(
		context, getLifecycle(), mWifiManager, getFragmentManager()));
		context, getLifecycle(), wifiManager, getFragmentManager()));
		return controllers;
		}

		@Override
		public void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (mUseOpenWifiPreferenceController == null \|\|
		!mUseOpenWifiPreferenceController.onActivityResult(requestCode, resultCode)) {
		super.onActivityResult(requestCode, resultCode, data);
		}
		}

		public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
		new BaseSearchIndexProvider() {
		@Override

src/com/android/settings/wifi/UseOpenWifiPreferenceController.java

0 → 100644

+165 −0

Original line number	Diff line number	Diff line
		package com.android.settings.wifi;

		import android.app.Activity;
		import android.app.Fragment;
		import android.content.ComponentName;
		import android.content.ContentResolver;
		import android.content.Context;
		import android.content.Intent;
		import android.database.ContentObserver;
		import android.net.NetworkScoreManager;

		import android.net.NetworkScorerAppData;
		import android.net.Uri;
		import android.os.Handler;
		import android.os.Looper;
		import android.provider.Settings;
		import android.support.annotation.VisibleForTesting;
		import android.support.v14.preference.SwitchPreference;
		import android.support.v7.preference.Preference;
		import android.support.v7.preference.PreferenceScreen;
		import android.text.TextUtils;

		import com.android.settings.network.NetworkScoreManagerWrapper;
		import com.android.settings.core.PreferenceController;
		import com.android.settings.core.lifecycle.Lifecycle;
		import com.android.settings.core.lifecycle.LifecycleObserver;
		import com.android.settings.core.lifecycle.events.OnPause;
		import com.android.settings.core.lifecycle.events.OnResume;

		/**
		* {@link PreferenceController} that controls whether a user wants to enable the "use open networks
		* automatically" feature provider by the current network recommendation provider.
		*/
		public class UseOpenWifiPreferenceController extends PreferenceController
		implements Preference.OnPreferenceChangeListener, LifecycleObserver, OnResume, OnPause {
		private static final String KEY_USE_OPEN_WIFI_AUTOMATICALLY = "use_open_wifi_automatically";
		@VisibleForTesting static final int REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY = 400;

		private final ContentResolver mContentResolver;
		private final Fragment mFragment;
		private final NetworkScoreManagerWrapper mNetworkScoreManagerWrapper;
		private final SettingObserver mSettingObserver;

		private Preference mPreference;
		private ComponentName mEnableUseWifiComponentName;

		public UseOpenWifiPreferenceController(Context context, Fragment fragment,
		NetworkScoreManagerWrapper networkScoreManagerWrapper, Lifecycle lifecycle) {
		super(context);
		mContentResolver = context.getContentResolver();
		mFragment = fragment;
		mNetworkScoreManagerWrapper = networkScoreManagerWrapper;
		mSettingObserver = new SettingObserver();
		updateEnableUseWifiComponentName();
		lifecycle.addObserver(this);
		}

		private void updateEnableUseWifiComponentName() {
		NetworkScorerAppData appData = mNetworkScoreManagerWrapper.getActiveScorer();
		mEnableUseWifiComponentName =
		appData == null ? null : appData.getEnableUseOpenWifiActivity();
		}

		@Override
		public void displayPreference(PreferenceScreen screen) {
		super.displayPreference(screen);
		mPreference = screen.findPreference(KEY_USE_OPEN_WIFI_AUTOMATICALLY);
		}

		@Override
		public void onResume() {
		mSettingObserver.register(mContentResolver);
		}

		@Override
		public void onPause() {
		mSettingObserver.unregister(mContentResolver);
		}

		@Override
		public boolean isAvailable() {
		return mEnableUseWifiComponentName != null;
		}

		@Override
		public String getPreferenceKey() {
		return KEY_USE_OPEN_WIFI_AUTOMATICALLY;
		}

		@Override
		public void updateState(Preference preference) {
		if (!(preference instanceof SwitchPreference)) {
		return;
		}
		final SwitchPreference useOpenWifiPreference = (SwitchPreference) preference;
		useOpenWifiPreference.setVisible(isAvailable());
		useOpenWifiPreference.setChecked(isSettingEnabled());
		}

		@Override
		public boolean onPreferenceChange(Preference preference, Object newValue) {
		if (!TextUtils.equals(preference.getKey(), KEY_USE_OPEN_WIFI_AUTOMATICALLY)
		\|\| !isAvailable()) {
		return false;
		}

		if (isSettingEnabled()) {
		Settings.Global.putString(mContentResolver,
		Settings.Global.USE_OPEN_WIFI_PACKAGE, "");
		return true;
		}

		Intent intent = new Intent(NetworkScoreManager.ACTION_CUSTOM_ENABLE);
		intent.setComponent(mEnableUseWifiComponentName);
		mFragment.startActivityForResult(intent, REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY);
		return false; // Updating state is done in onActivityResult.
		}

		private boolean isSettingEnabled() {
		String enabledUseOpenWifiPackage = Settings.Global.getString(mContentResolver,
		Settings.Global.USE_OPEN_WIFI_PACKAGE);
		String currentUseOpenWifiPackage = mEnableUseWifiComponentName == null
		? null : mEnableUseWifiComponentName.getPackageName();
		return TextUtils.equals(enabledUseOpenWifiPackage, currentUseOpenWifiPackage);
		}

		public boolean onActivityResult(int requestCode, int resultCode) {
		if (requestCode != REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY) {
		return false;
		}

		if (resultCode == Activity.RESULT_OK) {
		Settings.Global.putString(mContentResolver, Settings.Global.USE_OPEN_WIFI_PACKAGE,
		mEnableUseWifiComponentName.getPackageName());
		}
		return true;
		}

		class SettingObserver extends ContentObserver {
		private final Uri NETWORK_RECOMMENDATIONS_ENABLED_URI =
		Settings.Global.getUriFor(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED);

		public SettingObserver() {
		super(new Handler(Looper.getMainLooper()));
		}

		public void register(ContentResolver cr) {
		cr.registerContentObserver(NETWORK_RECOMMENDATIONS_ENABLED_URI, false, this);
		onChange(true /* selfChange */, NETWORK_RECOMMENDATIONS_ENABLED_URI);
		}

		public void unregister(ContentResolver cr) {
		cr.unregisterContentObserver(this);
		}

		@Override
		public void onChange(boolean selfChange, Uri uri) {
		super.onChange(selfChange, uri);
		if (NETWORK_RECOMMENDATIONS_ENABLED_URI.equals(uri)) {
		updateEnableUseWifiComponentName();
		updateState(mPreference);
		}
		}
		}
		}

tests/robotests/src/com/android/settings/wifi/UseOpenWifiPreferenceControllerTest.java

0 → 100644

+221 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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.settings.wifi;

		import static android.provider.Settings.Global.USE_OPEN_WIFI_PACKAGE;
		import static com.android.settings.wifi.UseOpenWifiPreferenceController.REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY;
		import static com.google.common.truth.Truth.assertThat;

		import static org.mockito.Matchers.eq;
		import static org.mockito.Mockito.mock;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.app.Activity;
		import android.app.Fragment;
		import android.content.ComponentName;
		import android.content.Context;
		import android.content.Intent;
		import android.net.NetworkScoreManager;
		import android.net.NetworkScorerAppData;
		import android.provider.Settings;
		import android.support.v14.preference.SwitchPreference;
		import android.support.v7.preference.Preference;

		import com.android.settings.network.NetworkScoreManagerWrapper;
		import com.android.settings.SettingsRobolectricTestRunner;
		import com.android.settings.TestConfig;
		import com.android.settings.core.lifecycle.Lifecycle;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.ArgumentCaptor;
		import org.mockito.Captor;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;
		import org.robolectric.RuntimeEnvironment;
		import org.robolectric.annotation.Config;

		@RunWith(SettingsRobolectricTestRunner.class)
		@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
		public class UseOpenWifiPreferenceControllerTest {
		private static ComponentName ENABLE_ACTIVITY_COMPONENT = new ComponentName("package", "activityClass");
		private static NetworkScorerAppData APP_DATA =
		new NetworkScorerAppData(0, null, null, ENABLE_ACTIVITY_COMPONENT);
		private static NetworkScorerAppData APP_DATA_NO_ACTIVITY =
		new NetworkScorerAppData(0, null, null, null);

		@Mock private Lifecycle mLifecycle;
		@Mock private Fragment mFragment;
		@Mock private NetworkScoreManagerWrapper mNetworkScoreManagerWrapper;
		@Captor private ArgumentCaptor<Intent> mIntentCaptor;
		private Context mContext;
		private UseOpenWifiPreferenceController mController;

		@Before
		public void setUp() {
		MockitoAnnotations.initMocks(this);

		mContext = RuntimeEnvironment.application;
		}

		private void createController() {
		mController = new UseOpenWifiPreferenceController(
		mContext, mFragment, mNetworkScoreManagerWrapper, mLifecycle);
		}

		@Test
		public void testIsAvailable_noScorer() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(null);

		createController();

		assertThat(mController.isAvailable()).isFalse();
		}

		@Test
		public void testIsAvailable_noEnableActivity() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA_NO_ACTIVITY);

		createController();

		assertThat(mController.isAvailable()).isFalse();
		}

		@Test
		public void testIsAvailable_enableActivityExists() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);

		createController();

		assertThat(mController.isAvailable()).isTrue();
		}

		@Test
		public void onPreferenceChange_nonMatchingKey_shouldDoNothing() {
		createController();

		final SwitchPreference pref = new SwitchPreference(mContext);

		assertThat(mController.onPreferenceChange(pref, null)).isFalse();
		}

		@Test
		public void onPreferenceChange_notAvailable_shouldDoNothing() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA_NO_ACTIVITY);

		createController();

		final Preference pref = new Preference(mContext);
		pref.setKey(mController.getPreferenceKey());

		assertThat(mController.onPreferenceChange(pref, null)).isFalse();
		}

		@Test
		public void onPreferenceChange_matchingKeyAndAvailable_enableShouldStartEnableActivity() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
		createController();

		final SwitchPreference pref = new SwitchPreference(mContext);
		pref.setKey(mController.getPreferenceKey());

		assertThat(mController.onPreferenceChange(pref, null)).isFalse();
		verify(mFragment).startActivityForResult(mIntentCaptor.capture(),
		eq(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY));
		Intent activityIntent = mIntentCaptor.getValue();
		assertThat(activityIntent.getComponent()).isEqualTo(ENABLE_ACTIVITY_COMPONENT);
		assertThat(activityIntent.getAction()).isEqualTo(NetworkScoreManager.ACTION_CUSTOM_ENABLE);
		}

		@Test
		public void onPreferenceChange_matchingKeyAndAvailable_disableShouldUpdateSetting() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
		Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
		ENABLE_ACTIVITY_COMPONENT.getPackageName());

		createController();

		final SwitchPreference pref = new SwitchPreference(mContext);
		pref.setKey(mController.getPreferenceKey());

		assertThat(mController.onPreferenceChange(pref, null)).isTrue();
		assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))
		.isEqualTo("");
		}

		@Test
		public void onActivityResult_nonmatchingRequestCode_shouldDoNothing() {
		createController();

		assertThat(mController.onActivityResult(234 /* requestCode */ , Activity.RESULT_OK))
		.isEqualTo(false);
		assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))
		.isNull();
		}

		@Test
		public void onActivityResult_matchingRequestCode_nonOkResult_shouldDoNothing() {
		createController();

		assertThat(mController
		.onActivityResult(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY, Activity.RESULT_CANCELED))
		.isEqualTo(true);
		assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))
		.isNull();
		}

		@Test
		public void onActivityResult_matchingRequestCode_okResult_updatesSetting() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
		createController();

		assertThat(mController
		.onActivityResult(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY, Activity.RESULT_OK))
		.isEqualTo(true);
		assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))
		.isEqualTo(ENABLE_ACTIVITY_COMPONENT.getPackageName());
		}

		@Test
		public void updateState_preferenceSetCheckedAndSetVisibleWhenSettingsAreEnabled() {
		when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
		createController();

		final SwitchPreference preference = mock(SwitchPreference.class);
		Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
		ENABLE_ACTIVITY_COMPONENT.getPackageName());

		mController.updateState(preference);

		verify(preference).setVisible(true);
		verify(preference).setChecked(true);
		}

		@Test
		public void updateState_preferenceSetCheckedAndSetVisibleWhenSettingsAreDisabled() {
		final SwitchPreference preference = mock(SwitchPreference.class);
		Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE, "");
		createController();

		mController.updateState(preference);

		verify(preference).setVisible(false);
		verify(preference).setChecked(false);
		}
		}