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

Add check for DISALLOW_DEBUGGING_FEATURES restriction

Browse Source 
- 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
This commit is contained in:
Doris Ling
2016-12-07 13:21:20 -08:00
parent fb8d1bf427
commit cc20600102
5 changed files with 499 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/com/android/settings/DevelopmentSettings.java
View File

@@ -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,

119
src/com/android/settings/development/BugReportInPowerPreferenceController.java Normal file
View File

@@ -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);
}
}

62
src/com/android/settings/development/BugReportPreferenceController.java Normal file
View File

@@ -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);
}
}
}

193
tests/robotests/src/com/android/settings/development/BugReportInPowerPreferenceControllerTest.java Normal file
View File

@@ -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());
}
}

106
tests/robotests/src/com/android/settings/development/BugReportPreferenceControllerTest.java Normal file
View File

@@ -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());
}
}