PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove Connect to public network for Network Rating Provider" into sc-dev

Browse Source
This commit is contained in:
Betty Chang
2021-06-03 07:21:04 +00:00
committed by Android (Google) Code Review
parent 032b2b20bc de57c12412
commit f4fafb97ff
4 changed files with 0 additions and 473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
res/xml/wifi_configure_settings.xml
View File

@@ -26,13 +26,6 @@
android:summary="@string/wifi_wakeup_summary" android:summary="@string/wifi_wakeup_summary"
settings:controller="com.android.settings.wifi.WifiWakeupPreferenceController"/> settings:controller="com.android.settings.wifi.WifiWakeupPreferenceController"/>
<SwitchPreference
android:key="use_open_wifi_automatically"
android:icon="@drawable/ic_open_wifi_autoconnect"
android:title="@string/use_open_wifi_automatically_title"
android:summary="@string/use_open_wifi_automatically_summary"
settings:controller="com.android.settings.wifi.UseOpenWifiPreferenceController"/>
<SwitchPreference <SwitchPreference
android:key="notify_open_networks" android:key="notify_open_networks"
android:title="@string/wifi_notify_open_networks" android:title="@string/wifi_notify_open_networks"

8
src/com/android/settings/wifi/ConfigureWifiSettings.java
View File

@@ -42,7 +42,6 @@ public class ConfigureWifiSettings extends DashboardFragment {
public static final int WIFI_WAKEUP_REQUEST_CODE = 600; public static final int WIFI_WAKEUP_REQUEST_CODE = 600;
private WifiWakeupPreferenceController mWifiWakeupPreferenceController; private WifiWakeupPreferenceController mWifiWakeupPreferenceController;
private UseOpenWifiPreferenceController mUseOpenWifiPreferenceController;
@Override @Override
public void onCreate(Bundle icicle) { public void onCreate(Bundle icicle) {
@@ -83,9 +82,6 @@ public class ConfigureWifiSettings extends DashboardFragment {
mWifiWakeupPreferenceController = use(WifiWakeupPreferenceController.class); mWifiWakeupPreferenceController = use(WifiWakeupPreferenceController.class);
mWifiWakeupPreferenceController.setFragment(this); mWifiWakeupPreferenceController.setFragment(this);
mUseOpenWifiPreferenceController = use(UseOpenWifiPreferenceController.class);
mUseOpenWifiPreferenceController.setFragment(this);
} }
@Override @Override
@@ -94,10 +90,6 @@ public class ConfigureWifiSettings extends DashboardFragment {
mWifiWakeupPreferenceController.onActivityResult(requestCode, resultCode); mWifiWakeupPreferenceController.onActivityResult(requestCode, resultCode);
return; return;
} }
if (requestCode == UseOpenWifiPreferenceController.REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY) {
mUseOpenWifiPreferenceController.onActivityResult(requestCode, resultCode);
return;
}
super.onActivityResult(requestCode, resultCode, data); super.onActivityResult(requestCode, resultCode, data);
} }

192
src/com/android/settings/wifi/UseOpenWifiPreferenceController.java
View File

