From d072e8501ace9be6f32565226960549c86ca0d5a Mon Sep 17 00:00:00 2001 From: Mill Chen Date: Thu, 4 Feb 2021 18:53:44 +0800 Subject: [PATCH 01/12] Restructure app info page When the collapsing toolbar is applied in the Settings app, some pages they used manage_applications_apps will have the collapsing toolbar not work properly. This was caused by using multiple CoordinatorLayout and AppBarLayout in these pages. Bug: 177375909 Test: visual verified Change-Id: Ibfeeab9cf907a23d18ee1ec2c450c523316cfc92 --- res/layout/manage_applications_apps_v2.xml | 63 +++++++++++++++++++ .../ManageApplications.java | 6 +- 2 files changed, 68 insertions(+), 1 deletion(-) create mode 100644 res/layout/manage_applications_apps_v2.xml diff --git a/res/layout/manage_applications_apps_v2.xml b/res/layout/manage_applications_apps_v2.xml new file mode 100644 index 00000000000..ecc764a9217 --- /dev/null +++ b/res/layout/manage_applications_apps_v2.xml @@ -0,0 +1,63 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/src/com/android/settings/applications/manageapplications/ManageApplications.java b/src/com/android/settings/applications/manageapplications/ManageApplications.java index c699425e0ae..707e6f44a1a 100644 --- a/src/com/android/settings/applications/manageapplications/ManageApplications.java +++ b/src/com/android/settings/applications/manageapplications/ManageApplications.java @@ -398,7 +398,11 @@ public class ManageApplications extends InstrumentedFragment return mRootView; } - mRootView = inflater.inflate(R.layout.manage_applications_apps, null); + if (FeatureFlagUtils.isEnabled(getContext(), FeatureFlags.SILKY_HOME)) { + mRootView = inflater.inflate(R.layout.manage_applications_apps_v2, null); + } else { + mRootView = inflater.inflate(R.layout.manage_applications_apps, null); + } mLoadingContainer = mRootView.findViewById(R.id.loading_container); mListContainer = mRootView.findViewById(R.id.list_container); if (mListContainer != null) { From 029e2d771e4fc799424256c70104c8a8a979c992 Mon Sep 17 00:00:00 2001 From: Weng Su Date: Mon, 8 Feb 2021 22:48:05 +0800 Subject: [PATCH 02/12] Fix WiFi show "Not connected" always issue - The WiFi summary is designed to be changed when the onCapabilitiesChanged() callback is made from the ConnectivityManager, but there is no guarantee that there will be a callback after the settings are registered to the ConnectivityManager. - Need to fatch initial state information to show the correct summary first when the settings register callback to the ConnectivityManager. - Screenshot: https://screenshot.googleplex.com/AwmLX2ZQE2grC7N Bug: 179335681 Test: manual test - make RunSettingsRoboTests ROBOTEST_FILTER=WifiSummaryUpdaterTest Change-Id: Ib5d22bdf34a3832dd5082e6e11cee699694afdee --- src/com/android/settings/wifi/WifiSummaryUpdater.java | 1 + .../com/android/settings/wifi/WifiSummaryUpdaterTest.java | 8 ++++++++ 2 files changed, 9 insertions(+) diff --git a/src/com/android/settings/wifi/WifiSummaryUpdater.java b/src/com/android/settings/wifi/WifiSummaryUpdater.java index c559e7dcea3..4264b4548f7 100644 --- a/src/com/android/settings/wifi/WifiSummaryUpdater.java +++ b/src/com/android/settings/wifi/WifiSummaryUpdater.java @@ -74,6 +74,7 @@ public final class WifiSummaryUpdater extends SummaryUpdater { @Override public void register(boolean register) { if (register) { + mWifiTracker.fetchInitialState(); notifyChangeIfNeeded(); mContext.registerReceiver(mReceiver, INTENT_FILTER); } else { diff --git a/tests/robotests/src/com/android/settings/wifi/WifiSummaryUpdaterTest.java b/tests/robotests/src/com/android/settings/wifi/WifiSummaryUpdaterTest.java index 02bf172e891..1ae31e8d75d 100644 --- a/tests/robotests/src/com/android/settings/wifi/WifiSummaryUpdaterTest.java +++ b/tests/robotests/src/com/android/settings/wifi/WifiSummaryUpdaterTest.java @@ -64,6 +64,14 @@ public class WifiSummaryUpdaterTest { verify(mWifiTracker).setListening(true); } + @Test + public void register_true_shouldFetchInitialStateAndSendSummaryChange() { + mSummaryUpdater.register(true); + + verify(mWifiTracker).fetchInitialState(); + verify(mListener).onSummaryChanged(anyString()); + } + @Test public void register_false_shouldUnregisterListenerAndTracker() { mSummaryUpdater.register(true); From f49a21d78db4e8c9e54aafc07593950a8aba2fe6 Mon Sep 17 00:00:00 2001 From: Jiashen Wang Date: Tue, 9 Feb 2021 16:45:26 -0800 Subject: [PATCH 03/12] Change SIM dialog activity theme Bug: 153811431 Bug: 170508680 Test: Test manually Change-Id: Ifc5697a3cc80b3e74144a67c5847820ee15bd2fa --- AndroidManifest.xml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/AndroidManifest.xml b/AndroidManifest.xml index f3066ce33ff..d6ccedee5e8 100644 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -517,12 +517,12 @@ + android:theme="@style/Theme.AlertDialog" /> + android:theme="@style/Theme.AlertDialog" /> + android:theme="@style/Theme.AlertDialog" /> + android:theme="@style/Theme.AlertDialog" /> From 6d65cb995bf31eee81fe45a3bbe53f0122b59acb Mon Sep 17 00:00:00 2001 From: Yomna Nasser Date: Mon, 18 Jan 2021 22:08:06 +0000 Subject: [PATCH 04/12] Adds Enable2gPreferenceController and unit tests. Adds (1) Enable2gPreferenceController, the controller for the "Enable 2G" toggle, and (2) Enable2gPreferenceControllerTest, the corresponding unit tests. Test: manul & atest -c Enable2gPreferenceControllerTest Bug: b/163168917 Change-Id: Ib827cfcfd96fdea77b586c92ae0ec5b2bd5818c3 --- res/values/strings.xml | 3 + res/xml/mobile_network_settings.xml | 4 + .../Enable2gPreferenceController.java | 102 +++++++++++++++ .../telephony/MobileNetworkSettings.java | 1 + .../Enable2gPreferenceControllerTest.java | 120 ++++++++++++++++++ 5 files changed, 230 insertions(+) create mode 100644 src/com/android/settings/network/telephony/Enable2gPreferenceController.java create mode 100644 tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java diff --git a/res/values/strings.xml b/res/values/strings.xml index 6d373fbda11..02772634778 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -12780,4 +12780,7 @@ Phone number is missing. OK + + + Allow 2G diff --git a/res/xml/mobile_network_settings.xml b/res/xml/mobile_network_settings.xml index a100d6b04b5..86f5a834f3b 100644 --- a/res/xml/mobile_network_settings.xml +++ b/res/xml/mobile_network_settings.xml @@ -255,4 +255,8 @@ settings:searchable="false" settings:controller="com.android.settings.network.telephony.NrDisabledInDsdsFooterPreferenceController"/> + diff --git a/src/com/android/settings/network/telephony/Enable2gPreferenceController.java b/src/com/android/settings/network/telephony/Enable2gPreferenceController.java new file mode 100644 index 00000000000..1fa430004b3 --- /dev/null +++ b/src/com/android/settings/network/telephony/Enable2gPreferenceController.java @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2020 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.network.telephony; + +import android.content.Context; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.util.Log; + +/** + * Preference controller for "Enable 2G" + */ +public class Enable2gPreferenceController extends TelephonyTogglePreferenceController { + + private static final String LOG_TAG = "Enable2gPreferenceController"; + private static final long BITMASK_2G = TelephonyManager.NETWORK_TYPE_BITMASK_GSM + | TelephonyManager.NETWORK_TYPE_BITMASK_GPRS + | TelephonyManager.NETWORK_TYPE_BITMASK_EDGE + | TelephonyManager.NETWORK_TYPE_BITMASK_CDMA; + + private CarrierConfigManager mCarrierConfigManager; + private TelephonyManager mTelephonyManager; + + /** + * Class constructor of "Enable 2G" toggle. + * + * @param context of settings + * @param key assigned within UI entry of XML file + */ + public Enable2gPreferenceController(Context context, String key) { + super(context, key); + mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + } + + /** + * Initialization based on a given subscription id. + * + * @param subId is the subscription id + * @return this instance after initialization + */ + public Enable2gPreferenceController init(int subId) { + mSubId = subId; + mTelephonyManager = mContext.getSystemService(TelephonyManager.class) + .createForSubscriptionId(mSubId); + return this; + } + + @Override + public int getAvailabilityStatus(int subId) { + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + boolean visible = + subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + && carrierConfig != null + && !carrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G) + && mTelephonyManager.isRadioInterfaceCapabilitySupported( + mTelephonyManager.CAPABILITY_ALLOWED_NETWORK_TYPES_USED); + return visible ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public boolean isChecked() { + long currentlyAllowedNetworkTypes = mTelephonyManager.getAllowedNetworkTypesForReason( + mTelephonyManager.ALLOWED_NETWORK_TYPES_REASON_ENABLE_2G); + return (currentlyAllowedNetworkTypes & BITMASK_2G) != 0; + } + + @Override + public boolean setChecked(boolean isChecked) { + long currentlyAllowedNetworkTypes = mTelephonyManager.getAllowedNetworkTypesForReason( + mTelephonyManager.ALLOWED_NETWORK_TYPES_REASON_ENABLE_2G); + boolean enabled = (currentlyAllowedNetworkTypes & BITMASK_2G) != 0; + if (enabled == isChecked) { + return false; + } + long newAllowedNetworkTypes = currentlyAllowedNetworkTypes; + if (isChecked) { + newAllowedNetworkTypes = currentlyAllowedNetworkTypes | BITMASK_2G; + Log.i(LOG_TAG, "Enabling 2g. Allowed network types: " + newAllowedNetworkTypes); + } else { + newAllowedNetworkTypes = currentlyAllowedNetworkTypes & ~BITMASK_2G; + Log.i(LOG_TAG, "Disabling 2g. Allowed network types: " + newAllowedNetworkTypes); + } + mTelephonyManager.setAllowedNetworkTypesForReason( + mTelephonyManager.ALLOWED_NETWORK_TYPES_REASON_ENABLE_2G, newAllowedNetworkTypes); + return true; + } +} diff --git a/src/com/android/settings/network/telephony/MobileNetworkSettings.java b/src/com/android/settings/network/telephony/MobileNetworkSettings.java index 0d842ef838a..9a4cb408f20 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkSettings.java +++ b/src/com/android/settings/network/telephony/MobileNetworkSettings.java @@ -158,6 +158,7 @@ public class MobileNetworkSettings extends AbstractMobileNetworkSettings { use(PreferredNetworkModePreferenceController.class).init(mSubId); use(EnabledNetworkModePreferenceController.class).init(getLifecycle(), mSubId); use(DataServiceSetupPreferenceController.class).init(mSubId); + use(Enable2gPreferenceController.class).init(mSubId); final WifiCallingPreferenceController wifiCallingPreferenceController = use(WifiCallingPreferenceController.class).init(mSubId); diff --git a/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java new file mode 100644 index 00000000000..9b9bb1131d3 --- /dev/null +++ b/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2020 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.network.telephony; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public final class Enable2gPreferenceControllerTest { + private static final int SUB_ID = 2; + + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + + private PersistableBundle mPersistableBundle; + private Enable2gPreferenceController mController; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(ApplicationProvider.getApplicationContext()); + when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); + when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); + when(mContext.getSystemService(CarrierConfigManager.class)) + .thenReturn(mCarrierConfigManager); + + doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); + + mPersistableBundle = new PersistableBundle(); + doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + mController = new Enable2gPreferenceController(mContext, "mobile_data"); + mController.init(SUB_ID); + } + + @Test + public void getAvailabilityStatus_invalidSubId_returnUnavailable() { + mController.init(SubscriptionManager.INVALID_SUBSCRIPTION_ID); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_hideEnable2g_returnUnavailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G, + true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_nullCarrierConfig_returnUnavailable() { + doReturn(true).when(mTelephonyManager).isRadioInterfaceCapabilitySupported( + mTelephonyManager.CAPABILITY_ALLOWED_NETWORK_TYPES_USED); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G, + false); + doReturn(null).when(mCarrierConfigManager); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_capabilityNotSupported_returnUnavailable() { + doReturn(false).when(mTelephonyManager).isRadioInterfaceCapabilitySupported( + mTelephonyManager.CAPABILITY_ALLOWED_NETWORK_TYPES_USED); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G, + false); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_returnAvailable() { + doReturn(true).when(mTelephonyManager).isRadioInterfaceCapabilitySupported( + mTelephonyManager.CAPABILITY_ALLOWED_NETWORK_TYPES_USED); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G, + false); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } +} From 15e7a0bce4c496582c13131bad89bf785a641714 Mon Sep 17 00:00:00 2001 From: Jiashen Wang Date: Fri, 12 Feb 2021 16:09:03 -0800 Subject: [PATCH 05/12] Fix the notification issue after pSIM is auto enabled Bug: 179933905 Test: Manually tested Change-Id: I52a751c515785618c9a1a5f3bc571687731b4552 --- res/values/strings.xml | 2 ++ src/com/android/settings/sim/SimActivationNotifier.java | 5 +++++ 2 files changed, 7 insertions(+) diff --git a/res/values/strings.xml b/res/values/strings.xml index 1ac3a281f6a..764bd48e1f3 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -12194,6 +12194,8 @@ Network activation + + Carrier switching %1$s is active diff --git a/src/com/android/settings/sim/SimActivationNotifier.java b/src/com/android/settings/sim/SimActivationNotifier.java index 735cb463c3e..c90836e5b78 100644 --- a/src/com/android/settings/sim/SimActivationNotifier.java +++ b/src/com/android/settings/sim/SimActivationNotifier.java @@ -88,6 +88,11 @@ public class SimActivationNotifier { SIM_SETUP_CHANNEL_ID, mContext.getString(R.string.sim_setup_channel_id), NotificationManager.IMPORTANCE_HIGH)); + mNotificationManager.createNotificationChannel( + new NotificationChannel( + SWITCH_SLOT_CHANNEL_ID, + mContext.getString(R.string.sim_switch_channel_id), + NotificationManager.IMPORTANCE_HIGH)); } /** From ed7673eadd314c98ea6727e5e0cf360835a9663d Mon Sep 17 00:00:00 2001 From: Abel Tesfaye Date: Thu, 11 Feb 2021 01:25:49 +0000 Subject: [PATCH 06/12] Check for available rotation resolver service and camera permission before showing setting for face based auto-rotation Test: locally with crosshatch & make -j64 RunSettingsRoboTests ROBOTEST_FILTER="com.android.settings.display.SmartAutoRotateControllerTest" Bug: 172857585 Change-Id: I825b0c2471c71a3de59532b39a47c5442f234fb5 --- AndroidManifest.xml | 2 +- res/values/strings.xml | 2 - res/xml/auto_rotate_settings.xml | 7 ++ .../AutoRotatePreferenceController.java | 1 + .../display/SmartAutoRotateController.java | 34 ++++- .../SmartAutoRotatePermissionController.java | 63 ++++++++++ .../SmartAutoRotatePreferenceFragment.java | 54 ++------ .../SmartAutoRotateControllerTest.java | 117 ++++++++++++++++++ 8 files changed, 234 insertions(+), 46 deletions(-) create mode 100644 src/com/android/settings/display/SmartAutoRotatePermissionController.java create mode 100644 tests/robotests/src/com/android/settings/display/SmartAutoRotateControllerTest.java diff --git a/AndroidManifest.xml b/AndroidManifest.xml index ee11802232f..3bd481519f0 100644 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -954,7 +954,7 @@ + android:value="com.android.settings.display.SmartAutoRotatePreferenceFragment" /> diff --git a/res/values/strings.xml b/res/values/strings.xml index 1ac3a281f6a..9e99251929b 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -2713,8 +2713,6 @@ Display - - com.android.settings.DisplaySettings Auto-rotate screen diff --git a/res/xml/auto_rotate_settings.xml b/res/xml/auto_rotate_settings.xml index dfa31f71aaa..a316b8fb29f 100644 --- a/res/xml/auto_rotate_settings.xml +++ b/res/xml/auto_rotate_settings.xml @@ -20,6 +20,13 @@ xmlns:settings="http://schemas.android.com/apk/res-auto" android:title="@string/accelerometer_title" > + + createPreferenceControllers(Context context) { - return buildPreferenceControllers(context); - } - - private static List buildPreferenceControllers( - Context context) { - final List controllers = new ArrayList<>(); - controllers.add( - new SmartAutoRotatePreferenceController(context, SMART_AUTO_ROTATE_CONTROLLER_KEY)); - return controllers; - } - @Override protected String getLogTag() { return TAG; } public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = - new BaseSearchIndexProvider(R.xml.auto_rotate_settings) { - - @Override - public List createPreferenceControllers( - Context context) { - return buildPreferenceControllers(context); - } - - @Override - protected boolean isPageSearchEnabled(Context context) { - return false; - } - }; + new BaseSearchIndexProvider(R.xml.auto_rotate_settings); } diff --git a/tests/robotests/src/com/android/settings/display/SmartAutoRotateControllerTest.java b/tests/robotests/src/com/android/settings/display/SmartAutoRotateControllerTest.java new file mode 100644 index 00000000000..2d56c0efd88 --- /dev/null +++ b/tests/robotests/src/com/android/settings/display/SmartAutoRotateControllerTest.java @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2021 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.display; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.DISABLED_DEPENDENT_SETTING; +import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.when; + +import android.Manifest; +import android.content.ContentResolver; +import android.content.Context; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.os.UserHandle; +import android.provider.Settings; + +import androidx.preference.Preference; + +import com.android.settings.testutils.ResolveInfoBuilder; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class SmartAutoRotateControllerTest { + + private static final String PACKAGE_NAME = "package_name"; + + private SmartAutoRotateController mController; + @Mock + private PackageManager mPackageManager; + @Mock + private Preference mPreference; + private ContentResolver mContentResolver; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + final Context context = Mockito.spy(RuntimeEnvironment.application); + mContentResolver = RuntimeEnvironment.application.getContentResolver(); + when(context.getPackageManager()).thenReturn(mPackageManager); + when(context.getContentResolver()).thenReturn(mContentResolver); + doReturn(PACKAGE_NAME).when(mPackageManager).getRotationResolverPackageName(); + doReturn(PackageManager.PERMISSION_GRANTED).when(mPackageManager).checkPermission( + Manifest.permission.CAMERA, PACKAGE_NAME); + mController = new SmartAutoRotateController(context, "test_key"); + doReturn(mController.getPreferenceKey()).when(mPreference).getKey(); + + final ResolveInfo resolveInfo = new ResolveInfoBuilder(PACKAGE_NAME).build(); + resolveInfo.serviceInfo = new ServiceInfo(); + when(mPackageManager.resolveService(any(), anyInt())).thenReturn(resolveInfo); + enableAutoRotation(); + } + + @Test + public void getAvailabilityStatus_returnAvailable() { + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + + @Test + public void getAvailabilityStatus_resolveInfoIsNull_returnUnsupportedOnDevice() { + when(mPackageManager.resolveService(any(), anyInt())).thenReturn(null); + assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE); + } + + @Test + public void getAvailabilityStatus_noCameraPermission_returnDisableDependentSetting() { + doReturn(PackageManager.PERMISSION_DENIED).when(mPackageManager).checkPermission( + Manifest.permission.CAMERA, PACKAGE_NAME); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING); + } + + @Test + public void getAvailabilityStatus_rotationLocked_returnDisableDependentSetting() { + disableAutoRotation(); + assertThat(mController.getAvailabilityStatus()).isEqualTo(DISABLED_DEPENDENT_SETTING); + } + + private void enableAutoRotation() { + Settings.System.putIntForUser(mContentResolver, + Settings.System.ACCELEROMETER_ROTATION, 1, UserHandle.USER_CURRENT); + } + + private void disableAutoRotation() { + Settings.System.putIntForUser(mContentResolver, + Settings.System.ACCELEROMETER_ROTATION, 0, UserHandle.USER_CURRENT); + } +} From 9a90dc1e8e469fd08b2177a3bfd0326248531e97 Mon Sep 17 00:00:00 2001 From: Tsung-Mao Fang Date: Thu, 18 Feb 2021 01:26:33 +0000 Subject: [PATCH 07/12] Update new owners for battery pages. Change-Id: I330d074c6e504493abf4cece51199ec5851b5d3b --- src/com/android/settings/fuelgauge/OWNERS | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/com/android/settings/fuelgauge/OWNERS b/src/com/android/settings/fuelgauge/OWNERS index 4e5ee0e10eb..ab3da898aac 100644 --- a/src/com/android/settings/fuelgauge/OWNERS +++ b/src/com/android/settings/fuelgauge/OWNERS @@ -1,3 +1,4 @@ # Default reviewers for this and subdirectories. -millchen@google.com -tmfang@google.com +tifn@google.com +wesleycwwang@google.com +ykhung@google.com From 5c9a04237068a76a48ac3854272428d88437a086 Mon Sep 17 00:00:00 2001 From: Lorenzo Colitti Date: Thu, 18 Feb 2021 01:11:49 +0900 Subject: [PATCH 08/12] Stop using ConnectivityManager for VPNs. These methods have all moved to VpnManager. Bug: 173331190 Test: atest SettingsRoboTests Change-Id: I1dd57fa2213b1785a94ec9d6ab4cce3a5d2684ff --- .../EnterprisePrivacyFeatureProviderImpl.java | 9 ++++++--- .../settings/overlay/FeatureFactoryImpl.java | 4 +++- .../settings/vpn2/AppDialogFragment.java | 7 ++----- .../settings/vpn2/AppManagementFragment.java | 9 +++------ .../settings/vpn2/ConfigDialogFragment.java | 4 +--- .../android/settings/vpn2/VpnSettings.java | 2 +- src/com/android/settings/vpn2/VpnUtils.java | 19 +++++++------------ ...erprisePrivacyFeatureProviderImplTest.java | 15 ++++++++------- .../android/settings/vpn2/VpnUtilsTest.java | 12 ++++++------ 9 files changed, 37 insertions(+), 44 deletions(-) diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java index 7a5b4897623..a746df699a8 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java @@ -25,6 +25,7 @@ import android.content.pm.ResolveInfo; import android.content.pm.UserInfo; import android.content.res.Resources; import android.net.ConnectivityManager; +import android.net.VpnManager; import android.os.UserHandle; import android.os.UserManager; import android.provider.Settings; @@ -48,18 +49,20 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe private final PackageManager mPm; private final UserManager mUm; private final ConnectivityManager mCm; + private final VpnManager mVm; private final Resources mResources; private static final int MY_USER_ID = UserHandle.myUserId(); public EnterprisePrivacyFeatureProviderImpl(Context context, DevicePolicyManager dpm, - PackageManager pm, UserManager um, ConnectivityManager cm, + PackageManager pm, UserManager um, ConnectivityManager cm, VpnManager vm, Resources resources) { mContext = context.getApplicationContext(); mDpm = dpm; mPm = pm; mUm = um; mCm = cm; + mVm = vm; mResources = resources; } @@ -133,14 +136,14 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe @Override public boolean isAlwaysOnVpnSetInCurrentUser() { - return VpnUtils.isAlwaysOnVpnSet(mCm, MY_USER_ID); + return VpnUtils.isAlwaysOnVpnSet(mVm, MY_USER_ID); } @Override public boolean isAlwaysOnVpnSetInManagedProfile() { final int managedProfileUserId = getManagedProfileUserId(); return managedProfileUserId != UserHandle.USER_NULL && - VpnUtils.isAlwaysOnVpnSet(mCm, managedProfileUserId); + VpnUtils.isAlwaysOnVpnSet(mVm, managedProfileUserId); } @Override diff --git a/src/com/android/settings/overlay/FeatureFactoryImpl.java b/src/com/android/settings/overlay/FeatureFactoryImpl.java index ebbe87cfdac..a1b70d99ff5 100644 --- a/src/com/android/settings/overlay/FeatureFactoryImpl.java +++ b/src/com/android/settings/overlay/FeatureFactoryImpl.java @@ -20,6 +20,7 @@ import android.app.AppGlobals; import android.app.admin.DevicePolicyManager; import android.content.Context; import android.net.ConnectivityManager; +import android.net.VpnManager; import android.os.UserManager; import androidx.annotation.Keep; @@ -172,7 +173,8 @@ public class FeatureFactoryImpl extends FeatureFactory { Context.DEVICE_POLICY_SERVICE), appContext.getPackageManager(), UserManager.get(appContext), - (ConnectivityManager) appContext.getSystemService(Context.CONNECTIVITY_SERVICE), + appContext.getSystemService(ConnectivityManager.class), + appContext.getSystemService(VpnManager.class), appContext.getResources()); } return mEnterprisePrivacyFeatureProvider; diff --git a/src/com/android/settings/vpn2/AppDialogFragment.java b/src/com/android/settings/vpn2/AppDialogFragment.java index 45fb9bdb820..626a271e7fc 100644 --- a/src/com/android/settings/vpn2/AppDialogFragment.java +++ b/src/com/android/settings/vpn2/AppDialogFragment.java @@ -20,7 +20,6 @@ import android.app.Dialog; import android.app.settings.SettingsEnums; import android.content.DialogInterface; import android.content.pm.PackageInfo; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.Bundle; import android.os.UserHandle; @@ -48,7 +47,6 @@ public class AppDialogFragment extends InstrumentedDialogFragment implements App private PackageInfo mPackageInfo; private Listener mListener; - private ConnectivityManager mConnectivityManager; private UserManager mUserManager; private VpnManager mVpnManager; @@ -93,7 +91,6 @@ public class AppDialogFragment extends InstrumentedDialogFragment implements App @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - mConnectivityManager = getContext().getSystemService(ConnectivityManager.class); mUserManager = UserManager.get(getContext()); mVpnManager = getContext().getSystemService(VpnManager.class); } @@ -158,8 +155,8 @@ public class AppDialogFragment extends InstrumentedDialogFragment implements App } final int userId = getUserId(); if (mPackageInfo.packageName.equals(VpnUtils.getConnectedPackage(mVpnManager, userId))) { - mConnectivityManager.setAlwaysOnVpnPackageForUser(userId, null, - /* lockdownEnabled */ false, /* lockdownAllowlist */ null); + mVpnManager.setAlwaysOnVpnPackageForUser(userId, null, /* lockdownEnabled */ false, + /* lockdownAllowlist */ null); mVpnManager.prepareVpn(mPackageInfo.packageName, VpnConfig.LEGACY_VPN, userId); } } diff --git a/src/com/android/settings/vpn2/AppManagementFragment.java b/src/com/android/settings/vpn2/AppManagementFragment.java index 9422010aed0..0543fee7dbe 100644 --- a/src/com/android/settings/vpn2/AppManagementFragment.java +++ b/src/com/android/settings/vpn2/AppManagementFragment.java @@ -28,7 +28,6 @@ import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.Bundle; import android.os.UserHandle; @@ -69,7 +68,6 @@ public class AppManagementFragment extends SettingsPreferenceFragment private PackageManager mPackageManager; private DevicePolicyManager mDevicePolicyManager; - private ConnectivityManager mConnectivityManager; private VpnManager mVpnManager; // VPN app info @@ -122,7 +120,6 @@ public class AppManagementFragment extends SettingsPreferenceFragment mPackageManager = getContext().getPackageManager(); mDevicePolicyManager = getContext().getSystemService(DevicePolicyManager.class); - mConnectivityManager = getContext().getSystemService(ConnectivityManager.class); mVpnManager = getContext().getSystemService(VpnManager.class); mPreferenceVersion = findPreference(KEY_VERSION); @@ -227,7 +224,7 @@ public class AppManagementFragment extends SettingsPreferenceFragment } private boolean setAlwaysOnVpn(boolean isEnabled, boolean isLockdown) { - return mConnectivityManager.setAlwaysOnVpnPackageForUser(mUserId, + return mVpnManager.setAlwaysOnVpnPackageForUser(mUserId, isEnabled ? mPackageName : null, isLockdown, /* lockdownAllowlist */ null); } @@ -261,7 +258,7 @@ public class AppManagementFragment extends SettingsPreferenceFragment mPreferenceLockdown.setDisabledByAdmin(admin); } } - if (mConnectivityManager.isAlwaysOnVpnPackageSupportedForUser(mUserId, mPackageName)) { + if (mVpnManager.isAlwaysOnVpnPackageSupportedForUser(mUserId, mPackageName)) { // setSummary doesn't override the admin message when user restriction is applied mPreferenceAlwaysOn.setSummary(R.string.vpn_always_on_summary); // setEnabled is not required here, as checkRestrictionAndSetDisabled @@ -275,7 +272,7 @@ public class AppManagementFragment extends SettingsPreferenceFragment } private String getAlwaysOnVpnPackage() { - return mConnectivityManager.getAlwaysOnVpnPackageForUser(mUserId); + return mVpnManager.getAlwaysOnVpnPackageForUser(mUserId); } private boolean isVpnAlwaysOn() { diff --git a/src/com/android/settings/vpn2/ConfigDialogFragment.java b/src/com/android/settings/vpn2/ConfigDialogFragment.java index e88e4efd588..f339a694c03 100644 --- a/src/com/android/settings/vpn2/ConfigDialogFragment.java +++ b/src/com/android/settings/vpn2/ConfigDialogFragment.java @@ -20,7 +20,6 @@ import android.app.Dialog; import android.app.settings.SettingsEnums; import android.content.Context; import android.content.DialogInterface; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.Bundle; import android.os.RemoteException; @@ -177,8 +176,7 @@ public class ConfigDialogFragment extends InstrumentedDialogFragment implements return; } - final ConnectivityManager conn = ConnectivityManager.from(mContext); - conn.setAlwaysOnVpnPackageForUser(UserHandle.myUserId(), null, + mService.setAlwaysOnVpnPackageForUser(UserHandle.myUserId(), null, /* lockdownEnabled */ false, /* lockdownAllowlist */ null); VpnUtils.setLockdownVpn(mContext, profile.key); } else { diff --git a/src/com/android/settings/vpn2/VpnSettings.java b/src/com/android/settings/vpn2/VpnSettings.java index 79f6be3c75b..0a3b2b01cd7 100644 --- a/src/com/android/settings/vpn2/VpnSettings.java +++ b/src/com/android/settings/vpn2/VpnSettings.java @@ -490,7 +490,7 @@ public class VpnSettings extends RestrictedSettingsFragment implements Set result = new ArraySet<>(); for (UserHandle profile : mUserManager.getUserProfiles()) { final int profileId = profile.getIdentifier(); - final String packageName = mConnectivityManager.getAlwaysOnVpnPackageForUser(profileId); + final String packageName = mVpnManager.getAlwaysOnVpnPackageForUser(profileId); if (packageName != null) { result.add(new AppVpnInfo(profileId, packageName)); } diff --git a/src/com/android/settings/vpn2/VpnUtils.java b/src/com/android/settings/vpn2/VpnUtils.java index c6b79b4432b..4c9338ccd68 100644 --- a/src/com/android/settings/vpn2/VpnUtils.java +++ b/src/com/android/settings/vpn2/VpnUtils.java @@ -16,7 +16,6 @@ package com.android.settings.vpn2; import android.content.Context; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.RemoteException; import android.provider.Settings; @@ -43,15 +42,15 @@ public class VpnUtils { public static void clearLockdownVpn(Context context) { KeyStore.getInstance().delete(Credentials.LOCKDOWN_VPN); - // Always notify ConnectivityManager after keystore update - getConnectivityManager(context).updateLockdownVpn(); + // Always notify VpnManager after keystore update + getVpnManager(context).updateLockdownVpn(); } public static void setLockdownVpn(Context context, String lockdownKey) { KeyStore.getInstance().put(Credentials.LOCKDOWN_VPN, lockdownKey.getBytes(), KeyStore.UID_SELF, /* flags */ 0); - // Always notify ConnectivityManager after keystore update - getConnectivityManager(context).updateLockdownVpn(); + // Always notify VpnManager after keystore update + getVpnManager(context).updateLockdownVpn(); } public static boolean isVpnLockdown(String key) { @@ -63,7 +62,7 @@ public class VpnUtils { if (getLockdownVpn() != null) { return true; } - return getConnectivityManager(context).getAlwaysOnVpnPackageForUser(userId) != null + return getVpnManager(context).getAlwaysOnVpnPackageForUser(userId) != null && Settings.Secure.getIntForUser(context.getContentResolver(), Settings.Secure.ALWAYS_ON_VPN_LOCKDOWN, /* default */ 0, userId) != 0; } @@ -77,16 +76,12 @@ public class VpnUtils { return config != null ? config.user : null; } - private static ConnectivityManager getConnectivityManager(Context context) { - return context.getSystemService(ConnectivityManager.class); - } - private static VpnManager getVpnManager(Context context) { return context.getSystemService(VpnManager.class); } - public static boolean isAlwaysOnVpnSet(ConnectivityManager cm, final int userId) { - return cm.getAlwaysOnVpnPackageForUser(userId) != null; + public static boolean isAlwaysOnVpnSet(VpnManager vm, final int userId) { + return vm.getAlwaysOnVpnPackageForUser(userId) != null; } public static boolean disconnectLegacyVpn(Context context) { diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java index c28267b9609..ee6c528a421 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java @@ -40,6 +40,7 @@ import android.content.pm.UserInfo; import android.content.res.Resources; import android.net.ConnectivityManager; import android.net.ProxyInfo; +import android.net.VpnManager; import android.os.UserHandle; import android.os.UserManager; import android.provider.Settings; @@ -91,6 +92,8 @@ public class EnterprisePrivacyFeatureProviderImplTest { private UserManager mUserManager; @Mock private ConnectivityManager mConnectivityManger; + @Mock + private VpnManager mVpnManager; private Resources mResources; private EnterprisePrivacyFeatureProvider mProvider; @@ -106,7 +109,7 @@ public class EnterprisePrivacyFeatureProviderImplTest { mResources = RuntimeEnvironment.application.getResources(); mProvider = new EnterprisePrivacyFeatureProviderImpl(mContext, mDevicePolicyManager, - mPackageManager, mUserManager, mConnectivityManger, mResources); + mPackageManager, mUserManager, mConnectivityManger, mVpnManager, mResources); } @Test @@ -208,11 +211,10 @@ public class EnterprisePrivacyFeatureProviderImplTest { @Test public void testIsAlwaysOnVpnSetInCurrentUser() { - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(mUserId)).thenReturn(null); + when(mVpnManager.getAlwaysOnVpnPackageForUser(mUserId)).thenReturn(null); assertThat(mProvider.isAlwaysOnVpnSetInCurrentUser()).isFalse(); - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(mUserId)) - .thenReturn(VPN_PACKAGE_ID); + when(mVpnManager.getAlwaysOnVpnPackageForUser(mUserId)).thenReturn(VPN_PACKAGE_ID); assertThat(mProvider.isAlwaysOnVpnSetInCurrentUser()).isTrue(); } @@ -222,11 +224,10 @@ public class EnterprisePrivacyFeatureProviderImplTest { mProfiles.add(new UserInfo(mManagedProfileUserId, "", "", UserInfo.FLAG_MANAGED_PROFILE)); - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(mManagedProfileUserId)) - .thenReturn(null); + when(mVpnManager.getAlwaysOnVpnPackageForUser(mManagedProfileUserId)).thenReturn(null); assertThat(mProvider.isAlwaysOnVpnSetInManagedProfile()).isFalse(); - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(mManagedProfileUserId)) + when(mVpnManager.getAlwaysOnVpnPackageForUser(mManagedProfileUserId)) .thenReturn(VPN_PACKAGE_ID); assertThat(mProvider.isAlwaysOnVpnSetInManagedProfile()).isTrue(); } diff --git a/tests/unit/src/com/android/settings/vpn2/VpnUtilsTest.java b/tests/unit/src/com/android/settings/vpn2/VpnUtilsTest.java index f214764ca75..ff5bb81df64 100644 --- a/tests/unit/src/com/android/settings/vpn2/VpnUtilsTest.java +++ b/tests/unit/src/com/android/settings/vpn2/VpnUtilsTest.java @@ -21,7 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import android.net.ConnectivityManager; +import android.net.VpnManager; import androidx.test.ext.junit.runners.AndroidJUnit4; @@ -32,11 +32,11 @@ import org.junit.runner.RunWith; public final class VpnUtilsTest { @Test public void testIsAlwaysOnVpnSet() { - final ConnectivityManager cm = mock(ConnectivityManager.class); - when(cm.getAlwaysOnVpnPackageForUser(0)).thenReturn("com.example.vpn"); - assertThat(VpnUtils.isAlwaysOnVpnSet(cm, 0)).isTrue(); + final VpnManager vm = mock(VpnManager.class); + when(vm.getAlwaysOnVpnPackageForUser(0)).thenReturn("com.example.vpn"); + assertThat(VpnUtils.isAlwaysOnVpnSet(vm, 0)).isTrue(); - when(cm.getAlwaysOnVpnPackageForUser(0)).thenReturn(null); - assertThat(VpnUtils.isAlwaysOnVpnSet(cm, 0)).isFalse(); + when(vm.getAlwaysOnVpnPackageForUser(0)).thenReturn(null); + assertThat(VpnUtils.isAlwaysOnVpnSet(vm, 0)).isFalse(); } } From cacf9aa485077c4cd88538810145695ff5391f58 Mon Sep 17 00:00:00 2001 From: Lorenzo Colitti Date: Thu, 18 Feb 2021 16:32:47 +0900 Subject: [PATCH 09/12] Remove ConnectivityManager from EnterprisePrivacyFeatureProvider. It is only used in GlobalHttpPreferenceController. Move it there. Bug: 173331190 Test: atest SettingsRoboTests Change-Id: I62c589679052b276927d057d3d5d084bbfb57626 --- .../EnterprisePrivacyFeatureProvider.java | 5 ----- .../EnterprisePrivacyFeatureProviderImpl.java | 5 ----- .../GlobalHttpProxyPreferenceController.java | 9 ++++----- .../EnterprisePrivacyFeatureProviderImplTest.java | 11 ----------- .../GlobalHttpProxyPreferenceControllerTest.java | 14 ++++++-------- 5 files changed, 10 insertions(+), 34 deletions(-) diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java index 62f15b92653..7d28d82954c 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java @@ -84,11 +84,6 @@ public interface EnterprisePrivacyFeatureProvider { */ boolean isAlwaysOnVpnSetInManagedProfile(); - /** - * Returns whether the Device Owner set a recommended global HTTP proxy. - */ - boolean isGlobalHttpProxySet(); - /** * Returns the number of failed login attempts that the Device Owner or Profile Owner allows * before the current user is wiped, or zero if no such limit is set. diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java index a746df699a8..f461fe1e556 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java @@ -146,11 +146,6 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe VpnUtils.isAlwaysOnVpnSet(mVm, managedProfileUserId); } - @Override - public boolean isGlobalHttpProxySet() { - return mCm.getGlobalProxy() != null; - } - @Override public int getMaximumFailedPasswordsBeforeWipeInCurrentUser() { ComponentName owner = mDpm.getDeviceOwnerComponentOnCallingUser(); diff --git a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java index 04e63aa1e8b..6de6cde359e 100644 --- a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java +++ b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java @@ -14,26 +14,25 @@ package com.android.settings.enterprise; import android.content.Context; +import android.net.ConnectivityManager; import com.android.settings.core.PreferenceControllerMixin; -import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.core.AbstractPreferenceController; public class GlobalHttpProxyPreferenceController extends AbstractPreferenceController implements PreferenceControllerMixin { private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy"; - private final EnterprisePrivacyFeatureProvider mFeatureProvider; + private final ConnectivityManager mCm; public GlobalHttpProxyPreferenceController(Context context) { super(context); - mFeatureProvider = FeatureFactory.getFactory(context) - .getEnterprisePrivacyFeatureProvider(context); + mCm = context.getSystemService(ConnectivityManager.class); } @Override public boolean isAvailable() { - return mFeatureProvider.isGlobalHttpProxySet(); + return mCm.getGlobalProxy() != null; } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java index ee6c528a421..28a790690fa 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java @@ -39,7 +39,6 @@ import android.content.pm.ResolveInfo; import android.content.pm.UserInfo; import android.content.res.Resources; import android.net.ConnectivityManager; -import android.net.ProxyInfo; import android.net.VpnManager; import android.os.UserHandle; import android.os.UserManager; @@ -232,16 +231,6 @@ public class EnterprisePrivacyFeatureProviderImplTest { assertThat(mProvider.isAlwaysOnVpnSetInManagedProfile()).isTrue(); } - @Test - public void testIsGlobalHttpProxySet() { - when(mConnectivityManger.getGlobalProxy()).thenReturn(null); - assertThat(mProvider.isGlobalHttpProxySet()).isFalse(); - - when(mConnectivityManger.getGlobalProxy()) - .thenReturn(ProxyInfo.buildDirectProxy("localhost", 123)); - assertThat(mProvider.isGlobalHttpProxySet()).isTrue(); - } - @Test public void testGetMaximumFailedPasswordsForWipeInCurrentUser() { when(mDevicePolicyManager.getDeviceOwnerComponentOnCallingUser()).thenReturn(null); diff --git a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java index 05d1c640fd0..11676a28378 100644 --- a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java @@ -21,11 +21,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.when; import android.content.Context; +import android.net.ConnectivityManager; +import android.net.ProxyInfo; import androidx.preference.Preference; -import com.android.settings.testutils.FakeFeatureFactory; - import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -41,25 +41,23 @@ public class GlobalHttpProxyPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; - private FakeFeatureFactory mFeatureFactory; + @Mock + private ConnectivityManager mCm; private GlobalHttpProxyPreferenceController mController; @Before public void setUp() { MockitoAnnotations.initMocks(this); - mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = new GlobalHttpProxyPreferenceController(mContext); } @Test public void testIsAvailable() { - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) - .thenReturn(false); + when(mCm.getGlobalProxy()).thenReturn(null); assertThat(mController.isAvailable()).isFalse(); - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) - .thenReturn(true); + when(mCm.getGlobalProxy()).thenReturn(ProxyInfo.buildDirectProxy("localhost", 123)); assertThat(mController.isAvailable()).isTrue(); } From 772477af1cced24d324326484f973952ce06aee1 Mon Sep 17 00:00:00 2001 From: Tsung-Mao Fang Date: Thu, 18 Feb 2021 18:14:58 +0800 Subject: [PATCH 10/12] Fix broken tests 1) Remove AssistantFeedbackPreferenceController since it didn't use. 2) Refine the AssistantFeedbackPreferenceControllerTest, we need to use vpn manager object now. (See ag/13519006) Test: Run robo test Fix: 180576544 Change-Id: I719711d83201d571427b9f46a6026e0831cddab6 --- .../ShortcutsSettingsFragment.java | 2 + ...AssistantFeedbackPreferenceController.java | 127 ------------- .../network/VpnPreferenceControllerTest.java | 12 +- ...stantFeedbackPreferenceControllerTest.java | 176 ------------------ 4 files changed, 5 insertions(+), 312 deletions(-) delete mode 100644 src/com/android/settings/notification/AssistantFeedbackPreferenceController.java delete mode 100644 tests/robotests/src/com/android/settings/notification/AssistantFeedbackPreferenceControllerTest.java diff --git a/src/com/android/settings/accessibility/ShortcutsSettingsFragment.java b/src/com/android/settings/accessibility/ShortcutsSettingsFragment.java index 91e16f623f3..84268349b7c 100644 --- a/src/com/android/settings/accessibility/ShortcutsSettingsFragment.java +++ b/src/com/android/settings/accessibility/ShortcutsSettingsFragment.java @@ -21,8 +21,10 @@ import android.app.settings.SettingsEnums; import com.android.settings.R; import com.android.settings.dashboard.DashboardFragment; import com.android.settings.search.BaseSearchIndexProvider; +import com.android.settingslib.search.SearchIndexable; /** Accessibility settings for accessibility shortcuts. */ +@SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC) public class ShortcutsSettingsFragment extends DashboardFragment { private static final String TAG = "ShortcutsSettingsFragment"; diff --git a/src/com/android/settings/notification/AssistantFeedbackPreferenceController.java b/src/com/android/settings/notification/AssistantFeedbackPreferenceController.java deleted file mode 100644 index 491fd8b7bfc..00000000000 --- a/src/com/android/settings/notification/AssistantFeedbackPreferenceController.java +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (C) 2020 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.notification; - -import static android.provider.Settings.Global.NOTIFICATION_FEEDBACK_ENABLED; - -import android.content.ContentResolver; -import android.content.Context; -import android.database.ContentObserver; -import android.net.Uri; -import android.os.Handler; -import android.provider.DeviceConfig; -import android.provider.Settings; - -import androidx.preference.Preference; -import androidx.preference.PreferenceScreen; - -import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; -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 com.google.common.annotations.VisibleForTesting; - -public class AssistantFeedbackPreferenceController extends TogglePreferenceController - implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener, - LifecycleObserver, OnResume, OnPause { - - @VisibleForTesting - static final int ON = 1; - @VisibleForTesting - static final int OFF = 0; - - private SettingObserver mSettingObserver; - - public AssistantFeedbackPreferenceController(Context context, - String preferenceKey) { - super(context, preferenceKey); - } - - @Override - public void displayPreference(PreferenceScreen screen) { - super.displayPreference(screen); - Preference preference = screen.findPreference(NOTIFICATION_FEEDBACK_ENABLED); - if (preference != null) { - mSettingObserver = new SettingObserver(preference); - } - } - - @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 int getAvailabilityStatus() { - return DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.ENABLE_NAS_FEEDBACK, false) - ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; - } - - @Override - public boolean isChecked() { - return Settings.Global.getInt(mContext.getContentResolver(), - NOTIFICATION_FEEDBACK_ENABLED, ON) == ON; - } - - @Override - public boolean setChecked(boolean isChecked) { - return Settings.Global.putInt(mContext.getContentResolver(), - NOTIFICATION_FEEDBACK_ENABLED, isChecked ? ON : OFF); - } - - class SettingObserver extends ContentObserver { - - private final Uri NOTIFICATION_URI = - Settings.Global.getUriFor(NOTIFICATION_FEEDBACK_ENABLED); - - private final Preference mPreference; - - SettingObserver(Preference preference) { - super(new Handler()); - mPreference = preference; - } - - public void register(ContentResolver cr, boolean register) { - if (register) { - cr.registerContentObserver(NOTIFICATION_URI, false, this); - } else { - cr.unregisterContentObserver(this); - } - } - - @Override - public void onChange(boolean selfChange, Uri uri) { - super.onChange(selfChange, uri); - if (NOTIFICATION_URI.equals(uri)) { - updateState(mPreference); - } - } - } -} diff --git a/tests/robotests/src/com/android/settings/network/VpnPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/VpnPreferenceControllerTest.java index 89d0465fab2..fb66d299ccd 100644 --- a/tests/robotests/src/com/android/settings/network/VpnPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/VpnPreferenceControllerTest.java @@ -30,11 +30,9 @@ import static org.mockito.Mockito.when; import android.content.Context; import android.net.ConnectivityManager; -import android.net.IConnectivityManager; import android.net.NetworkRequest; -import android.os.IBinder; +import android.net.VpnManager; import android.os.UserHandle; -import android.os.ServiceManager; import android.provider.SettingsSlicesContract; import androidx.lifecycle.LifecycleOwner; @@ -60,9 +58,7 @@ public class VpnPreferenceControllerTest { @Mock private ConnectivityManager mConnectivityManager; @Mock - private IBinder mBinder; - @Mock - private IConnectivityManager mConnectivityManagerService; + private VpnManager mVpnManager; @Mock private PreferenceScreen mScreen; @Mock @@ -76,9 +72,7 @@ public class VpnPreferenceControllerTest { MockitoAnnotations.initMocks(this); when(mContext.getSystemService(Context.CONNECTIVITY_SERVICE)) .thenReturn(mConnectivityManager); - when(mBinder.queryLocalInterface("android.net.IConnectivityManager")) - .thenReturn(mConnectivityManagerService); - ServiceManager.addService(Context.CONNECTIVITY_SERVICE, mBinder); + when(mContext.getSystemService(VpnManager.class)).thenReturn(mVpnManager); when(mScreen.findPreference(anyString())).thenReturn(mPreference); mController = spy(new VpnPreferenceController(mContext)); diff --git a/tests/robotests/src/com/android/settings/notification/AssistantFeedbackPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/AssistantFeedbackPreferenceControllerTest.java deleted file mode 100644 index 9f172a6df1f..00000000000 --- a/tests/robotests/src/com/android/settings/notification/AssistantFeedbackPreferenceControllerTest.java +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright (C) 2020 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.notification; - -import static android.provider.Settings.Global.NOTIFICATION_FEEDBACK_ENABLED; - -import static com.android.settings.notification.AssistantFeedbackPreferenceController.OFF; -import static com.android.settings.notification.AssistantFeedbackPreferenceController.ON; - -import static com.google.common.truth.Truth.assertThat; - -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import android.content.Context; -import android.provider.DeviceConfig; -import android.provider.Settings; - -import androidx.preference.Preference; -import androidx.preference.PreferenceScreen; -import androidx.preference.TwoStatePreference; - -import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; -import com.android.settings.core.BasePreferenceController; -import com.android.settings.testutils.shadow.ShadowDeviceConfig; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Answers; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; -import org.robolectric.annotation.Config; - -@RunWith(RobolectricTestRunner.class) -@Config(shadows = {ShadowDeviceConfig.class}) -public class AssistantFeedbackPreferenceControllerTest { - - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - private Context mContext; - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - private PreferenceScreen mScreen; - - private AssistantFeedbackPreferenceController mController; - private Preference mPreference; - - private static final String KEY = "asst_feedback_indicator"; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - mController = new AssistantFeedbackPreferenceController(mContext, KEY); - mPreference = new Preference(RuntimeEnvironment.application); - mPreference.setKey(mController.getPreferenceKey()); - when(mScreen.findPreference(mPreference.getKey())).thenReturn(mPreference); - } - - @After - public void tearDown() { - ShadowDeviceConfig.reset(); - } - - @Test - public void testIsVisible_DeviceConfigOn() { - DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.ENABLE_NAS_FEEDBACK, "true", true); - mController.displayPreference(mScreen); - - assertThat(mPreference.isVisible()).isTrue(); - } - - @Test - public void testIsVisible_DeviceConfigOff() { - DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.ENABLE_NAS_FEEDBACK, "false", true); - mController.displayPreference(mScreen); - - assertThat(mPreference.isVisible()).isFalse(); - } - - @Test - public void getAvailabilityStatus_DeviceConfigOn_returnAvailable() { - DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.ENABLE_NAS_FEEDBACK, "true", true); - - assertThat(mController.getAvailabilityStatus()).isEqualTo( - BasePreferenceController.AVAILABLE); - } - - @Test - public void getAvailabilityStatus_DeviceConfigOff_returnUnavailable() { - DeviceConfig.setProperty(DeviceConfig.NAMESPACE_SYSTEMUI, - SystemUiDeviceConfigFlags.ENABLE_NAS_FEEDBACK, "false", true); - - assertThat(mController.getAvailabilityStatus()).isEqualTo( - BasePreferenceController.CONDITIONALLY_UNAVAILABLE); - } - - @Test - public void updateState_preferenceSetCheckedWhenSettingIsOn() { - final TwoStatePreference preference = mock(TwoStatePreference.class); - final Context context = RuntimeEnvironment.application; - Settings.Global.putInt(context.getContentResolver(), NOTIFICATION_FEEDBACK_ENABLED, ON); - - mController = new AssistantFeedbackPreferenceController(context, KEY); - mController.updateState(preference); - - verify(preference).setChecked(true); - } - - @Test - public void updateState_preferenceSetUncheckedWhenSettingIsOff() { - final TwoStatePreference preference = mock(TwoStatePreference.class); - final Context context = RuntimeEnvironment.application; - Settings.Global.putInt(context.getContentResolver(), NOTIFICATION_FEEDBACK_ENABLED, OFF); - - mController = new AssistantFeedbackPreferenceController(context, KEY); - mController.updateState(preference); - - verify(preference).setChecked(false); - } - - @Test - public void isChecked_settingIsOff_shouldReturnFalse() { - Settings.Global.putInt(mContext.getContentResolver(), NOTIFICATION_FEEDBACK_ENABLED, OFF); - - assertThat(mController.isChecked()).isFalse(); - } - - @Test - public void isChecked_settingIsOn_shouldReturnTrue() { - Settings.Global.putInt(mContext.getContentResolver(), NOTIFICATION_FEEDBACK_ENABLED, ON); - - assertThat(mController.isChecked()).isTrue(); - } - - @Test - public void setChecked_setFalse_disablesSetting() { - Settings.Global.putInt(mContext.getContentResolver(), NOTIFICATION_FEEDBACK_ENABLED, ON); - - mController.setChecked(false); - int updatedValue = Settings.Global.getInt(mContext.getContentResolver(), - NOTIFICATION_FEEDBACK_ENABLED, -1); - - assertThat(updatedValue).isEqualTo(OFF); - } - - @Test - public void setChecked_setTrue_enablesSetting() { - Settings.Global.putInt(mContext.getContentResolver(), NOTIFICATION_FEEDBACK_ENABLED, OFF); - - mController.setChecked(true); - int updatedValue = Settings.Global.getInt(mContext.getContentResolver(), - NOTIFICATION_FEEDBACK_ENABLED, -1); - - assertThat(updatedValue).isEqualTo(ON); - } -} From 1434c086008490cb921fac2392fb1110838a5ec6 Mon Sep 17 00:00:00 2001 From: Lorenzo Colitti Date: Thu, 18 Feb 2021 01:11:49 +0900 Subject: [PATCH 11/12] Stop using ConnectivityManager for VPNs. These methods have all moved to VpnManager. Bug: 173331190 Test: atest SettingsRoboTests Change-Id: I1dd57fa2213b1785a94ec9d6ab4cce3a5d2684ff Merged-In: I1dd57fa2213b1785a94ec9d6ab4cce3a5d2684ff --- .../EnterprisePrivacyFeatureProviderImpl.java | 9 ++++++--- .../settings/overlay/FeatureFactoryImpl.java | 4 +++- .../settings/vpn2/AppDialogFragment.java | 7 ++----- .../settings/vpn2/AppManagementFragment.java | 11 ++++------- .../settings/vpn2/ConfigDialogFragment.java | 6 ++---- .../android/settings/vpn2/VpnSettings.java | 2 +- src/com/android/settings/vpn2/VpnUtils.java | 19 +++++++------------ ...erprisePrivacyFeatureProviderImplTest.java | 14 +++++++------- .../android/settings/vpn2/VpnUtilsTest.java | 12 ++++++------ 9 files changed, 38 insertions(+), 46 deletions(-) diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java index 429c537d985..59036a2c81d 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java @@ -25,6 +25,7 @@ import android.content.pm.ResolveInfo; import android.content.pm.UserInfo; import android.content.res.Resources; import android.net.ConnectivityManager; +import android.net.VpnManager; import android.os.UserHandle; import android.os.UserManager; import android.provider.Settings; @@ -45,18 +46,20 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe private final PackageManager mPm; private final UserManager mUm; private final ConnectivityManager mCm; + private final VpnManager mVm; private final Resources mResources; private static final int MY_USER_ID = UserHandle.myUserId(); public EnterprisePrivacyFeatureProviderImpl(Context context, DevicePolicyManager dpm, - PackageManager pm, UserManager um, ConnectivityManager cm, + PackageManager pm, UserManager um, ConnectivityManager cm, VpnManager vm, Resources resources) { mContext = context.getApplicationContext(); mDpm = dpm; mPm = pm; mUm = um; mCm = cm; + mVm = vm; mResources = resources; } @@ -130,14 +133,14 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe @Override public boolean isAlwaysOnVpnSetInCurrentUser() { - return VpnUtils.isAlwaysOnVpnSet(mCm, MY_USER_ID); + return VpnUtils.isAlwaysOnVpnSet(mVm, MY_USER_ID); } @Override public boolean isAlwaysOnVpnSetInManagedProfile() { final int managedProfileUserId = getManagedProfileUserId(); return managedProfileUserId != UserHandle.USER_NULL && - VpnUtils.isAlwaysOnVpnSet(mCm, managedProfileUserId); + VpnUtils.isAlwaysOnVpnSet(mVm, managedProfileUserId); } @Override diff --git a/src/com/android/settings/overlay/FeatureFactoryImpl.java b/src/com/android/settings/overlay/FeatureFactoryImpl.java index d4d396f80b9..41bfb21d112 100644 --- a/src/com/android/settings/overlay/FeatureFactoryImpl.java +++ b/src/com/android/settings/overlay/FeatureFactoryImpl.java @@ -20,6 +20,7 @@ import android.app.AppGlobals; import android.app.admin.DevicePolicyManager; import android.content.Context; import android.net.ConnectivityManager; +import android.net.VpnManager; import android.os.UserManager; import androidx.annotation.Keep; @@ -169,7 +170,8 @@ public class FeatureFactoryImpl extends FeatureFactory { Context.DEVICE_POLICY_SERVICE), appContext.getPackageManager(), UserManager.get(appContext), - (ConnectivityManager) appContext.getSystemService(Context.CONNECTIVITY_SERVICE), + appContext.getSystemService(ConnectivityManager.class), + appContext.getSystemService(VpnManager.class), appContext.getResources()); } return mEnterprisePrivacyFeatureProvider; diff --git a/src/com/android/settings/vpn2/AppDialogFragment.java b/src/com/android/settings/vpn2/AppDialogFragment.java index 45fb9bdb820..626a271e7fc 100644 --- a/src/com/android/settings/vpn2/AppDialogFragment.java +++ b/src/com/android/settings/vpn2/AppDialogFragment.java @@ -20,7 +20,6 @@ import android.app.Dialog; import android.app.settings.SettingsEnums; import android.content.DialogInterface; import android.content.pm.PackageInfo; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.Bundle; import android.os.UserHandle; @@ -48,7 +47,6 @@ public class AppDialogFragment extends InstrumentedDialogFragment implements App private PackageInfo mPackageInfo; private Listener mListener; - private ConnectivityManager mConnectivityManager; private UserManager mUserManager; private VpnManager mVpnManager; @@ -93,7 +91,6 @@ public class AppDialogFragment extends InstrumentedDialogFragment implements App @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); - mConnectivityManager = getContext().getSystemService(ConnectivityManager.class); mUserManager = UserManager.get(getContext()); mVpnManager = getContext().getSystemService(VpnManager.class); } @@ -158,8 +155,8 @@ public class AppDialogFragment extends InstrumentedDialogFragment implements App } final int userId = getUserId(); if (mPackageInfo.packageName.equals(VpnUtils.getConnectedPackage(mVpnManager, userId))) { - mConnectivityManager.setAlwaysOnVpnPackageForUser(userId, null, - /* lockdownEnabled */ false, /* lockdownAllowlist */ null); + mVpnManager.setAlwaysOnVpnPackageForUser(userId, null, /* lockdownEnabled */ false, + /* lockdownAllowlist */ null); mVpnManager.prepareVpn(mPackageInfo.packageName, VpnConfig.LEGACY_VPN, userId); } } diff --git a/src/com/android/settings/vpn2/AppManagementFragment.java b/src/com/android/settings/vpn2/AppManagementFragment.java index 8ab6a4f2b4f..0543fee7dbe 100644 --- a/src/com/android/settings/vpn2/AppManagementFragment.java +++ b/src/com/android/settings/vpn2/AppManagementFragment.java @@ -28,7 +28,6 @@ import android.content.pm.ApplicationInfo; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManager.NameNotFoundException; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.Bundle; import android.os.UserHandle; @@ -69,7 +68,6 @@ public class AppManagementFragment extends SettingsPreferenceFragment private PackageManager mPackageManager; private DevicePolicyManager mDevicePolicyManager; - private ConnectivityManager mConnectivityManager; private VpnManager mVpnManager; // VPN app info @@ -122,7 +120,6 @@ public class AppManagementFragment extends SettingsPreferenceFragment mPackageManager = getContext().getPackageManager(); mDevicePolicyManager = getContext().getSystemService(DevicePolicyManager.class); - mConnectivityManager = getContext().getSystemService(ConnectivityManager.class); mVpnManager = getContext().getSystemService(VpnManager.class); mPreferenceVersion = findPreference(KEY_VERSION); @@ -227,8 +224,8 @@ public class AppManagementFragment extends SettingsPreferenceFragment } private boolean setAlwaysOnVpn(boolean isEnabled, boolean isLockdown) { - return mConnectivityManager.setAlwaysOnVpnPackageForUser(mUserId, - isEnabled ? mPackageName : null, isLockdown, /* lockdownWhitelist */ null); + return mVpnManager.setAlwaysOnVpnPackageForUser(mUserId, + isEnabled ? mPackageName : null, isLockdown, /* lockdownAllowlist */ null); } private void updateUI() { @@ -261,7 +258,7 @@ public class AppManagementFragment extends SettingsPreferenceFragment mPreferenceLockdown.setDisabledByAdmin(admin); } } - if (mConnectivityManager.isAlwaysOnVpnPackageSupportedForUser(mUserId, mPackageName)) { + if (mVpnManager.isAlwaysOnVpnPackageSupportedForUser(mUserId, mPackageName)) { // setSummary doesn't override the admin message when user restriction is applied mPreferenceAlwaysOn.setSummary(R.string.vpn_always_on_summary); // setEnabled is not required here, as checkRestrictionAndSetDisabled @@ -275,7 +272,7 @@ public class AppManagementFragment extends SettingsPreferenceFragment } private String getAlwaysOnVpnPackage() { - return mConnectivityManager.getAlwaysOnVpnPackageForUser(mUserId); + return mVpnManager.getAlwaysOnVpnPackageForUser(mUserId); } private boolean isVpnAlwaysOn() { diff --git a/src/com/android/settings/vpn2/ConfigDialogFragment.java b/src/com/android/settings/vpn2/ConfigDialogFragment.java index a478eb9deb5..f339a694c03 100644 --- a/src/com/android/settings/vpn2/ConfigDialogFragment.java +++ b/src/com/android/settings/vpn2/ConfigDialogFragment.java @@ -20,7 +20,6 @@ import android.app.Dialog; import android.app.settings.SettingsEnums; import android.content.Context; import android.content.DialogInterface; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.Bundle; import android.os.RemoteException; @@ -177,9 +176,8 @@ public class ConfigDialogFragment extends InstrumentedDialogFragment implements return; } - final ConnectivityManager conn = ConnectivityManager.from(mContext); - conn.setAlwaysOnVpnPackageForUser(UserHandle.myUserId(), null, - /* lockdownEnabled */ false, /* lockdownWhitelist */ null); + mService.setAlwaysOnVpnPackageForUser(UserHandle.myUserId(), null, + /* lockdownEnabled */ false, /* lockdownAllowlist */ null); VpnUtils.setLockdownVpn(mContext, profile.key); } else { // update only if lockdown vpn has been changed diff --git a/src/com/android/settings/vpn2/VpnSettings.java b/src/com/android/settings/vpn2/VpnSettings.java index 79f6be3c75b..0a3b2b01cd7 100644 --- a/src/com/android/settings/vpn2/VpnSettings.java +++ b/src/com/android/settings/vpn2/VpnSettings.java @@ -490,7 +490,7 @@ public class VpnSettings extends RestrictedSettingsFragment implements Set result = new ArraySet<>(); for (UserHandle profile : mUserManager.getUserProfiles()) { final int profileId = profile.getIdentifier(); - final String packageName = mConnectivityManager.getAlwaysOnVpnPackageForUser(profileId); + final String packageName = mVpnManager.getAlwaysOnVpnPackageForUser(profileId); if (packageName != null) { result.add(new AppVpnInfo(profileId, packageName)); } diff --git a/src/com/android/settings/vpn2/VpnUtils.java b/src/com/android/settings/vpn2/VpnUtils.java index c6b79b4432b..4c9338ccd68 100644 --- a/src/com/android/settings/vpn2/VpnUtils.java +++ b/src/com/android/settings/vpn2/VpnUtils.java @@ -16,7 +16,6 @@ package com.android.settings.vpn2; import android.content.Context; -import android.net.ConnectivityManager; import android.net.VpnManager; import android.os.RemoteException; import android.provider.Settings; @@ -43,15 +42,15 @@ public class VpnUtils { public static void clearLockdownVpn(Context context) { KeyStore.getInstance().delete(Credentials.LOCKDOWN_VPN); - // Always notify ConnectivityManager after keystore update - getConnectivityManager(context).updateLockdownVpn(); + // Always notify VpnManager after keystore update + getVpnManager(context).updateLockdownVpn(); } public static void setLockdownVpn(Context context, String lockdownKey) { KeyStore.getInstance().put(Credentials.LOCKDOWN_VPN, lockdownKey.getBytes(), KeyStore.UID_SELF, /* flags */ 0); - // Always notify ConnectivityManager after keystore update - getConnectivityManager(context).updateLockdownVpn(); + // Always notify VpnManager after keystore update + getVpnManager(context).updateLockdownVpn(); } public static boolean isVpnLockdown(String key) { @@ -63,7 +62,7 @@ public class VpnUtils { if (getLockdownVpn() != null) { return true; } - return getConnectivityManager(context).getAlwaysOnVpnPackageForUser(userId) != null + return getVpnManager(context).getAlwaysOnVpnPackageForUser(userId) != null && Settings.Secure.getIntForUser(context.getContentResolver(), Settings.Secure.ALWAYS_ON_VPN_LOCKDOWN, /* default */ 0, userId) != 0; } @@ -77,16 +76,12 @@ public class VpnUtils { return config != null ? config.user : null; } - private static ConnectivityManager getConnectivityManager(Context context) { - return context.getSystemService(ConnectivityManager.class); - } - private static VpnManager getVpnManager(Context context) { return context.getSystemService(VpnManager.class); } - public static boolean isAlwaysOnVpnSet(ConnectivityManager cm, final int userId) { - return cm.getAlwaysOnVpnPackageForUser(userId) != null; + public static boolean isAlwaysOnVpnSet(VpnManager vm, final int userId) { + return vm.getAlwaysOnVpnPackageForUser(userId) != null; } public static boolean disconnectLegacyVpn(Context context) { diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java index f5393508dfd..07c9b3d40e3 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java @@ -40,6 +40,7 @@ import android.content.pm.UserInfo; import android.content.res.Resources; import android.net.ConnectivityManager; import android.net.ProxyInfo; +import android.net.VpnManager; import android.os.UserHandle; import android.os.UserManager; import android.provider.Settings; @@ -84,6 +85,7 @@ public class EnterprisePrivacyFeatureProviderImplTest { private @Mock PackageManager mPackageManager; private @Mock UserManager mUserManager; private @Mock ConnectivityManager mConnectivityManger; + private @Mock VpnManager mVpnManager; private Resources mResources; private EnterprisePrivacyFeatureProvider mProvider; @@ -99,7 +101,7 @@ public class EnterprisePrivacyFeatureProviderImplTest { mResources = RuntimeEnvironment.application.getResources(); mProvider = new EnterprisePrivacyFeatureProviderImpl(mContext, mDevicePolicyManager, - mPackageManager, mUserManager, mConnectivityManger, mResources); + mPackageManager, mUserManager, mConnectivityManger, mVpnManager, mResources); } @Test @@ -201,11 +203,10 @@ public class EnterprisePrivacyFeatureProviderImplTest { @Test public void testIsAlwaysOnVpnSetInCurrentUser() { - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(MY_USER_ID)).thenReturn(null); + when(mVpnManager.getAlwaysOnVpnPackageForUser(MY_USER_ID)).thenReturn(null); assertThat(mProvider.isAlwaysOnVpnSetInCurrentUser()).isFalse(); - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(MY_USER_ID)) - .thenReturn(VPN_PACKAGE_ID); + when(mVpnManager.getAlwaysOnVpnPackageForUser(MY_USER_ID)).thenReturn(VPN_PACKAGE_ID); assertThat(mProvider.isAlwaysOnVpnSetInCurrentUser()).isTrue(); } @@ -215,11 +216,10 @@ public class EnterprisePrivacyFeatureProviderImplTest { mProfiles.add(new UserInfo(MANAGED_PROFILE_USER_ID, "", "", UserInfo.FLAG_MANAGED_PROFILE)); - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(MANAGED_PROFILE_USER_ID)) - .thenReturn(null); + when(mVpnManager.getAlwaysOnVpnPackageForUser(MANAGED_PROFILE_USER_ID)).thenReturn(null); assertThat(mProvider.isAlwaysOnVpnSetInManagedProfile()).isFalse(); - when(mConnectivityManger.getAlwaysOnVpnPackageForUser(MANAGED_PROFILE_USER_ID)) + when(mVpnManager.getAlwaysOnVpnPackageForUser(MANAGED_PROFILE_USER_ID)) .thenReturn(VPN_PACKAGE_ID); assertThat(mProvider.isAlwaysOnVpnSetInManagedProfile()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/vpn2/VpnUtilsTest.java b/tests/robotests/src/com/android/settings/vpn2/VpnUtilsTest.java index 7856b06a0b3..08a92428395 100644 --- a/tests/robotests/src/com/android/settings/vpn2/VpnUtilsTest.java +++ b/tests/robotests/src/com/android/settings/vpn2/VpnUtilsTest.java @@ -21,7 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import android.net.ConnectivityManager; +import android.net.VpnManager; import org.junit.Test; import org.junit.runner.RunWith; @@ -31,11 +31,11 @@ import org.robolectric.RobolectricTestRunner; public final class VpnUtilsTest { @Test public void testIsAlwaysOnVpnSet() { - final ConnectivityManager cm = mock(ConnectivityManager.class); - when(cm.getAlwaysOnVpnPackageForUser(0)).thenReturn("com.example.vpn"); - assertThat(VpnUtils.isAlwaysOnVpnSet(cm, 0)).isTrue(); + final VpnManager vm = mock(VpnManager.class); + when(vm.getAlwaysOnVpnPackageForUser(0)).thenReturn("com.example.vpn"); + assertThat(VpnUtils.isAlwaysOnVpnSet(vm, 0)).isTrue(); - when(cm.getAlwaysOnVpnPackageForUser(0)).thenReturn(null); - assertThat(VpnUtils.isAlwaysOnVpnSet(cm, 0)).isFalse(); + when(vm.getAlwaysOnVpnPackageForUser(0)).thenReturn(null); + assertThat(VpnUtils.isAlwaysOnVpnSet(vm, 0)).isFalse(); } } From 65128bab0802a6cf498f075391e9056f7aa19058 Mon Sep 17 00:00:00 2001 From: Lorenzo Colitti Date: Thu, 18 Feb 2021 16:32:47 +0900 Subject: [PATCH 12/12] Remove ConnectivityManager from EnterprisePrivacyFeatureProvider. It is only used in GlobalHttpPreferenceController. Move it there. Bug: 173331190 Test: atest SettingsRoboTests Change-Id: I62c589679052b276927d057d3d5d084bbfb57626 Merged-In: I62c589679052b276927d057d3d5d084bbfb57626 --- .../EnterprisePrivacyFeatureProvider.java | 5 ----- .../EnterprisePrivacyFeatureProviderImpl.java | 5 ----- .../GlobalHttpProxyPreferenceController.java | 9 ++++----- .../EnterprisePrivacyFeatureProviderImplTest.java | 11 ----------- .../GlobalHttpProxyPreferenceControllerTest.java | 14 ++++++-------- 5 files changed, 10 insertions(+), 34 deletions(-) diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java index 46f9b71f230..22fe76019d4 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java @@ -84,11 +84,6 @@ public interface EnterprisePrivacyFeatureProvider { */ boolean isAlwaysOnVpnSetInManagedProfile(); - /** - * Returns whether the Device Owner set a recommended global HTTP proxy. - */ - boolean isGlobalHttpProxySet(); - /** * Returns the number of failed login attempts that the Device Owner or Profile Owner allows * before the current user is wiped, or zero if no such limit is set. diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java index 59036a2c81d..ad57c3cfda9 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java @@ -143,11 +143,6 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe VpnUtils.isAlwaysOnVpnSet(mVm, managedProfileUserId); } - @Override - public boolean isGlobalHttpProxySet() { - return mCm.getGlobalProxy() != null; - } - @Override public int getMaximumFailedPasswordsBeforeWipeInCurrentUser() { ComponentName owner = mDpm.getDeviceOwnerComponentOnCallingUser(); diff --git a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java index 04e63aa1e8b..6de6cde359e 100644 --- a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java +++ b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java @@ -14,26 +14,25 @@ package com.android.settings.enterprise; import android.content.Context; +import android.net.ConnectivityManager; import com.android.settings.core.PreferenceControllerMixin; -import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.core.AbstractPreferenceController; public class GlobalHttpProxyPreferenceController extends AbstractPreferenceController implements PreferenceControllerMixin { private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy"; - private final EnterprisePrivacyFeatureProvider mFeatureProvider; + private final ConnectivityManager mCm; public GlobalHttpProxyPreferenceController(Context context) { super(context); - mFeatureProvider = FeatureFactory.getFactory(context) - .getEnterprisePrivacyFeatureProvider(context); + mCm = context.getSystemService(ConnectivityManager.class); } @Override public boolean isAvailable() { - return mFeatureProvider.isGlobalHttpProxySet(); + return mCm.getGlobalProxy() != null; } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java index 07c9b3d40e3..43fe0f612c9 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java @@ -39,7 +39,6 @@ import android.content.pm.ResolveInfo; import android.content.pm.UserInfo; import android.content.res.Resources; import android.net.ConnectivityManager; -import android.net.ProxyInfo; import android.net.VpnManager; import android.os.UserHandle; import android.os.UserManager; @@ -224,16 +223,6 @@ public class EnterprisePrivacyFeatureProviderImplTest { assertThat(mProvider.isAlwaysOnVpnSetInManagedProfile()).isTrue(); } - @Test - public void testIsGlobalHttpProxySet() { - when(mConnectivityManger.getGlobalProxy()).thenReturn(null); - assertThat(mProvider.isGlobalHttpProxySet()).isFalse(); - - when(mConnectivityManger.getGlobalProxy()) - .thenReturn(ProxyInfo.buildDirectProxy("localhost", 123)); - assertThat(mProvider.isGlobalHttpProxySet()).isTrue(); - } - @Test public void testGetMaximumFailedPasswordsForWipeInCurrentUser() { when(mDevicePolicyManager.getDeviceOwnerComponentOnCallingUser()).thenReturn(null); diff --git a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java index 05d1c640fd0..11676a28378 100644 --- a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java @@ -21,11 +21,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.when; import android.content.Context; +import android.net.ConnectivityManager; +import android.net.ProxyInfo; import androidx.preference.Preference; -import com.android.settings.testutils.FakeFeatureFactory; - import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -41,25 +41,23 @@ public class GlobalHttpProxyPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; - private FakeFeatureFactory mFeatureFactory; + @Mock + private ConnectivityManager mCm; private GlobalHttpProxyPreferenceController mController; @Before public void setUp() { MockitoAnnotations.initMocks(this); - mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = new GlobalHttpProxyPreferenceController(mContext); } @Test public void testIsAvailable() { - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) - .thenReturn(false); + when(mCm.getGlobalProxy()).thenReturn(null); assertThat(mController.isAvailable()).isFalse(); - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) - .thenReturn(true); + when(mCm.getGlobalProxy()).thenReturn(ProxyInfo.buildDirectProxy("localhost", 123)); assertThat(mController.isAvailable()).isTrue(); }