From b15cc090d16cff3c835c03506687f12d060d3eea Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sat, 19 Jan 2019 16:45:20 +0800 Subject: [PATCH] Game Driver: Add SwitchBar to control GUP feature Uncheck the global switch will hide the preference controllers and force all apps to use system graphics driver. This change also add a content observer to notify all the preference controllers of settings global changes. Bug: 119221883 Test: make RunSettingsRoboTests Change-Id: Ice9ded17c759791a3728c552f79881e2215ac081 Merged-In: Ice9ded17c759791a3728c552f79881e2215ac081 --- .../development/gup/GameDriverContentObserver.java | 56 ++++++++++ .../settings/development/gup/GupDashboard.java | 20 +++- .../GupEnableForAllAppsPreferenceController.java | 57 ++++++++-- .../gup/GupGlobalSwitchBarController.java | 98 ++++++++++++++++ .../development/gup/GupPreferenceController.java | 90 +++++++++++---- .../gup/GameDriverContentObserverTest.java | 70 ++++++++++++ ...upEnableForAllAppsPreferenceControllerTest.java | 26 ++++- .../gup/GupGlobalSwitchBarControllerTest.java | 124 +++++++++++++++++++++ .../gup/GupPreferenceControllerTest.java | 34 +++++- 9 files changed, 536 insertions(+), 39 deletions(-) create mode 100644 src/com/android/settings/development/gup/GameDriverContentObserver.java create mode 100644 src/com/android/settings/development/gup/GupGlobalSwitchBarController.java create mode 100644 tests/robotests/src/com/android/settings/development/gup/GameDriverContentObserverTest.java create mode 100644 tests/robotests/src/com/android/settings/development/gup/GupGlobalSwitchBarControllerTest.java diff --git a/src/com/android/settings/development/gup/GameDriverContentObserver.java b/src/com/android/settings/development/gup/GameDriverContentObserver.java new file mode 100644 index 0000000000..92602134c0 --- /dev/null +++ b/src/com/android/settings/development/gup/GameDriverContentObserver.java @@ -0,0 +1,56 @@ +/* + * Copyright 2019 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.development.gup; + +import android.content.ContentResolver; +import android.database.ContentObserver; +import android.os.Handler; +import android.provider.Settings; + +import androidx.annotation.VisibleForTesting; + +/** + * Helper class to observe Game Driver settings global change. + */ +public class GameDriverContentObserver extends ContentObserver { + interface OnGameDriverContentChangedListener { + void onGameDriverContentChanged(); + } + + @VisibleForTesting + OnGameDriverContentChangedListener mListener; + + public GameDriverContentObserver(Handler handler, OnGameDriverContentChangedListener listener) { + super(handler); + mListener = listener; + } + + @Override + public void onChange(boolean selfChange) { + super.onChange(selfChange); + mListener.onGameDriverContentChanged(); + } + + public void register(ContentResolver contentResolver) { + contentResolver.registerContentObserver( + Settings.Global.getUriFor(Settings.Global.GUP_DEV_ALL_APPS), false, this); + } + + public void unregister(ContentResolver contentResolver) { + contentResolver.unregisterContentObserver(this); + } +} diff --git a/src/com/android/settings/development/gup/GupDashboard.java b/src/com/android/settings/development/gup/GupDashboard.java index 674a0a90d0..392de47bd7 100644 --- a/src/com/android/settings/development/gup/GupDashboard.java +++ b/src/com/android/settings/development/gup/GupDashboard.java @@ -17,14 +17,20 @@ package com.android.settings.development.gup; import android.content.Context; +import android.os.Bundle; import com.android.internal.logging.nano.MetricsProto; import com.android.settings.R; +import com.android.settings.SettingsActivity; import com.android.settings.dashboard.DashboardFragment; -import com.android.settingslib.core.AbstractPreferenceController; +import com.android.settings.widget.SwitchBar; +import com.android.settings.widget.SwitchBarController; import java.util.List; +/** + * Dashboard for Game Driver preferences. + */ public class GupDashboard extends DashboardFragment { private static final String TAG = "GupDashboard"; @@ -47,4 +53,16 @@ public class GupDashboard extends DashboardFragment { public int getHelpResource() { return 0; } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + final SettingsActivity activity = (SettingsActivity) getActivity(); + final SwitchBar switchBar = activity.getSwitchBar(); + final GupGlobalSwitchBarController switchBarController = + new GupGlobalSwitchBarController(activity, new SwitchBarController(switchBar)); + getLifecycle().addObserver(switchBarController); + switchBar.show(); + } } diff --git a/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceController.java b/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceController.java index 3c2d8b88b1..b71e9f334e 100644 --- a/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceController.java +++ b/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceController.java @@ -18,55 +18,92 @@ package com.android.settings.development.gup; import android.content.ContentResolver; import android.content.Context; +import android.os.Handler; +import android.os.Looper; import android.provider.Settings; +import androidx.annotation.VisibleForTesting; import androidx.preference.Preference; import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.core.lifecycle.LifecycleObserver; +import com.android.settingslib.core.lifecycle.events.OnStart; +import com.android.settingslib.core.lifecycle.events.OnStop; import com.android.settingslib.development.DevelopmentSettingsEnabler; -public class GupEnableForAllAppsPreferenceController - extends BasePreferenceController implements Preference.OnPreferenceChangeListener { +/** + * Controller of global switch to enable Game Driver for all Apps. + */ +public class GupEnableForAllAppsPreferenceController extends BasePreferenceController + implements Preference.OnPreferenceChangeListener, + GameDriverContentObserver.OnGameDriverContentChangedListener, LifecycleObserver, + OnStart, OnStop { public static final int GUP_DEFAULT = 0; public static final int GUP_ALL_APPS = 1; + public static final int GUP_OFF = 2; + private final Context mContext; private final ContentResolver mContentResolver; + @VisibleForTesting + GameDriverContentObserver mGameDriverContentObserver; + + private SwitchPreference mPreference; public GupEnableForAllAppsPreferenceController(Context context, String key) { super(context, key); + mContext = context; mContentResolver = context.getContentResolver(); + mGameDriverContentObserver = + new GameDriverContentObserver(new Handler(Looper.getMainLooper()), this); } @Override public int getAvailabilityStatus() { return DevelopmentSettingsEnabler.isDevelopmentSettingsEnabled(mContext) + && (Settings.Global.getInt( + mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT) + != GUP_OFF) ? AVAILABLE - : DISABLED_DEPENDENT_SETTING; + : CONDITIONALLY_UNAVAILABLE; } @Override public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); - final SwitchPreference switchPreference = - (SwitchPreference) screen.findPreference(getPreferenceKey()); - if (switchPreference == null) { - return; - } + mPreference = (SwitchPreference) screen.findPreference(getPreferenceKey()); + } + @Override + public void onStart() { + mGameDriverContentObserver.register(mContentResolver); + } + + @Override + public void onStop() { + mGameDriverContentObserver.unregister(mContentResolver); + } + + @Override + public void updateState(Preference preference) { + final SwitchPreference switchPreference = (SwitchPreference) preference; + switchPreference.setVisible(isAvailable()); switchPreference.setChecked(Settings.Global.getInt(mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT) == GUP_ALL_APPS); - switchPreference.setOnPreferenceChangeListener(this); } @Override public boolean onPreferenceChange(Preference preference, Object newValue) { - // When developer option is present, always overwrite GUP_DEV_ALL_APPS. Settings.Global.putInt(mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, (boolean) newValue ? GUP_ALL_APPS : GUP_DEFAULT); return true; } + + @Override + public void onGameDriverContentChanged() { + updateState(mPreference); + } } diff --git a/src/com/android/settings/development/gup/GupGlobalSwitchBarController.java b/src/com/android/settings/development/gup/GupGlobalSwitchBarController.java new file mode 100644 index 0000000000..c6bdf9dd33 --- /dev/null +++ b/src/com/android/settings/development/gup/GupGlobalSwitchBarController.java @@ -0,0 +1,98 @@ +/* + * Copyright 2019 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.development.gup; + +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_ALL_APPS; +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_DEFAULT; +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_OFF; + +import android.content.ContentResolver; +import android.content.Context; +import android.os.Handler; +import android.os.Looper; +import android.provider.Settings; + +import androidx.annotation.VisibleForTesting; + +import com.android.settings.widget.SwitchWidgetController; +import com.android.settingslib.core.lifecycle.LifecycleObserver; +import com.android.settingslib.core.lifecycle.events.OnStart; +import com.android.settingslib.core.lifecycle.events.OnStop; +import com.android.settingslib.development.DevelopmentSettingsEnabler; + +/** + * Controller of global switch bar used to fully turn off Game Driver. + */ +public class GupGlobalSwitchBarController + implements SwitchWidgetController.OnSwitchChangeListener, + GameDriverContentObserver.OnGameDriverContentChangedListener, LifecycleObserver, + OnStart, OnStop { + private final Context mContext; + private final ContentResolver mContentResolver; + @VisibleForTesting + SwitchWidgetController mSwitchWidgetController; + @VisibleForTesting + GameDriverContentObserver mGameDriverContentObserver; + + GupGlobalSwitchBarController(Context context, SwitchWidgetController switchWidgetController) { + mContext = context; + mContentResolver = context.getContentResolver(); + mGameDriverContentObserver = + new GameDriverContentObserver(new Handler(Looper.getMainLooper()), this); + mSwitchWidgetController = switchWidgetController; + mSwitchWidgetController.setEnabled( + DevelopmentSettingsEnabler.isDevelopmentSettingsEnabled(context)); + mSwitchWidgetController.setChecked(Settings.Global.getInt(mContentResolver, + Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT) + != GUP_OFF); + mSwitchWidgetController.setListener(this); + } + + @Override + public void onStart() { + mSwitchWidgetController.startListening(); + mGameDriverContentObserver.register(mContentResolver); + } + + @Override + public void onStop() { + mSwitchWidgetController.stopListening(); + mGameDriverContentObserver.unregister(mContentResolver); + } + + @Override + public boolean onSwitchToggled(boolean isChecked) { + if (!isChecked) { + Settings.Global.putInt(mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_OFF); + return true; + } + + if (Settings.Global.getInt(mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT) + != GUP_ALL_APPS) { + Settings.Global.putInt(mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT); + } + + return true; + } + + @Override + public void onGameDriverContentChanged() { + mSwitchWidgetController.setChecked(Settings.Global.getInt(mContentResolver, + Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT) + != GUP_OFF); + } +} diff --git a/src/com/android/settings/development/gup/GupPreferenceController.java b/src/com/android/settings/development/gup/GupPreferenceController.java index d4cd2f1284..8fed52cc63 100644 --- a/src/com/android/settings/development/gup/GupPreferenceController.java +++ b/src/com/android/settings/development/gup/GupPreferenceController.java @@ -16,11 +16,16 @@ package com.android.settings.development.gup; +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_DEFAULT; +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_OFF; + import android.content.ContentResolver; import android.content.Context; import android.content.pm.ApplicationInfo; import android.content.pm.PackageManager; import android.content.res.Resources; +import android.os.Handler; +import android.os.Looper; import android.provider.Settings; import androidx.annotation.VisibleForTesting; @@ -31,6 +36,9 @@ import androidx.preference.PreferenceScreen; import com.android.settings.R; import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.core.lifecycle.LifecycleObserver; +import com.android.settingslib.core.lifecycle.events.OnStart; +import com.android.settingslib.core.lifecycle.events.OnStop; import com.android.settingslib.development.DevelopmentSettingsEnabler; import java.text.Collator; @@ -42,21 +50,37 @@ import java.util.HashSet; import java.util.List; import java.util.Set; -public class GupPreferenceController - extends BasePreferenceController implements Preference.OnPreferenceChangeListener { +/** + * Controller of all the per App based list preferences. + */ +public class GupPreferenceController extends BasePreferenceController + implements Preference.OnPreferenceChangeListener, + GameDriverContentObserver.OnGameDriverContentChangedListener, LifecycleObserver, + OnStart, OnStop { + private final Context mContext; + private final ContentResolver mContentResolver; private final CharSequence[] mEntryList; private final String mPreferenceTitle; private final String mPreferenceDefault; private final String mPreferenceGup; private final String mPreferenceSystem; + @VisibleForTesting + GameDriverContentObserver mGameDriverContentObserver; private final List mAppInfos; private final Set mDevOptInApps; private final Set mDevOptOutApps; + private PreferenceGroup mPreferenceGroup; + public GupPreferenceController(Context context, String key) { super(context, key); + mContext = context; + mContentResolver = context.getContentResolver(); + mGameDriverContentObserver = + new GameDriverContentObserver(new Handler(Looper.getMainLooper()), this); + final Resources resources = context.getResources(); mEntryList = resources.getStringArray(R.array.gup_app_preference_values); mPreferenceTitle = resources.getString(R.string.gup_app_preference_title); @@ -68,36 +92,58 @@ public class GupPreferenceController // Update the UI when all the app infos are ready. mAppInfos = getAppInfos(context); - final ContentResolver contentResolver = context.getContentResolver(); mDevOptInApps = - getGlobalSettingsString(contentResolver, Settings.Global.GUP_DEV_OPT_IN_APPS); + getGlobalSettingsString(mContentResolver, Settings.Global.GUP_DEV_OPT_IN_APPS); mDevOptOutApps = - getGlobalSettingsString(contentResolver, Settings.Global.GUP_DEV_OPT_OUT_APPS); + getGlobalSettingsString(mContentResolver, Settings.Global.GUP_DEV_OPT_OUT_APPS); } @Override public int getAvailabilityStatus() { return DevelopmentSettingsEnabler.isDevelopmentSettingsEnabled(mContext) + && (Settings.Global.getInt( + mContentResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT) + != GUP_OFF) ? AVAILABLE - : DISABLED_DEPENDENT_SETTING; + : CONDITIONALLY_UNAVAILABLE; } @Override public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); - final PreferenceGroup preferenceGroup = - (PreferenceGroup) screen.findPreference(getPreferenceKey()); - if (preferenceGroup == null) { - return; - } + mPreferenceGroup = (PreferenceGroup) screen.findPreference(getPreferenceKey()); + final Context context = mPreferenceGroup.getContext(); for (AppInfo appInfo : mAppInfos) { - preferenceGroup.addPreference( - createListPreference(appInfo.info.packageName, appInfo.label)); + mPreferenceGroup.addPreference( + createListPreference(context, appInfo.info.packageName, appInfo.label)); } } @Override + public void onStart() { + mGameDriverContentObserver.register(mContentResolver); + } + + @Override + public void onStop() { + mGameDriverContentObserver.unregister(mContentResolver); + } + + @Override + public void updateState(Preference preference) { + // This is a workaround, because PreferenceGroup.setVisible is not applied to the + // preferences inside the group. + final boolean isGroupAvailable = isAvailable(); + final PreferenceGroup group = (PreferenceGroup) preference; + for (int idx = 0; idx < group.getPreferenceCount(); idx++) { + final Preference pref = group.getPreference(idx); + pref.setVisible(isGroupAvailable); + } + preference.setVisible(isGroupAvailable); + } + + @Override public boolean onPreferenceChange(Preference preference, Object newValue) { final ListPreference listPref = (ListPreference) preference; final String value = newValue.toString(); @@ -120,14 +166,19 @@ public class GupPreferenceController // Push the updated Sets for opt-in and opt-out apps to // corresponding Settings.Global.GUP_DEV_OPT_(IN|OUT)_APPS - Settings.Global.putString(mContext.getContentResolver(), - Settings.Global.GUP_DEV_OPT_IN_APPS, String.join(",", mDevOptInApps)); - Settings.Global.putString(mContext.getContentResolver(), - Settings.Global.GUP_DEV_OPT_OUT_APPS, String.join(",", mDevOptOutApps)); + Settings.Global.putString(mContentResolver, Settings.Global.GUP_DEV_OPT_IN_APPS, + String.join(",", mDevOptInApps)); + Settings.Global.putString(mContentResolver, Settings.Global.GUP_DEV_OPT_OUT_APPS, + String.join(",", mDevOptOutApps)); return true; } + @Override + public void onGameDriverContentChanged() { + updateState(mPreferenceGroup); + } + // AppInfo class to achieve loading the application label only once class AppInfo { AppInfo(PackageManager packageManager, ApplicationInfo applicationInfo) { @@ -176,8 +227,9 @@ public class GupPreferenceController }; @VisibleForTesting - protected ListPreference createListPreference(String packageName, String appName) { - final ListPreference listPreference = new ListPreference(mContext); + protected ListPreference createListPreference( + Context context, String packageName, String appName) { + final ListPreference listPreference = new ListPreference(context); listPreference.setKey(packageName); listPreference.setTitle(appName); diff --git a/tests/robotests/src/com/android/settings/development/gup/GameDriverContentObserverTest.java b/tests/robotests/src/com/android/settings/development/gup/GameDriverContentObserverTest.java new file mode 100644 index 0000000000..6939ac9e2d --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/gup/GameDriverContentObserverTest.java @@ -0,0 +1,70 @@ +/* + * Copyright 2019 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.development.gup; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import android.content.ContentResolver; +import android.provider.Settings; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class GameDriverContentObserverTest { + @Mock + private ContentResolver mResolver; + @Mock + private GameDriverContentObserver.OnGameDriverContentChangedListener mListener; + + private GameDriverContentObserver mGameDriverContentObserver; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mGameDriverContentObserver = spy(new GameDriverContentObserver(null, null)); + } + + @Test + public void onChange_shouldCallListener() { + mGameDriverContentObserver.mListener = mListener; + mGameDriverContentObserver.onChange(true); + + verify(mListener).onGameDriverContentChanged(); + } + + @Test + public void register_shouldRegisterContentObserver() { + mGameDriverContentObserver.register(mResolver); + + verify(mResolver).registerContentObserver( + Settings.Global.getUriFor(Settings.Global.GUP_DEV_ALL_APPS), false, + mGameDriverContentObserver); + } + + @Test + public void unregister_shouldUnregisterContentObserver() { + mGameDriverContentObserver.unregister(mResolver); + + verify(mResolver).unregisterContentObserver(mGameDriverContentObserver); + } +} diff --git a/tests/robotests/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceControllerTest.java index 4dbdd35e17..cd8c710810 100644 --- a/tests/robotests/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/development/gup/GupEnableForAllAppsPreferenceControllerTest.java @@ -20,6 +20,7 @@ import static com.android.settings.development.gup.GupEnableForAllAppsPreference import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_DEFAULT; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -44,6 +45,8 @@ public class GupEnableForAllAppsPreferenceControllerTest { private PreferenceScreen mScreen; @Mock private SwitchPreference mPreference; + @Mock + private GameDriverContentObserver mGameDriverContentObserver; private Context mContext; private ContentResolver mResolver; @@ -56,20 +59,38 @@ public class GupEnableForAllAppsPreferenceControllerTest { mResolver = mContext.getContentResolver(); mController = new GupEnableForAllAppsPreferenceController(mContext, "testKey"); when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mPreference); + mController.displayPreference(mScreen); + + Settings.Global.putInt(mResolver, Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 1); } @Test public void displayPreference_shouldAddSwitchPreference() { Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT); - mController.displayPreference(mScreen); + mController.updateState(mPreference); verify(mPreference).setChecked(false); } @Test + public void onStart_shouldRegister() { + mController.mGameDriverContentObserver = mGameDriverContentObserver; + mController.onStart(); + + verify(mGameDriverContentObserver).register(mResolver); + } + + @Test + public void onStop_shouldUnregister() { + mController.mGameDriverContentObserver = mGameDriverContentObserver; + mController.onStop(); + + verify(mGameDriverContentObserver).unregister(mResolver); + } + + @Test public void onPreferenceChange_check_shouldUpdateSettingsGlobal() { Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT); - mController.displayPreference(mScreen); mController.onPreferenceChange(mPreference, true); assertThat(Settings.Global.getInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT)) @@ -79,7 +100,6 @@ public class GupEnableForAllAppsPreferenceControllerTest { @Test public void onPreferenceChange_uncheck_shouldUpdateSettingsGlobal() { Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_ALL_APPS); - mController.displayPreference(mScreen); mController.onPreferenceChange(mPreference, false); assertThat(Settings.Global.getInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT)) diff --git a/tests/robotests/src/com/android/settings/development/gup/GupGlobalSwitchBarControllerTest.java b/tests/robotests/src/com/android/settings/development/gup/GupGlobalSwitchBarControllerTest.java new file mode 100644 index 0000000000..0d3ed481fc --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/gup/GupGlobalSwitchBarControllerTest.java @@ -0,0 +1,124 @@ +/* + * Copyright 2019 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.development.gup; + +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_DEFAULT; +import static com.android.settings.development.gup.GupEnableForAllAppsPreferenceController.GUP_OFF; +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.verify; + +import android.content.ContentResolver; +import android.content.Context; +import android.provider.Settings; + +import com.android.settings.widget.SwitchBar; +import com.android.settings.widget.SwitchBarController; +import com.android.settings.widget.SwitchWidgetController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class GupGlobalSwitchBarControllerTest { + @Mock + private SwitchBar mSwitchBar; + @Mock + private SwitchWidgetController mSwitchWidgetController; + @Mock + private GameDriverContentObserver mGameDriverContentObserver; + + private Context mContext; + private ContentResolver mResolver; + private GupGlobalSwitchBarController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mResolver = mContext.getContentResolver(); + } + + @Test + public void constructor_gupOn_shouldCheckSwitchBar() { + Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT); + mController = + new GupGlobalSwitchBarController(mContext, new SwitchBarController(mSwitchBar)); + + verify(mSwitchBar).setChecked(true); + } + + @Test + public void constructor_gupOff_shouldUncheckSwitchBar() { + Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_OFF); + mController = + new GupGlobalSwitchBarController(mContext, new SwitchBarController(mSwitchBar)); + + verify(mSwitchBar).setChecked(false); + } + + @Test + public void onStart_shouldStartListeningAndRegister() { + mController = + new GupGlobalSwitchBarController(mContext, new SwitchBarController(mSwitchBar)); + mController.mSwitchWidgetController = mSwitchWidgetController; + mController.mGameDriverContentObserver = mGameDriverContentObserver; + mController.onStart(); + + verify(mSwitchWidgetController).startListening(); + verify(mGameDriverContentObserver).register(mResolver); + } + + @Test + public void onStop_shouldStopListeningAndUnregister() { + mController = + new GupGlobalSwitchBarController(mContext, new SwitchBarController(mSwitchBar)); + mController.mSwitchWidgetController = mSwitchWidgetController; + mController.mGameDriverContentObserver = mGameDriverContentObserver; + mController.onStop(); + + verify(mSwitchWidgetController).stopListening(); + verify(mGameDriverContentObserver).unregister(mResolver); + } + + @Test + public void onSwitchToggled_checked_shouldTurnOnGup() { + Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_OFF); + mController = + new GupGlobalSwitchBarController(mContext, new SwitchBarController(mSwitchBar)); + mController.onSwitchToggled(true); + + assertThat(Settings.Global.getInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT)) + .isEqualTo(GUP_DEFAULT); + } + + @Test + public void onSwitchToggled_unchecked_shouldTurnOffGup() { + Settings.Global.putInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT); + mController = + new GupGlobalSwitchBarController(mContext, new SwitchBarController(mSwitchBar)); + mController.onSwitchToggled(false); + + assertThat(Settings.Global.getInt(mResolver, Settings.Global.GUP_DEV_ALL_APPS, GUP_DEFAULT)) + .isEqualTo(GUP_OFF); + } +} diff --git a/tests/robotests/src/com/android/settings/development/gup/GupPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/gup/GupPreferenceControllerTest.java index 0ac14ef007..8055c94ae3 100644 --- a/tests/robotests/src/com/android/settings/development/gup/GupPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/development/gup/GupPreferenceControllerTest.java @@ -20,6 +20,7 @@ import static com.android.settings.testutils.ApplicationTestUtils.buildInfo; import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.content.ContentResolver; @@ -63,6 +64,8 @@ public class GupPreferenceControllerTest { private PackageManager mPackageManager; @Mock private PreferenceScreen mScreen; + @Mock + private GameDriverContentObserver mGameDriverContentObserver; private Context mContext; private PreferenceGroup mGroup; @@ -93,10 +96,28 @@ public class GupPreferenceControllerTest { } @Test + public void onStart_shouldRegister() { + loadDefaultConfig(); + mController.mGameDriverContentObserver = mGameDriverContentObserver; + mController.onStart(); + + verify(mGameDriverContentObserver).register(mResolver); + } + + @Test + public void onStop_shouldUnregister() { + loadDefaultConfig(); + mController.mGameDriverContentObserver = mGameDriverContentObserver; + mController.onStop(); + + verify(mGameDriverContentObserver).unregister(mResolver); + } + + @Test public void createPreference_configDefault_shouldSetDefaultAttributes() { loadDefaultConfig(); final ListPreference preference = - mController.createListPreference(TEST_PKG_NAME, TEST_APP_NAME); + mController.createListPreference(mContext, TEST_PKG_NAME, TEST_APP_NAME); assertThat(preference.getKey()).isEqualTo(TEST_PKG_NAME); assertThat(preference.getTitle()).isEqualTo(TEST_APP_NAME); @@ -112,7 +133,7 @@ public class GupPreferenceControllerTest { public void createPreference_configGup_shouldSetGupAttributes() { loadConfig(TEST_PKG_NAME, ""); final ListPreference preference = - mController.createListPreference(TEST_PKG_NAME, TEST_APP_NAME); + mController.createListPreference(mContext, TEST_PKG_NAME, TEST_APP_NAME); assertThat(preference.getKey()).isEqualTo(TEST_PKG_NAME); assertThat(preference.getTitle()).isEqualTo(TEST_APP_NAME); @@ -128,7 +149,7 @@ public class GupPreferenceControllerTest { public void createPreference_configSystem_shouldSetSystemAttributes() { loadConfig("", TEST_PKG_NAME); final ListPreference preference = - mController.createListPreference(TEST_PKG_NAME, TEST_APP_NAME); + mController.createListPreference(mContext, TEST_PKG_NAME, TEST_APP_NAME); assertThat(preference.getKey()).isEqualTo(TEST_PKG_NAME); assertThat(preference.getTitle()).isEqualTo(TEST_APP_NAME); @@ -144,7 +165,7 @@ public class GupPreferenceControllerTest { public void onPreferenceChange_selectDefault_shouldUpdateAttributesAndSettingsGlobal() { loadDefaultConfig(); final ListPreference preference = - mController.createListPreference(TEST_PKG_NAME, TEST_APP_NAME); + mController.createListPreference(mContext, TEST_PKG_NAME, TEST_APP_NAME); mController.onPreferenceChange(preference, mValueList[DEFAULT]); assertThat(preference.getEntry()).isEqualTo(mValueList[DEFAULT]); @@ -160,7 +181,7 @@ public class GupPreferenceControllerTest { public void onPreferenceChange_selectGup_shouldUpdateAttributesAndSettingsGlobal() { loadDefaultConfig(); final ListPreference preference = - mController.createListPreference(TEST_PKG_NAME, TEST_APP_NAME); + mController.createListPreference(mContext, TEST_PKG_NAME, TEST_APP_NAME); mController.onPreferenceChange(preference, mValueList[GUP]); assertThat(preference.getEntry()).isEqualTo(mValueList[GUP]); @@ -176,7 +197,7 @@ public class GupPreferenceControllerTest { public void onPreferenceChange_selectSystem_shouldUpdateAttributesAndSettingsGlobal() { loadDefaultConfig(); final ListPreference preference = - mController.createListPreference(TEST_PKG_NAME, TEST_APP_NAME); + mController.createListPreference(mContext, TEST_PKG_NAME, TEST_APP_NAME); mController.onPreferenceChange(preference, mValueList[SYSTEM]); assertThat(preference.getEntry()).isEqualTo(mValueList[SYSTEM]); @@ -212,6 +233,7 @@ public class GupPreferenceControllerTest { mController = new GupPreferenceController(mContext, "testKey"); mGroup = spy(new PreferenceCategory(mContext)); final PreferenceManager preferenceManager = new PreferenceManager(mContext); + when(mGroup.getContext()).thenReturn(mContext); when(mGroup.getPreferenceManager()).thenReturn(preferenceManager); when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mGroup); mController.displayPreference(mScreen); -- 2.11.0