diff --git a/res/values/strings.xml b/res/values/strings.xml index b9e9c1c67a8..39e0cc58c56 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -1582,9 +1582,13 @@ In Airplane mode - Network notification + Open network notification - Notify whenever a public network is available + Notify whenever a high quality open network is available + + Turn Wi\u2011Fi back on + + Automatically turn on Wi\u2011Fi near saved networks Avoid poor connections diff --git a/res/xml/wifi_configure_settings.xml b/res/xml/wifi_configure_settings.xml index 91df2fe7edc..a43ea87f9f8 100644 --- a/res/xml/wifi_configure_settings.xml +++ b/res/xml/wifi_configure_settings.xml @@ -23,11 +23,6 @@ android:fragment="com.android.settings.wifi.SavedAccessPointsWifiSettings" /> - - + + + + controllers = new ArrayList<>(); controllers.add(new WifiInfoPreferenceController(context, getLifecycle(), mWifiManager)); controllers.add(new SavedNetworkPreferenceController(context, mWifiManager)); - controllers.add(new NotifyOpenNetworksPreferenceController(context, mWifiManager)); controllers.add(new CellularFallbackPreferenceController(context)); controllers.add(new AllowRecommendationPreferenceController(context)); + controllers.add(new NotifyOpenNetworksPreferenceController(context, getLifecycle())); + controllers.add(new WifiWakeupPreferenceController(context, getLifecycle())); controllers.add(new WifiSleepPolicyPreferenceController(context)); return controllers; } diff --git a/src/com/android/settings/wifi/NotifyOpenNetworksPreferenceController.java b/src/com/android/settings/wifi/NotifyOpenNetworksPreferenceController.java index df3aa26b331..8771da48a69 100644 --- a/src/com/android/settings/wifi/NotifyOpenNetworksPreferenceController.java +++ b/src/com/android/settings/wifi/NotifyOpenNetworksPreferenceController.java @@ -16,27 +16,56 @@ package com.android.settings.wifi; +import android.content.ContentResolver; import android.content.Context; -import android.net.wifi.WifiManager; +import android.database.ContentObserver; +import android.net.Uri; +import android.os.Handler; import android.provider.Settings; 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.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 we should notify user when open network is * available. */ -public class NotifyOpenNetworksPreferenceController extends PreferenceController { +public class NotifyOpenNetworksPreferenceController extends PreferenceController implements + LifecycleObserver, OnResume, OnPause { private static final String KEY_NOTIFY_OPEN_NETWORKS = "notify_open_networks"; - private final WifiManager mWifiManager; + private SettingObserver mSettingObserver; - public NotifyOpenNetworksPreferenceController(Context context, WifiManager wifiManager) { + public NotifyOpenNetworksPreferenceController(Context context, Lifecycle lifecycle) { super(context); - mWifiManager = wifiManager; + lifecycle.addObserver(this); + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mSettingObserver = new SettingObserver(screen.findPreference(KEY_NOTIFY_OPEN_NETWORKS)); + } + + @Override + public void onResume() { + if (mSettingObserver != null) { + mSettingObserver.register(mContext.getContentResolver(), true /* register */); + } + } + + @Override + public void onPause() { + if (mSettingObserver != null) { + mSettingObserver.register(mContext.getContentResolver(), false /* register */); + } } @Override @@ -71,6 +100,35 @@ public class NotifyOpenNetworksPreferenceController extends PreferenceController final SwitchPreference notifyOpenNetworks = (SwitchPreference) preference; notifyOpenNetworks.setChecked(Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0) == 1); - notifyOpenNetworks.setEnabled(mWifiManager.isWifiEnabled()); + notifyOpenNetworks.setEnabled(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0) == 1); + } + + class SettingObserver extends ContentObserver { + private final Uri NETWORK_RECOMMENDATIONS_ENABLED_URI = + Settings.Global.getUriFor(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED); + + private final Preference mPreference; + + public SettingObserver(Preference preference) { + super(new Handler()); + mPreference = preference; + } + + public void register(ContentResolver cr, boolean register) { + if (register) { + cr.registerContentObserver(NETWORK_RECOMMENDATIONS_ENABLED_URI, false, this); + } else { + cr.unregisterContentObserver(this); + } + } + + @Override + public void onChange(boolean selfChange, Uri uri) { + super.onChange(selfChange, uri); + if (NETWORK_RECOMMENDATIONS_ENABLED_URI.equals(uri)) { + updateState(mPreference); + } + } } } diff --git a/src/com/android/settings/wifi/WifiWakeupPreferenceController.java b/src/com/android/settings/wifi/WifiWakeupPreferenceController.java new file mode 100644 index 00000000000..122e524a7c0 --- /dev/null +++ b/src/com/android/settings/wifi/WifiWakeupPreferenceController.java @@ -0,0 +1,133 @@ +/* + * 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 android.content.ContentResolver; +import android.content.Context; +import android.database.ContentObserver; +import android.net.Uri; +import android.os.Handler; +import android.provider.Settings; +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.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 the Wi-Fi Wakeup feature should be enabled. + */ +public class WifiWakeupPreferenceController extends PreferenceController implements + LifecycleObserver, OnResume, OnPause { + + private static final String KEY_ENABLE_WIFI_WAKEUP = "enable_wifi_wakeup"; + private SettingObserver mSettingObserver; + + public WifiWakeupPreferenceController(Context context, Lifecycle lifecycle) { + super(context); + lifecycle.addObserver(this); + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mSettingObserver = new SettingObserver(screen.findPreference(KEY_ENABLE_WIFI_WAKEUP)); + } + + @Override + public void onResume() { + if (mSettingObserver != null) { + mSettingObserver.register(mContext.getContentResolver(), true /* register */); + } + } + + @Override + public void onPause() { + if (mSettingObserver != null) { + mSettingObserver.register(mContext.getContentResolver(), false /* register */); + } + } + + @Override + public boolean isAvailable() { + return true; + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + if (!TextUtils.equals(preference.getKey(), KEY_ENABLE_WIFI_WAKEUP)) { + return false; + } + if (!(preference instanceof SwitchPreference)) { + return false; + } + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.WIFI_WAKEUP_ENABLED, + ((SwitchPreference) preference).isChecked() ? 1 : 0); + return true; + } + + @Override + public String getPreferenceKey() { + return KEY_ENABLE_WIFI_WAKEUP; + } + + @Override + public void updateState(Preference preference) { + if (!(preference instanceof SwitchPreference)) { + return; + } + final SwitchPreference enableWifiWakeup = (SwitchPreference) preference; + enableWifiWakeup.setChecked(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.WIFI_WAKEUP_ENABLED, 0) == 1); + enableWifiWakeup.setEnabled(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0) == 1); + } + + class SettingObserver extends ContentObserver { + private final Uri NETWORK_RECOMMENDATIONS_ENABLED_URI = + Settings.Global.getUriFor(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED); + + private final Preference mPreference; + + public SettingObserver(Preference preference) { + super(new Handler()); + mPreference = preference; + } + + public void register(ContentResolver cr, boolean register) { + if (register) { + cr.registerContentObserver(NETWORK_RECOMMENDATIONS_ENABLED_URI, false, this); + } else { + cr.unregisterContentObserver(this); + } + } + + @Override + public void onChange(boolean selfChange, Uri uri) { + super.onChange(selfChange, uri); + if (NETWORK_RECOMMENDATIONS_ENABLED_URI.equals(uri)) { + updateState(mPreference); + } + } + } +} diff --git a/tests/robotests/src/com/android/settings/wifi/NotifyOpenNetworkPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/wifi/NotifyOpenNetworkPreferenceControllerTest.java index aa127877655..3afa7fbef67 100644 --- a/tests/robotests/src/com/android/settings/wifi/NotifyOpenNetworkPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/wifi/NotifyOpenNetworkPreferenceControllerTest.java @@ -16,31 +16,34 @@ package com.android.settings.wifi; +import static android.provider.Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED; +import static android.provider.Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + import android.content.Context; -import android.net.wifi.WifiManager; import android.provider.Settings; import android.support.v14.preference.SwitchPreference; import android.support.v7.preference.Preference; 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.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; -import static com.google.common.truth.Truth.assertThat; - @RunWith(SettingsRobolectricTestRunner.class) @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) public class NotifyOpenNetworkPreferenceControllerTest { - @Mock - private WifiManager mWifiManager; private Context mContext; private NotifyOpenNetworksPreferenceController mController; @@ -48,7 +51,7 @@ public class NotifyOpenNetworkPreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); mContext = RuntimeEnvironment.application; - mController = new NotifyOpenNetworksPreferenceController(mContext, mWifiManager); + mController = new NotifyOpenNetworksPreferenceController(mContext, mock(Lifecycle.class)); } @Test @@ -71,7 +74,6 @@ public class NotifyOpenNetworkPreferenceControllerTest { assertThat(mController.handlePreferenceTreeClick(pref)).isFalse(); } - @Test public void handlePreferenceTreeClick_matchingKeyAndType_shouldUpdateSetting() { final SwitchPreference pref = new SwitchPreference(mContext); @@ -80,8 +82,33 @@ public class NotifyOpenNetworkPreferenceControllerTest { assertThat(mController.handlePreferenceTreeClick(pref)).isTrue(); assertThat(Settings.Global.getInt(mContext.getContentResolver(), - Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0)) + WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0)) .isEqualTo(1); } + @Test + public void updateState_preferenceSetCheckedAndSetEnabledWhenSettingsAreEnabled() { + final SwitchPreference preference = mock(SwitchPreference.class); + Settings.System.putInt(mContext.getContentResolver(), NETWORK_RECOMMENDATIONS_ENABLED, 1); + Settings.System.putInt(mContext.getContentResolver(), + WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1); + + mController.updateState(preference); + + verify(preference).setChecked(true); + verify(preference).setEnabled(true); + } + + @Test + public void updateState_preferenceSetCheckedAndSetEnabledWhenSettingsAreDisabled() { + final SwitchPreference preference = mock(SwitchPreference.class); + Settings.System.putInt(mContext.getContentResolver(), NETWORK_RECOMMENDATIONS_ENABLED, 0); + Settings.System.putInt(mContext.getContentResolver(), + WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 0); + + mController.updateState(preference); + + verify(preference).setChecked(false); + verify(preference).setEnabled(false); + } } diff --git a/tests/robotests/src/com/android/settings/wifi/WifiWakeupPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/wifi/WifiWakeupPreferenceControllerTest.java new file mode 100644 index 00000000000..d6243aca178 --- /dev/null +++ b/tests/robotests/src/com/android/settings/wifi/WifiWakeupPreferenceControllerTest.java @@ -0,0 +1,111 @@ +/* + * 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.NETWORK_RECOMMENDATIONS_ENABLED; +import static android.provider.Settings.Global.WIFI_WAKEUP_ENABLED; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import android.content.Context; +import android.provider.Settings; +import android.support.v14.preference.SwitchPreference; +import android.support.v7.preference.Preference; + +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.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.annotation.Config; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class WifiWakeupPreferenceControllerTest { + + private Context mContext; + private WifiWakeupPreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mController = new WifiWakeupPreferenceController(mContext, mock(Lifecycle.class)); + } + + @Test + public void testIsAvailable_shouldAlwaysReturnTrue() { + assertThat(mController.isAvailable()).isTrue(); + } + + @Test + public void handlePreferenceTreeClick_nonMatchingKey_shouldDoNothing() { + final SwitchPreference pref = new SwitchPreference(mContext); + + assertThat(mController.handlePreferenceTreeClick(pref)).isFalse(); + } + + @Test + public void handlePreferenceTreeClick_nonMatchingType_shouldDoNothing() { + final Preference pref = new Preference(mContext); + pref.setKey(mController.getPreferenceKey()); + + assertThat(mController.handlePreferenceTreeClick(pref)).isFalse(); + } + + @Test + public void handlePreferenceTreeClick_matchingKeyAndType_shouldUpdateSetting() { + final SwitchPreference pref = new SwitchPreference(mContext); + pref.setChecked(true); + pref.setKey(mController.getPreferenceKey()); + + assertThat(mController.handlePreferenceTreeClick(pref)).isTrue(); + assertThat(Settings.Global.getInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 0)) + .isEqualTo(1); + } + + @Test + public void updateState_preferenceSetCheckedAndSetEnabledWhenSettingsAreEnabled() { + final SwitchPreference preference = mock(SwitchPreference.class); + Settings.System.putInt(mContext.getContentResolver(), NETWORK_RECOMMENDATIONS_ENABLED, 1); + Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1); + + mController.updateState(preference); + + verify(preference).setChecked(true); + verify(preference).setEnabled(true); + } + + @Test + public void updateState_preferenceSetCheckedAndSetEnabledWhenSettingsAreDisabled() { + final SwitchPreference preference = mock(SwitchPreference.class); + Settings.System.putInt(mContext.getContentResolver(), NETWORK_RECOMMENDATIONS_ENABLED, 0); + Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 0); + + mController.updateState(preference); + + verify(preference).setChecked(false); + verify(preference).setEnabled(false); + } +}