@@ -1,192 +0,0 @@
package com.android.settings.wifi;
import android.app.Activity;
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.text.TextUtils;
import androidx.fragment.app.Fragment;
import androidx.preference.Preference;
import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.core.TogglePreferenceController;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnPause;
import com.android.settingslib.core.lifecycle.events.OnResume;
import java.util.List;
/**
* {@link TogglePreferenceController} that controls whether a user wants to enable the "use open
* networks automatically" feature provided by the current network recommendation provider.
*/
public class UseOpenWifiPreferenceController extends TogglePreferenceController
implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener,
LifecycleObserver, OnResume, OnPause {
public static final int REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY = 400;
private static final String KEY_USE_OPEN_WIFI_AUTOMATICALLY = "use_open_wifi_automatically";
private final ContentResolver mContentResolver;
private Fragment mFragment;
private final NetworkScoreManager mNetworkScoreManager;
private final SettingObserver mSettingObserver;
private Preference mPreference;
private ComponentName mEnableUseWifiComponentName;
private boolean mDoFeatureSupportedScorersExist;
public UseOpenWifiPreferenceController(Context context) {
super(context, KEY_USE_OPEN_WIFI_AUTOMATICALLY);
mContentResolver = context.getContentResolver();
mNetworkScoreManager =
(NetworkScoreManager) context.getSystemService(Context.NETWORK_SCORE_SERVICE);
mSettingObserver = new SettingObserver();
updateEnableUseWifiComponentName();
checkForFeatureSupportedScorers();
}
public void setFragment(Fragment hostFragment) {
mFragment = hostFragment;
}
private void updateEnableUseWifiComponentName() {
NetworkScorerAppData appData = mNetworkScoreManager.getActiveScorer();
mEnableUseWifiComponentName =
appData == null ? null : appData.getEnableUseOpenWifiActivity();
}
private void checkForFeatureSupportedScorers() {
if (mEnableUseWifiComponentName != null) {
mDoFeatureSupportedScorersExist = true;
return;
}
List<NetworkScorerAppData> scorers = mNetworkScoreManager.getAllValidScorers();
for (NetworkScorerAppData scorer : scorers) {
if (scorer.getEnableUseOpenWifiActivity() != null) {
mDoFeatureSupportedScorersExist = true;
return;
}
}
mDoFeatureSupportedScorersExist = false;
}
@Override
public void displayPreference(PreferenceScreen screen) {
super.displayPreference(screen);
mPreference = screen.findPreference(getPreferenceKey());
}
@Override
public void onResume() {
mSettingObserver.register(mContentResolver);
}
@Override
public void onPause() {
mSettingObserver.unregister(mContentResolver);
}
@Override
public int getAvailabilityStatus() {
// It is possible that mEnableUseWifiComponentName is no longer enabled by
// USE_OPEN_WIFI_PACKAGE. So update this component to reflect correct availability.
updateEnableUseWifiComponentName();
checkForFeatureSupportedScorers();
return mDoFeatureSupportedScorersExist ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
}
@Override
public void updateState(Preference preference) {
super.updateState(preference);
final boolean isScorerSet = mNetworkScoreManager.getActiveScorerPackage() != null;
final boolean doesActiveScorerSupportFeature = mEnableUseWifiComponentName != null;
preference.setEnabled(isScorerSet && doesActiveScorerSupportFeature);
if (!isScorerSet) {
preference.setSummary(R.string.use_open_wifi_automatically_summary_scoring_disabled);
} else if (!doesActiveScorerSupportFeature) {
preference.setSummary(
R.string.use_open_wifi_automatically_summary_scorer_unsupported_disabled);
} else {
preference.setSummary(R.string.use_open_wifi_automatically_summary);
}
}
@Override
public boolean isChecked() {
final String enabledUseOpenWifiPackage = Settings.Global.getString(mContentResolver,
Settings.Global.USE_OPEN_WIFI_PACKAGE);
final String currentUseOpenWifiPackage = mEnableUseWifiComponentName == null
? null : mEnableUseWifiComponentName.getPackageName();
return TextUtils.equals(enabledUseOpenWifiPackage, currentUseOpenWifiPackage);
}
@Override
public boolean setChecked(boolean isChecked) {
if (isChecked) {
if (mFragment == null) {
throw new IllegalStateException("No fragment to start activity");
}
final 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.
} else {
Settings.Global.putString(mContentResolver, Settings.Global.USE_OPEN_WIFI_PACKAGE, "");
return true;
}
}
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);
}
}
}
}

266
tests/robotests/src/com/android/settings/wifi/UseOpenWifiPreferenceControllerTest.java
View File

