Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cc206001 authored by Doris Ling's avatar Doris Ling
Browse files

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
parent fb8d1bf4

src/com/android/settings/DevelopmentSettings.java

+19 −26
Original line number Diff line number Diff line
@@ -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,

src/com/android/settings/development/BugReportInPowerPreferenceController.java

0 → 100644
+119 −0
Original line number Diff line number Diff line 
/*

 * 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);

    }



}

src/com/android/settings/development/BugReportPreferenceController.java

0 → 100644
+62 −0
Original line number Diff line number Diff line 
/*

 * 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);

        }

    }



}

tests/robotests/src/com/android/settings/development/BugReportInPowerPreferenceControllerTest.java

0 → 100644
+193 −0
Original line number Diff line number Diff line 
/*

 * 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());

    }

}

tests/robotests/src/com/android/settings/development/BugReportPreferenceControllerTest.java

0 → 100644
+106 −0
Original line number Diff line number Diff line 
/*

 * 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());

    }



}