From cc20600102f7b61bac8be6160cce64fd4b1dde11 Mon Sep 17 00:00:00 2001 From: Doris Ling Date: Wed, 7 Dec 2016 13:21:20 -0800 Subject: [PATCH] Add check for DISALLOW_DEBUGGING_FEATURES restriction - if the user has restriction for the action DISALLOW_DEBUGGING_FEATURES, remove the preference for taking bug report and the switch preference to enable bug report shortcut in the power key. - refactor DevelopmentSettings to use preference controller for Take bug report and enable bug report in power key. Fixes: 27145643 Test: make RunSettingsRoboTests Change-Id: I18784d218d37956130c33f527d514ab703727397 --- .../android/settings/DevelopmentSettings.java | 45 ++-- .../BugReportInPowerPreferenceController.java | 119 +++++++++++ .../BugReportPreferenceController.java | 62 ++++++ ...ReportInPowerPreferenceControllerTest.java | 193 ++++++++++++++++++ .../BugReportPreferenceControllerTest.java | 106 ++++++++++ 5 files changed, 499 insertions(+), 26 deletions(-) create mode 100644 src/com/android/settings/development/BugReportInPowerPreferenceController.java create mode 100644 src/com/android/settings/development/BugReportPreferenceController.java create mode 100644 tests/robotests/src/com/android/settings/development/BugReportInPowerPreferenceControllerTest.java create mode 100644 tests/robotests/src/com/android/settings/development/BugReportPreferenceControllerTest.java diff --git a/src/com/android/settings/DevelopmentSettings.java b/src/com/android/settings/DevelopmentSettings.java index 867fbfd9332..41d96d642c2 100644 --- a/src/com/android/settings/DevelopmentSettings.java +++ b/src/com/android/settings/DevelopmentSettings.java @@ -83,6 +83,8 @@ import com.android.internal.app.LocalePicker; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.applications.BackgroundCheckSummary; import com.android.settings.dashboard.DashboardFeatureProvider; +import com.android.settings.development.BugReportPreferenceController; +import com.android.settings.development.BugReportInPowerPreferenceController; import com.android.settings.fuelgauge.InactiveApps; import com.android.settings.overlay.FeatureFactory; import com.android.settings.search.BaseSearchIndexProvider; @@ -129,8 +131,6 @@ public class DevelopmentSettings extends RestrictedSettingsFragment private static final String LOCAL_BACKUP_PASSWORD = "local_backup_password"; private static final String HARDWARE_UI_PROPERTY = "persist.sys.ui.hw"; private static final String MSAA_PROPERTY = "debug.egl.force_msaa"; - private static final String BUGREPORT = "bugreport"; - private static final String BUGREPORT_IN_POWER_KEY = "bugreport_in_power"; private static final String OPENGL_TRACES_PROPERTY = "debug.egl.trace"; private static final String TUNER_UI_KEY = "tuner_ui"; private static final String COLOR_TEMPERATURE_PROPERTY = "persist.sys.debug.color_temp"; @@ -248,8 +248,6 @@ public class DevelopmentSettings extends RestrictedSettingsFragment private SwitchPreference mEnableAdb; private Preference mClearAdbKeys; private SwitchPreference mEnableTerminal; - private Preference mBugreport; - private SwitchPreference mBugreportInPower; private RestrictedSwitchPreference mKeepScreenOn; private SwitchPreference mBtHciSnoopLog; private RestrictedSwitchPreference mEnableOemUnlock; @@ -330,6 +328,8 @@ public class DevelopmentSettings extends RestrictedSettingsFragment private boolean mLogpersistCleared; private Dialog mLogpersistClearDialog; private DashboardFeatureProvider mDashboardFeatureProvider; + private BugReportPreferenceController mBugReportController; + private BugReportInPowerPreferenceController mBugReportInPowerController; public DevelopmentSettings() { super(UserManager.DISALLOW_DEBUGGING_FEATURES); @@ -365,6 +365,9 @@ public class DevelopmentSettings extends RestrictedSettingsFragment mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); + mBugReportController = new BugReportPreferenceController(getActivity()); + mBugReportInPowerController = new BugReportInPowerPreferenceController(getActivity()); + setIfOnlyAvailableForAdmins(true); if (isUiRestricted() || !Utils.isDeviceProvisioned(getActivity())) { // Block access to developer options if the user is not the owner, if user policy @@ -392,8 +395,9 @@ public class DevelopmentSettings extends RestrictedSettingsFragment mEnableTerminal = null; } - mBugreport = findPreference(BUGREPORT); - mBugreportInPower = findAndInitSwitchPref(BUGREPORT_IN_POWER_KEY); + mBugReportController.displayPreference(getPreferenceScreen()); + mBugReportInPowerController.displayPreference(getPreferenceScreen()); + mKeepScreenOn = (RestrictedSwitchPreference) findAndInitSwitchPref(KEEP_SCREEN_ON); mBtHciSnoopLog = findAndInitSwitchPref(BT_HCI_SNOOP_LOG); mEnableOemUnlock = (RestrictedSwitchPreference) findAndInitSwitchPref(ENABLE_OEM_UNLOCK); @@ -601,6 +605,7 @@ public class DevelopmentSettings extends RestrictedSettingsFragment Preference pref = mAllPrefs.get(i); pref.setEnabled(enabled && !mDisabledPrefs.contains(pref)); } + mBugReportInPowerController.enablePreference(enabled); updateAllOptions(); } @@ -702,8 +707,7 @@ public class DevelopmentSettings extends RestrictedSettingsFragment context.getPackageManager().getApplicationEnabledSetting(TERMINAL_APP_PACKAGE) == PackageManager.COMPONENT_ENABLED_STATE_ENABLED); } - updateSwitchPreference(mBugreportInPower, Settings.Secure.getInt(cr, - Settings.Global.BUGREPORT_IN_POWER_MENU, 0) != 0); + mHaveDebugSettings |= mBugReportInPowerController.updatePreference(); updateSwitchPreference(mKeepScreenOn, Settings.Global.getInt(cr, Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0) != 0); updateSwitchPreference(mBtHciSnoopLog, Settings.Secure.getInt(cr, @@ -765,6 +769,7 @@ public class DevelopmentSettings extends RestrictedSettingsFragment onPreferenceTreeClick(cb); } } + mBugReportInPowerController.resetPreference(); resetDebuggerOptions(); writeLogpersistOption(null, true); writeLogdSizeOption(null); @@ -1076,19 +1081,8 @@ public class DevelopmentSettings extends RestrictedSettingsFragment } private void updateBugreportOptions() { - mBugreport.setEnabled(true); - mBugreportInPower.setEnabled(true); - setBugreportStorageProviderStatus(); - } - - private void setBugreportStorageProviderStatus() { - final ComponentName componentName = new ComponentName("com.android.shell", - "com.android.shell.BugreportStorageProvider"); - final boolean enabled = mBugreportInPower.isChecked(); - getPackageManager().setComponentEnabledSetting(componentName, - enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED - : PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, - 0); + mBugReportController.enablePreference(true); + mBugReportInPowerController.updateBugreportOptions(); } // Returns the current state of the system property that controls @@ -1951,6 +1945,10 @@ public class DevelopmentSettings extends RestrictedSettingsFragment return false; } + if (mBugReportInPowerController.handlePreferenceTreeClick(preference)) { + return true; + } + if (preference == mEnableAdb) { if (mEnableAdb.isChecked()) { mDialogClicked = false; @@ -1981,11 +1979,6 @@ public class DevelopmentSettings extends RestrictedSettingsFragment pm.setApplicationEnabledSetting(TERMINAL_APP_PACKAGE, mEnableTerminal.isChecked() ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED : PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, 0); - } else if (preference == mBugreportInPower) { - Settings.Secure.putInt(getActivity().getContentResolver(), - Settings.Global.BUGREPORT_IN_POWER_MENU, - mBugreportInPower.isChecked() ? 1 : 0); - setBugreportStorageProviderStatus(); } else if (preference == mKeepScreenOn) { Settings.Global.putInt(getActivity().getContentResolver(), Settings.Global.STAY_ON_WHILE_PLUGGED_IN, diff --git a/src/com/android/settings/development/BugReportInPowerPreferenceController.java b/src/com/android/settings/development/BugReportInPowerPreferenceController.java new file mode 100644 index 00000000000..47b2d0d1be6 --- /dev/null +++ b/src/com/android/settings/development/BugReportInPowerPreferenceController.java @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2016 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; + +import android.content.ComponentName; +import android.content.Context; +import android.content.pm.PackageManager; +import android.os.UserManager; +import android.provider.Settings; +import android.support.v14.preference.SwitchPreference; +import android.support.v7.preference.Preference; +import android.support.v7.preference.PreferenceScreen; + +import com.android.settings.core.PreferenceController; + +public class BugReportInPowerPreferenceController extends PreferenceController { + + private static final String KEY_BUGREPORT_IN_POWER = "bugreport_in_power"; + + private UserManager mUserManager; + private SwitchPreference mPreference; + + public BugReportInPowerPreferenceController(Context context) { + super(context); + mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE); + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + if (KEY_BUGREPORT_IN_POWER.equals(preference.getKey())) { + final SwitchPreference switchPreference = (SwitchPreference) preference; + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Global.BUGREPORT_IN_POWER_MENU, + switchPreference.isChecked() ? 1 : 0); + setBugreportStorageProviderStatus(); + return true; + } + return false; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + if (isAvailable()) { + mPreference = (SwitchPreference) screen.findPreference(KEY_BUGREPORT_IN_POWER); + } + } + + @Override + public String getPreferenceKey() { + return KEY_BUGREPORT_IN_POWER; + } + + @Override + public boolean isAvailable() { + return !mUserManager.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES); + } + + @Override + public void updateState(Preference preference) { + updatePreference(); + } + + public void enablePreference(boolean enabled) { + if (isAvailable()) { + mPreference.setEnabled(enabled); + } + } + + public void resetPreference() { + if (mPreference.isChecked()) { + mPreference.setChecked(false); + handlePreferenceTreeClick(mPreference); + } + } + + public boolean updatePreference() { + if (!isAvailable()) { + return false; + } + final boolean enabled = Settings.Secure.getInt( + mContext.getContentResolver(), Settings.Global.BUGREPORT_IN_POWER_MENU, 0) != 0; + mPreference.setChecked(enabled); + return enabled; + } + + public void updateBugreportOptions() { + if (!isAvailable()) { + return; + } + mPreference.setEnabled(true); + setBugreportStorageProviderStatus(); + } + + private void setBugreportStorageProviderStatus() { + final ComponentName componentName = new ComponentName("com.android.shell", + "com.android.shell.BugreportStorageProvider"); + final boolean enabled = mPreference.isChecked(); + mContext.getPackageManager().setComponentEnabledSetting(componentName, + enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED + : PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, + 0); + } + +} diff --git a/src/com/android/settings/development/BugReportPreferenceController.java b/src/com/android/settings/development/BugReportPreferenceController.java new file mode 100644 index 00000000000..371fb7342dd --- /dev/null +++ b/src/com/android/settings/development/BugReportPreferenceController.java @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2016 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; + +import android.content.Context; +import android.os.UserManager; +import android.support.v7.preference.Preference; +import android.support.v7.preference.PreferenceScreen; + +import com.android.settings.core.PreferenceController; + +public class BugReportPreferenceController extends PreferenceController { + + private static final String KEY_BUGREPORT = "bugreport"; + + private UserManager mUserManager; + private Preference mPreference; + + public BugReportPreferenceController(Context context) { + super(context); + mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE); + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + if (isAvailable()) { + mPreference = screen.findPreference(KEY_BUGREPORT); + } + } + + @Override + public String getPreferenceKey() { + return KEY_BUGREPORT; + } + + @Override + public boolean isAvailable() { + return !mUserManager.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES); + } + + public void enablePreference(boolean enabled) { + if (isAvailable()) { + mPreference.setEnabled(enabled); + } + } + +} diff --git a/tests/robotests/src/com/android/settings/development/BugReportInPowerPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/BugReportInPowerPreferenceControllerTest.java new file mode 100644 index 00000000000..4ca6609def7 --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/BugReportInPowerPreferenceControllerTest.java @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2016 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; + +import android.content.ComponentName; +import android.content.Context; +import android.content.pm.PackageManager; +import android.provider.Settings; +import android.os.UserManager; +import android.support.v14.preference.SwitchPreference; +import android.support.v7.preference.Preference; +import android.support.v7.preference.PreferenceScreen; + +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Answers.RETURNS_DEEP_STUBS; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyBoolean; +import static org.mockito.Matchers.anyInt; +import static org.mockito.Matchers.anyString; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doCallRealMethod; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class BugReportInPowerPreferenceControllerTest { + + @Mock(answer = RETURNS_DEEP_STUBS) + private PreferenceScreen mScreen; + @Mock + private UserManager mUserManager; + @Mock + private PackageManager mPackageManager; + + private Context mContext; + private SwitchPreference mPreference; + private BugReportInPowerPreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + ShadowApplication shadowContext = ShadowApplication.getInstance(); + shadowContext.setSystemService(Context.USER_SERVICE, mUserManager); + mContext = spy(shadowContext.getApplicationContext()); + when(mContext.getPackageManager()).thenReturn(mPackageManager); + mPreference = new SwitchPreference(mContext); + when(mScreen.findPreference(anyString())).thenReturn(mPreference); + mController = new BugReportInPowerPreferenceController(mContext); + mPreference.setKey(mController.getPreferenceKey()); + } + + @Test + public void displayPreference_hasDebugRestriction_shouldRemovePreference() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(true); + + mController.displayPreference(mScreen); + + verify(mScreen).removePreference(any(Preference.class)); + } + + @Test + public void displayPreference_noDebugRestriction_shouldNotRemovePreference() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + + mController.displayPreference(mScreen); + + verify(mScreen, never()).removePreference(any(Preference.class)); + } + + @Test + public void enablePreference_hasDebugRestriction_shouldNotEnable() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(true); + mController.displayPreference(mScreen); + mPreference.setEnabled(false); + + mController.enablePreference(true); + + assertThat(mPreference.isEnabled()).isFalse(); + } + + @Test + public void enablePreference_noDebugRestriction_shouldEnable() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + mController.displayPreference(mScreen); + mPreference.setEnabled(false); + + mController.enablePreference(true); + + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void resetPreference_shouldUncheck() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + mController.displayPreference(mScreen); + mPreference.setChecked(true); + + mController.resetPreference(); + + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void handlePreferenceTreeClick_shouldUpdateSettings() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Global.BUGREPORT_IN_POWER_MENU, 0); + mPreference.setChecked(true); + mController.displayPreference(mScreen); + + mController.handlePreferenceTreeClick(mPreference); + + assertThat(Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Global.BUGREPORT_IN_POWER_MENU, 0)).isEqualTo(1); + } + + @Test + public void updateState_settingsOn_shouldCheck() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Global.BUGREPORT_IN_POWER_MENU, 1); + mPreference.setChecked(false); + mController.displayPreference(mScreen); + + mController.updateState(mPreference); + + assertThat(mPreference.isChecked()).isTrue(); + } + + @Test + public void updateState_settingsOff_shouldUncheck() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Global.BUGREPORT_IN_POWER_MENU, 0); + mPreference.setChecked(true); + mController.displayPreference(mScreen); + + mController.updateState(mPreference); + + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void updateBugreportOptions_shouldEnable() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + mPreference.setEnabled(false); + mController.displayPreference(mScreen); + + mController.updateBugreportOptions(); + + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void updateBugreportOptions_shouldEnableBugReportStorage() { + final ComponentName componentName = new ComponentName("com.android.shell", + "com.android.shell.BugreportStorageProvider"); + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + mController.displayPreference(mScreen); + + mController.updateBugreportOptions(); + + verify(mPackageManager).setComponentEnabledSetting(eq(componentName), anyInt(), anyInt()); + } +} diff --git a/tests/robotests/src/com/android/settings/development/BugReportPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/BugReportPreferenceControllerTest.java new file mode 100644 index 00000000000..377b4670d58 --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/BugReportPreferenceControllerTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2016 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; + +import android.content.Context; +import android.os.UserManager; +import android.support.v7.preference.Preference; +import android.support.v7.preference.PreferenceScreen; + +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settingslib.drawer.CategoryKey; + +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.annotation.Config; + +import static org.mockito.Answers.RETURNS_DEEP_STUBS; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyBoolean; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class BugReportPreferenceControllerTest { + + @Mock + private Context mContext; + @Mock + private Preference mPreference; + @Mock(answer = RETURNS_DEEP_STUBS) + private PreferenceScreen mScreen; + @Mock + private UserManager mUserManager; + + private BugReportPreferenceController mController; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager); + when(mScreen.findPreference(anyString())).thenReturn(mPreference); + mController = new BugReportPreferenceController(mContext); + } + + @Test + public void displayPreference_hasDebugRestriction_shouldRemovePreference() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(true); + + mController.displayPreference(mScreen); + + verify(mScreen).removePreference(any(Preference.class)); + } + + @Test + public void displayPreference_noDebugRestriction_shouldNotRemovePreference() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + + mController.displayPreference(mScreen); + + verify(mScreen, never()).removePreference(any(Preference.class)); + } + + @Test + public void enablePreference_hasDebugRestriction_shouldNotEnable() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(true); + mController.displayPreference(mScreen); + + mController.enablePreference(true); + + verify(mPreference, never()).setEnabled(anyBoolean()); + } + + @Test + public void enablePreference_noDebugRestriction_shouldEnable() { + when(mUserManager.hasUserRestriction(anyString())).thenReturn(false); + mController.displayPreference(mScreen); + + mController.enablePreference(true); + + verify(mPreference).setEnabled(anyBoolean()); + } + +}