@@ -1,266 +0,0 @@
/*
* 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.content.Context.NETWORK_SCORE_SERVICE;
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.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.annotation.NonNull;
import android.app.Activity;
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 androidx.fragment.app.Fragment;
import androidx.preference.SwitchPreference;
import com.android.settings.R;
import com.google.common.collect.Lists;
import org.junit.Before;
import org.junit.BeforeClass;
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.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.shadows.ShadowApplication;
import java.util.ArrayList;
import java.util.List;
@RunWith(RobolectricTestRunner.class)
public class UseOpenWifiPreferenceControllerTest {
private static ComponentName sEnableActivityComponent;
private static NetworkScorerAppData sAppData;
private static NetworkScorerAppData sAppDataNoActivity;
@BeforeClass
public static void beforeClass() {
sEnableActivityComponent = new ComponentName("package", "activityClass");
sAppData = new NetworkScorerAppData(0, null, null, sEnableActivityComponent, null);
sAppDataNoActivity = new NetworkScorerAppData(0, null, null, null, null);
}
@Mock
private Fragment mFragment;
@Mock
private NetworkScoreManager mNetworkScoreManager;
@Captor
private ArgumentCaptor<Intent> mIntentCaptor;
private Context mContext;
private UseOpenWifiPreferenceController mController;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = RuntimeEnvironment.application;
ShadowApplication.getInstance()
.setSystemService(NETWORK_SCORE_SERVICE, mNetworkScoreManager);
}
private void createController() {
mController = new UseOpenWifiPreferenceController(mContext);
mController.setFragment(mFragment);
}
/**
* Sets the scorers.
*
* @param scorers list of scorers returned by {@link NetworkScoreManager#getAllValidScorers()}.
* First scorer in the list is the active scorer.
*/
private void setupScorers(@NonNull List<NetworkScorerAppData> scorers) {
when(mNetworkScoreManager.getActiveScorerPackage())
.thenReturn(sEnableActivityComponent.getPackageName());
when(mNetworkScoreManager.getAllValidScorers()).thenReturn(scorers);
when(mNetworkScoreManager.getActiveScorer()).thenReturn(scorers.get(0));
}
@Test
public void testIsAvailable_returnsFalseWhenNoScorerSet() {
createController();
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void testIsAvailable_returnsFalseWhenScorersNotSupported() {
setupScorers(Lists.newArrayList(sAppDataNoActivity));
createController();
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void testIsAvailable_returnsTrueIfActiveScorerSupported() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
createController();
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void testIsAvailable_returnsTrueIfNonActiveScorerSupported() {
setupScorers(Lists.newArrayList(sAppDataNoActivity, sAppData));
when(mNetworkScoreManager.getActiveScorer()).thenReturn(sAppDataNoActivity);
createController();
assertThat(mController.isAvailable()).isTrue();
}
@Test
public void isAvailable_disableUseOpenWifiComponentBetweenCalls_returnsTrueThenReturnsFalse() {
setupScorers(Lists.newArrayList(sAppData));
createController();
assertThat(mController.isAvailable()).isTrue();
// Update NetworkScorerAppData so that it no longer has openWifiActivity.
setupScorers(Lists.newArrayList(sAppDataNoActivity));
assertThat(mController.isAvailable()).isFalse();
}
@Test
public void setChecked_withTrue_enableShouldStartEnableActivity() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
createController();
mController.setChecked(true);
verify(mFragment).startActivityForResult(mIntentCaptor.capture(),
eq(REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY));
final Intent activityIntent = mIntentCaptor.getValue();
assertThat(activityIntent.getComponent()).isEqualTo(sEnableActivityComponent);
assertThat(activityIntent.getAction()).isEqualTo(NetworkScoreManager.ACTION_CUSTOM_ENABLE);
}
@Test
public void setChecked_withFalse_disableShouldUpdateSetting() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
sEnableActivityComponent.getPackageName());
createController();
mController.setChecked(false);
assertThat(Settings.Global.getString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE))
.isEqualTo("");
}
@Test
public void onActivityResult_nonmatchingRequestCode_shouldDoNothing() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
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() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
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() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
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(sEnableActivityComponent.getPackageName());
}
@Test
public void updateState_noEnableActivity_preferenceDisabled_summaryChanged() {
setupScorers(Lists.newArrayList(sAppDataNoActivity));
createController();
final SwitchPreference preference = mock(SwitchPreference.class);
Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
sEnableActivityComponent.getPackageName());
mController.updateState(preference);
verify(preference).setChecked(false);
verify(preference).setSummary(
R.string.use_open_wifi_automatically_summary_scorer_unsupported_disabled);
}
@Test
public void updateState_noScorer_preferenceDisabled_summaryChanged() {
when(mNetworkScoreManager.getAllValidScorers()).thenReturn(new ArrayList<>());
createController();
final SwitchPreference preference = mock(SwitchPreference.class);
Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
sEnableActivityComponent.getPackageName());
mController.updateState(preference);
verify(preference).setChecked(false);
verify(preference).setSummary(
R.string.use_open_wifi_automatically_summary_scoring_disabled);
}
@Test
public void updateState_enableActivityExists_preferenceEnabled() {
setupScorers(Lists.newArrayList(sAppData, sAppDataNoActivity));
createController();
final SwitchPreference preference = mock(SwitchPreference.class);
Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
sEnableActivityComponent.getPackageName());
mController.updateState(preference);
verify(preference).setChecked(true);
verify(preference).setSummary(R.string.use_open_wifi_automatically_summary);
}
}