package com.android.settings;
+import android.Manifest;
import android.app.Activity;
import android.app.ActivityManagerNative;
import android.app.AlertDialog;
+import android.app.AppOpsManager;
+import android.app.AppOpsManager.PackageOps;
import android.app.Dialog;
import android.app.admin.DevicePolicyManager;
import android.app.backup.IBackupManager;
import android.bluetooth.BluetoothAdapter;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
+import android.content.IntentFilter;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
+import android.content.res.Resources;
import android.hardware.usb.IUsbManager;
+import android.hardware.usb.UsbManager;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.os.BatteryManager;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.os.UserManager;
-import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.PreferenceGroup;
import android.preference.PreferenceScreen;
+import android.preference.SwitchPreference;
import android.provider.SearchIndexableResource;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Log;
import android.view.HardwareRenderer;
import android.view.IWindowManager;
+import android.view.LayoutInflater;
import android.view.View;
+import android.view.ViewGroup;
import android.view.accessibility.AccessibilityManager;
import android.widget.Switch;
import android.widget.TextView;
+import com.android.internal.logging.MetricsLogger;
+import com.android.settings.fuelgauge.InactiveApps;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.search.Indexable;
import com.android.settings.widget.SwitchBar;
-import dalvik.system.VMRuntime;
import java.util.ArrayList;
import java.util.Arrays;
private static final String KEEP_SCREEN_ON = "keep_screen_on";
private static final String BT_HCI_SNOOP_LOG = "bt_hci_snoop_log";
private static final String ENABLE_OEM_UNLOCK = "oem_unlock_enable";
- private static final String ALLOW_MOCK_LOCATION = "allow_mock_location";
private static final String HDCP_CHECKING_KEY = "hdcp_checking";
private static final String HDCP_CHECKING_PROPERTY = "persist.sys.hdcp_checking";
private static final String LOCAL_BACKUP_PASSWORD = "local_backup_password";
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 DEBUG_APP_KEY = "debug_app";
private static final String WAIT_FOR_DEBUGGER_KEY = "wait_for_debugger";
+ private static final String MOCK_LOCATION_APP_KEY = "mock_location_app";
private static final String VERIFY_APPS_OVER_USB_KEY = "verify_apps_over_usb";
private static final String DEBUG_VIEW_ATTRIBUTES = "debug_view_attributes";
private static final String STRICT_MODE_KEY = "strict_mode";
private static final String SHOW_SCREEN_UPDATES_KEY = "show_screen_updates";
private static final String DISABLE_OVERLAYS_KEY = "disable_overlays";
private static final String SIMULATE_COLOR_SPACE = "simulate_color_space";
- private static final String USE_NUPLAYER_KEY = "use_nuplayer";
private static final String USB_AUDIO_KEY = "usb_audio";
- private static final String USE_AWESOMEPLAYER_PROPERTY = "persist.sys.media.use-awesome";
private static final String SHOW_CPU_USAGE_KEY = "show_cpu_usage";
private static final String FORCE_HARDWARE_UI_KEY = "force_hw_ui";
private static final String FORCE_MSAA_KEY = "force_msaa";
private static final String TRANSITION_ANIMATION_SCALE_KEY = "transition_animation_scale";
private static final String ANIMATOR_DURATION_SCALE_KEY = "animator_duration_scale";
private static final String OVERLAY_DISPLAY_DEVICES_KEY = "overlay_display_devices";
+ private static final String ENABLE_MULTI_WINDOW_KEY = "enable_multi_window";
private static final String DEBUG_DEBUGGING_CATEGORY_KEY = "debug_debugging_category";
- private static final String DEBUG_APPLICATIONS_CATEGORY_KEY = "debug_applications_category";
+ private static final String SELECT_LOGD_SIZE_KEY = "select_logd_size";
+ private static final String SELECT_LOGD_SIZE_PROPERTY = "persist.logd.size";
+ private static final String SELECT_LOGD_DEFAULT_SIZE_PROPERTY = "ro.logd.size";
+
private static final String WIFI_DISPLAY_CERTIFICATION_KEY = "wifi_display_certification";
private static final String WIFI_VERBOSE_LOGGING_KEY = "wifi_verbose_logging";
private static final String WIFI_AGGRESSIVE_HANDOVER_KEY = "wifi_aggressive_handover";
private static final String WIFI_ALLOW_SCAN_WITH_TRAFFIC_KEY = "wifi_allow_scan_with_traffic";
- private static final String SELECT_LOGD_SIZE_KEY = "select_logd_size";
- private static final String SELECT_LOGD_SIZE_PROPERTY = "persist.logd.size";
- private static final String SELECT_LOGD_DEFAULT_SIZE_PROPERTY = "ro.logd.size";
+ private static final String USB_CONFIGURATION_KEY = "select_usb_configuration";
+ private static final String WIFI_LEGACY_DHCP_CLIENT_KEY = "legacy_dhcp_client";
+ private static final String MOBILE_DATA_ALWAYS_ON = "mobile_data_always_on";
+ private static final String KEY_COLOR_MODE = "color_mode";
+
+ private static final String INACTIVE_APPS_KEY = "inactive_apps";
private static final String OPENGL_TRACES_KEY = "enable_opengl_traces";
+ private static final String ROOT_ACCESS_KEY = "root_access";
+ private static final String ROOT_ACCESS_PROPERTY = "persist.sys.root_access";
+
private static final String IMMEDIATELY_DESTROY_ACTIVITIES_KEY
= "immediately_destroy_activities";
private static final String APP_PROCESS_LIMIT_KEY = "app_process_limit";
private static final String SHOW_ALL_ANRS_KEY = "show_all_anrs";
- private static final String PROCESS_STATS = "proc_stats";
-
- private static final String TAG_CONFIRM_ENFORCE = "confirm_enforce";
-
private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive";
private static final String TERMINAL_APP_PACKAGE = "com.android.terminal";
private static final int RESULT_DEBUG_APP = 1000;
+ private static final int RESULT_MOCK_LOCATION_APP = 1001;
private static final String PERSISTENT_DATA_BLOCK_PROP = "ro.frp.pst";
+ private static final int REQUEST_CODE_ENABLE_OEM_UNLOCK = 0;
+
private static String DEFAULT_LOG_RING_BUFFER_SIZE_IN_BYTES = "262144"; // 256K
+ private static final int[] MOCK_LOCATION_APP_OPS = new int[] {AppOpsManager.OP_MOCK_LOCATION};
+
+ private static final String MULTI_WINDOW_SYSTEM_PROPERTY = "persist.sys.debug.multi_window";
private IWindowManager mWindowManager;
private IBackupManager mBackupManager;
private DevicePolicyManager mDpm;
private boolean mHaveDebugSettings;
private boolean mDontPokeProperties;
- private CheckBoxPreference mEnableAdb;
+ private SwitchPreference mEnableAdb;
private Preference mClearAdbKeys;
- private CheckBoxPreference mEnableTerminal;
+ private SwitchPreference mEnableTerminal;
private Preference mBugreport;
- private CheckBoxPreference mBugreportInPower;
- private CheckBoxPreference mKeepScreenOn;
- private CheckBoxPreference mBtHciSnoopLog;
- private CheckBoxPreference mEnableOemUnlock;
- private CheckBoxPreference mAllowMockLocation;
- private CheckBoxPreference mDebugViewAttributes;
+ private SwitchPreference mBugreportInPower;
+ private SwitchPreference mKeepScreenOn;
+ private SwitchPreference mBtHciSnoopLog;
+ private SwitchPreference mEnableOemUnlock;
+ private SwitchPreference mDebugViewAttributes;
private PreferenceScreen mPassword;
private String mDebugApp;
private Preference mDebugAppPref;
- private CheckBoxPreference mWaitForDebugger;
- private CheckBoxPreference mVerifyAppsOverUsb;
- private CheckBoxPreference mWifiDisplayCertification;
- private CheckBoxPreference mWifiVerboseLogging;
- private CheckBoxPreference mWifiAggressiveHandover;
-
- private CheckBoxPreference mWifiAllowScansWithTraffic;
- private CheckBoxPreference mStrictMode;
- private CheckBoxPreference mPointerLocation;
- private CheckBoxPreference mShowTouches;
- private CheckBoxPreference mShowScreenUpdates;
- private CheckBoxPreference mDisableOverlays;
- private CheckBoxPreference mShowCpuUsage;
- private CheckBoxPreference mForceHardwareUi;
- private CheckBoxPreference mForceMsaa;
- private CheckBoxPreference mShowHwScreenUpdates;
- private CheckBoxPreference mShowHwLayersUpdates;
- private CheckBoxPreference mDebugLayout;
- private CheckBoxPreference mForceRtlLayout;
+
+ private String mMockLocationApp;
+ private Preference mMockLocationAppPref;
+
+ private SwitchPreference mWaitForDebugger;
+ private SwitchPreference mVerifyAppsOverUsb;
+ private SwitchPreference mWifiDisplayCertification;
+ private SwitchPreference mWifiVerboseLogging;
+ private SwitchPreference mWifiAggressiveHandover;
+ private SwitchPreference mLegacyDhcpClient;
+ private SwitchPreference mMobileDataAlwaysOn;
+
+ private SwitchPreference mWifiAllowScansWithTraffic;
+ private SwitchPreference mStrictMode;
+ private SwitchPreference mPointerLocation;
+ private SwitchPreference mShowTouches;
+ private SwitchPreference mShowScreenUpdates;
+ private SwitchPreference mDisableOverlays;
+ private SwitchPreference mEnableMultiWindow;
+ private SwitchPreference mShowCpuUsage;
+ private SwitchPreference mForceHardwareUi;
+ private SwitchPreference mForceMsaa;
+ private SwitchPreference mShowHwScreenUpdates;
+ private SwitchPreference mShowHwLayersUpdates;
+ private SwitchPreference mDebugLayout;
+ private SwitchPreference mForceRtlLayout;
private ListPreference mDebugHwOverdraw;
private ListPreference mLogdSize;
+ private ListPreference mUsbConfiguration;
private ListPreference mTrackFrameTime;
private ListPreference mShowNonRectClip;
private ListPreference mWindowAnimationScale;
private ListPreference mSimulateColorSpace;
- private CheckBoxPreference mUseNuplayer;
- private CheckBoxPreference mUSBAudio;
- private CheckBoxPreference mImmediatelyDestroyActivities;
+ private SwitchPreference mUSBAudio;
+ private SwitchPreference mImmediatelyDestroyActivities;
private ListPreference mAppProcessLimit;
- private CheckBoxPreference mShowAllANRs;
+ private SwitchPreference mShowAllANRs;
+
+ private ColorModePreference mColorModePreference;
private PreferenceScreen mProcessStats;
+ private ListPreference mRootAccess;
+ private Object mSelectedRootValue;
+
private final ArrayList<Preference> mAllPrefs = new ArrayList<Preference>();
- private final ArrayList<CheckBoxPreference> mResetCbPrefs
- = new ArrayList<CheckBoxPreference>();
+ private final ArrayList<SwitchPreference> mResetSwitchPrefs
+ = new ArrayList<SwitchPreference>();
private final HashSet<Preference> mDisabledPrefs = new HashSet<Preference>();
// To track whether a confirmation dialog was clicked.
private Dialog mAdbKeysDialog;
private boolean mUnavailable;
+ private Dialog mRootDialog;
+
+ @Override
+ protected int getMetricsCategory() {
+ return MetricsLogger.DEVELOPMENT;
+ }
@Override
public void onCreate(Bundle icicle) {
mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
if (android.os.Process.myUserHandle().getIdentifier() != UserHandle.USER_OWNER
- || mUm.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES)) {
+ || mUm.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES)
+ || Settings.Global.getInt(getActivity().getContentResolver(),
+ Settings.Global.DEVICE_PROVISIONED, 0) == 0) {
+ // Block access to developer options if the user is not the owner, if user policy
+ // restricts it, or if the device has not been provisioned
mUnavailable = true;
setPreferenceScreen(new PreferenceScreen(getActivity(), null));
return;
final PreferenceGroup debugDebuggingCategory = (PreferenceGroup)
findPreference(DEBUG_DEBUGGING_CATEGORY_KEY);
-
- mEnableAdb = findAndInitCheckboxPref(ENABLE_ADB);
+ mEnableAdb = findAndInitSwitchPref(ENABLE_ADB);
mClearAdbKeys = findPreference(CLEAR_ADB_KEYS);
if (!SystemProperties.getBoolean("ro.adb.secure", false)) {
if (debugDebuggingCategory != null) {
}
}
mAllPrefs.add(mClearAdbKeys);
- mEnableTerminal = findAndInitCheckboxPref(ENABLE_TERMINAL);
+ mEnableTerminal = findAndInitSwitchPref(ENABLE_TERMINAL);
if (!isPackageInstalled(getActivity(), TERMINAL_APP_PACKAGE)) {
debugDebuggingCategory.removePreference(mEnableTerminal);
mEnableTerminal = null;
}
mBugreport = findPreference(BUGREPORT);
- mBugreportInPower = findAndInitCheckboxPref(BUGREPORT_IN_POWER_KEY);
- mKeepScreenOn = findAndInitCheckboxPref(KEEP_SCREEN_ON);
- mBtHciSnoopLog = findAndInitCheckboxPref(BT_HCI_SNOOP_LOG);
- mEnableOemUnlock = findAndInitCheckboxPref(ENABLE_OEM_UNLOCK);
+ mBugreportInPower = findAndInitSwitchPref(BUGREPORT_IN_POWER_KEY);
+ mKeepScreenOn = findAndInitSwitchPref(KEEP_SCREEN_ON);
+ mBtHciSnoopLog = findAndInitSwitchPref(BT_HCI_SNOOP_LOG);
+ mEnableOemUnlock = findAndInitSwitchPref(ENABLE_OEM_UNLOCK);
if (!showEnableOemUnlockPreference()) {
removePreference(mEnableOemUnlock);
mEnableOemUnlock = null;
}
- mAllowMockLocation = findAndInitCheckboxPref(ALLOW_MOCK_LOCATION);
- mDebugViewAttributes = findAndInitCheckboxPref(DEBUG_VIEW_ATTRIBUTES);
+
+ mDebugViewAttributes = findAndInitSwitchPref(DEBUG_VIEW_ATTRIBUTES);
mPassword = (PreferenceScreen) findPreference(LOCAL_BACKUP_PASSWORD);
mAllPrefs.add(mPassword);
mDebugAppPref = findPreference(DEBUG_APP_KEY);
mAllPrefs.add(mDebugAppPref);
- mWaitForDebugger = findAndInitCheckboxPref(WAIT_FOR_DEBUGGER_KEY);
- mVerifyAppsOverUsb = findAndInitCheckboxPref(VERIFY_APPS_OVER_USB_KEY);
+ mWaitForDebugger = findAndInitSwitchPref(WAIT_FOR_DEBUGGER_KEY);
+
+ mMockLocationAppPref = findPreference(MOCK_LOCATION_APP_KEY);
+ mAllPrefs.add(mMockLocationAppPref);
+
+ mVerifyAppsOverUsb = findAndInitSwitchPref(VERIFY_APPS_OVER_USB_KEY);
if (!showVerifierSetting()) {
if (debugDebuggingCategory != null) {
debugDebuggingCategory.removePreference(mVerifyAppsOverUsb);
mVerifyAppsOverUsb.setEnabled(false);
}
}
- mStrictMode = findAndInitCheckboxPref(STRICT_MODE_KEY);
- mPointerLocation = findAndInitCheckboxPref(POINTER_LOCATION_KEY);
- mShowTouches = findAndInitCheckboxPref(SHOW_TOUCHES_KEY);
- mShowScreenUpdates = findAndInitCheckboxPref(SHOW_SCREEN_UPDATES_KEY);
- mDisableOverlays = findAndInitCheckboxPref(DISABLE_OVERLAYS_KEY);
- mShowCpuUsage = findAndInitCheckboxPref(SHOW_CPU_USAGE_KEY);
- mForceHardwareUi = findAndInitCheckboxPref(FORCE_HARDWARE_UI_KEY);
- mForceMsaa = findAndInitCheckboxPref(FORCE_MSAA_KEY);
+ mStrictMode = findAndInitSwitchPref(STRICT_MODE_KEY);
+ mPointerLocation = findAndInitSwitchPref(POINTER_LOCATION_KEY);
+ mShowTouches = findAndInitSwitchPref(SHOW_TOUCHES_KEY);
+ mShowScreenUpdates = findAndInitSwitchPref(SHOW_SCREEN_UPDATES_KEY);
+ mDisableOverlays = findAndInitSwitchPref(DISABLE_OVERLAYS_KEY);
+ mShowCpuUsage = findAndInitSwitchPref(SHOW_CPU_USAGE_KEY);
+ mForceHardwareUi = findAndInitSwitchPref(FORCE_HARDWARE_UI_KEY);
+ mForceMsaa = findAndInitSwitchPref(FORCE_MSAA_KEY);
mTrackFrameTime = addListPreference(TRACK_FRAME_TIME_KEY);
mShowNonRectClip = addListPreference(SHOW_NON_RECTANGULAR_CLIP_KEY);
- mShowHwScreenUpdates = findAndInitCheckboxPref(SHOW_HW_SCREEN_UPDATES_KEY);
- mShowHwLayersUpdates = findAndInitCheckboxPref(SHOW_HW_LAYERS_UPDATES_KEY);
- mDebugLayout = findAndInitCheckboxPref(DEBUG_LAYOUT_KEY);
- mForceRtlLayout = findAndInitCheckboxPref(FORCE_RTL_LAYOUT_KEY);
+ mShowHwScreenUpdates = findAndInitSwitchPref(SHOW_HW_SCREEN_UPDATES_KEY);
+ mShowHwLayersUpdates = findAndInitSwitchPref(SHOW_HW_LAYERS_UPDATES_KEY);
+ mDebugLayout = findAndInitSwitchPref(DEBUG_LAYOUT_KEY);
+ mForceRtlLayout = findAndInitSwitchPref(FORCE_RTL_LAYOUT_KEY);
mDebugHwOverdraw = addListPreference(DEBUG_HW_OVERDRAW_KEY);
- mWifiDisplayCertification = findAndInitCheckboxPref(WIFI_DISPLAY_CERTIFICATION_KEY);
- mWifiVerboseLogging = findAndInitCheckboxPref(WIFI_VERBOSE_LOGGING_KEY);
- mWifiAggressiveHandover = findAndInitCheckboxPref(WIFI_AGGRESSIVE_HANDOVER_KEY);
- mWifiAllowScansWithTraffic = findAndInitCheckboxPref(WIFI_ALLOW_SCAN_WITH_TRAFFIC_KEY);
+ mWifiDisplayCertification = findAndInitSwitchPref(WIFI_DISPLAY_CERTIFICATION_KEY);
+ mWifiVerboseLogging = findAndInitSwitchPref(WIFI_VERBOSE_LOGGING_KEY);
+ mWifiAggressiveHandover = findAndInitSwitchPref(WIFI_AGGRESSIVE_HANDOVER_KEY);
+ mWifiAllowScansWithTraffic = findAndInitSwitchPref(WIFI_ALLOW_SCAN_WITH_TRAFFIC_KEY);
+ mLegacyDhcpClient = findAndInitSwitchPref(WIFI_LEGACY_DHCP_CLIENT_KEY);
+ mMobileDataAlwaysOn = findAndInitSwitchPref(MOBILE_DATA_ALWAYS_ON);
mLogdSize = addListPreference(SELECT_LOGD_SIZE_KEY);
+ mUsbConfiguration = addListPreference(USB_CONFIGURATION_KEY);
mWindowAnimationScale = addListPreference(WINDOW_ANIMATION_SCALE_KEY);
mTransitionAnimationScale = addListPreference(TRANSITION_ANIMATION_SCALE_KEY);
mAnimatorDurationScale = addListPreference(ANIMATOR_DURATION_SCALE_KEY);
mOverlayDisplayDevices = addListPreference(OVERLAY_DISPLAY_DEVICES_KEY);
+ mEnableMultiWindow = findAndInitSwitchPref(ENABLE_MULTI_WINDOW_KEY);
+ if (!showEnableMultiWindowPreference()) {
+ final PreferenceGroup drawingGroup =
+ (PreferenceGroup)findPreference("debug_drawing_category");
+ if (drawingGroup != null) {
+ drawingGroup.removePreference(mEnableMultiWindow);
+ } else {
+ mEnableMultiWindow.setEnabled(false);
+ }
+ removePreference(mEnableMultiWindow);
+ mEnableMultiWindow = null;
+ }
mOpenGLTraces = addListPreference(OPENGL_TRACES_KEY);
mSimulateColorSpace = addListPreference(SIMULATE_COLOR_SPACE);
- mUseNuplayer = findAndInitCheckboxPref(USE_NUPLAYER_KEY);
- mUSBAudio = findAndInitCheckboxPref(USB_AUDIO_KEY);
+ mUSBAudio = findAndInitSwitchPref(USB_AUDIO_KEY);
- mImmediatelyDestroyActivities = (CheckBoxPreference) findPreference(
+ mImmediatelyDestroyActivities = (SwitchPreference) findPreference(
IMMEDIATELY_DESTROY_ACTIVITIES_KEY);
mAllPrefs.add(mImmediatelyDestroyActivities);
- mResetCbPrefs.add(mImmediatelyDestroyActivities);
+ mResetSwitchPrefs.add(mImmediatelyDestroyActivities);
mAppProcessLimit = addListPreference(APP_PROCESS_LIMIT_KEY);
- mShowAllANRs = (CheckBoxPreference) findPreference(
+ mShowAllANRs = (SwitchPreference) findPreference(
SHOW_ALL_ANRS_KEY);
mAllPrefs.add(mShowAllANRs);
- mResetCbPrefs.add(mShowAllANRs);
+ mResetSwitchPrefs.add(mShowAllANRs);
Preference hdcpChecking = findPreference(HDCP_CHECKING_KEY);
if (hdcpChecking != null) {
removePreferenceForProduction(hdcpChecking);
}
- mProcessStats = (PreferenceScreen) findPreference(PROCESS_STATS);
- mAllPrefs.add(mProcessStats);
+ mColorModePreference = (ColorModePreference) findPreference(KEY_COLOR_MODE);
+ mColorModePreference.updateCurrentAndSupported();
+ if (mColorModePreference.getTransformsCount() < 2) {
+ removePreference(KEY_COLOR_MODE);
+ mColorModePreference = null;
+ }
+
+ mRootAccess = (ListPreference) findPreference(ROOT_ACCESS_KEY);
+ mRootAccess.setOnPreferenceChangeListener(this);
+ if (!removeRootOptionsIfRequired()) {
+ mAllPrefs.add(mRootAccess);
+ }
}
private ListPreference addListPreference(String prefKey) {
}
}
- private CheckBoxPreference findAndInitCheckboxPref(String key) {
- CheckBoxPreference pref = (CheckBoxPreference) findPreference(key);
+ private SwitchPreference findAndInitSwitchPref(String key) {
+ SwitchPreference pref = (SwitchPreference) findPreference(key);
if (pref == null) {
throw new IllegalArgumentException("Cannot find preference with key = " + key);
}
mAllPrefs.add(pref);
- mResetCbPrefs.add(pref);
+ mResetSwitchPrefs.add(pref);
return pref;
}
+ private boolean removeRootOptionsIfRequired() {
+ // user builds don't get root, and eng always gets root
+ if (!(Build.IS_DEBUGGABLE || "eng".equals(Build.TYPE))) {
+ if (mRootAccess != null) {
+ getPreferenceScreen().removePreference(mRootAccess);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
private void removePreference(Preference preference) {
getPreferenceScreen().removePreference(preference);
mAllPrefs.remove(preference);
+ mResetSwitchPrefs.remove(preference);
}
private void setPrefsEnabledState(boolean enabled) {
setPrefsEnabledState(mLastEnabledState);
}
mSwitchBar.show();
+
+ if (mColorModePreference != null) {
+ mColorModePreference.startListening();
+ mColorModePreference.updateCurrentAndSupported();
+ }
+ }
+
+ @Override
+ public void onPause() {
+ super.onPause();
+ if (mColorModePreference != null) {
+ mColorModePreference.stopListening();
+ }
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container,
+ Bundle savedInstanceState) {
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(UsbManager.ACTION_USB_STATE);
+ getActivity().registerReceiver(mUsbReceiver, filter);
+ return super.onCreateView(inflater, container, savedInstanceState);
}
@Override
}
mSwitchBar.removeOnSwitchChangeListener(this);
mSwitchBar.hide();
+ getActivity().unregisterReceiver(mUsbReceiver);
}
- void updateCheckBox(CheckBoxPreference checkBox, boolean value) {
- checkBox.setChecked(value);
+ void updateSwitchPreference(SwitchPreference switchPreference, boolean value) {
+ switchPreference.setChecked(value);
mHaveDebugSettings |= value;
}
final Context context = getActivity();
final ContentResolver cr = context.getContentResolver();
mHaveDebugSettings = false;
- updateCheckBox(mEnableAdb, Settings.Global.getInt(cr,
+ updateSwitchPreference(mEnableAdb, Settings.Global.getInt(cr,
Settings.Global.ADB_ENABLED, 0) != 0);
if (mEnableTerminal != null) {
- updateCheckBox(mEnableTerminal,
+ updateSwitchPreference(mEnableTerminal,
context.getPackageManager().getApplicationEnabledSetting(TERMINAL_APP_PACKAGE)
- == PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
+ == PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
}
- updateCheckBox(mBugreportInPower, Settings.Secure.getInt(cr,
+ updateSwitchPreference(mBugreportInPower, Settings.Secure.getInt(cr,
Settings.Secure.BUGREPORT_IN_POWER_MENU, 0) != 0);
- updateCheckBox(mKeepScreenOn, Settings.Global.getInt(cr,
+ updateSwitchPreference(mKeepScreenOn, Settings.Global.getInt(cr,
Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0) != 0);
- updateCheckBox(mBtHciSnoopLog, Settings.Secure.getInt(cr,
+ updateSwitchPreference(mBtHciSnoopLog, Settings.Secure.getInt(cr,
Settings.Secure.BLUETOOTH_HCI_LOG, 0) != 0);
if (mEnableOemUnlock != null) {
- updateCheckBox(mEnableOemUnlock, Utils.isOemUnlockEnabled(getActivity()));
+ updateSwitchPreference(mEnableOemUnlock, Utils.isOemUnlockEnabled(getActivity()));
}
- updateCheckBox(mAllowMockLocation, Settings.Secure.getInt(cr,
- Settings.Secure.ALLOW_MOCK_LOCATION, 0) != 0);
- updateCheckBox(mDebugViewAttributes, Settings.Global.getInt(cr,
+ updateSwitchPreference(mDebugViewAttributes, Settings.Global.getInt(cr,
Settings.Global.DEBUG_VIEW_ATTRIBUTES, 0) != 0);
updateHdcpValues();
updatePasswordSummary();
updateDebuggerOptions();
+ updateMockLocation();
updateStrictModeVisualOptions();
updatePointerLocationOptions();
updateShowTouchesOptions();
updateDebugLayoutOptions();
updateAnimationScaleOptions();
updateOverlayDisplayDevicesOptions();
+ if (mEnableMultiWindow != null) {
+ updateSwitchPreference(mEnableMultiWindow,
+ SystemProperties.getBoolean(MULTI_WINDOW_SYSTEM_PROPERTY, false));
+ }
updateOpenGLTracesOptions();
updateImmediatelyDestroyActivitiesOptions();
updateAppProcessLimitOptions();
updateWifiVerboseLoggingOptions();
updateWifiAggressiveHandoverOptions();
updateWifiAllowScansWithTrafficOptions();
+ updateLegacyDhcpClientOptions();
+ updateMobileDataAlwaysOnOptions();
updateSimulateColorSpace();
- updateUseNuplayerOptions();
updateUSBAudioOptions();
+ updateRootAccessOptions();
}
private void resetDangerousOptions() {
mDontPokeProperties = true;
- for (int i=0; i<mResetCbPrefs.size(); i++) {
- CheckBoxPreference cb = mResetCbPrefs.get(i);
+ for (int i=0; i< mResetSwitchPrefs.size(); i++) {
+ SwitchPreference cb = mResetSwitchPrefs.get(i);
if (cb.isChecked()) {
cb.setChecked(false);
onPreferenceTreeClick(null, cb);
}
resetDebuggerOptions();
writeLogdSizeOption(null);
+ resetRootAccessOptions();
writeAnimationScaleOption(0, mWindowAnimationScale, null);
writeAnimationScaleOption(1, mTransitionAnimationScale, null);
writeAnimationScaleOption(2, mAnimatorDurationScale, null);
pokeSystemProperties();
}
+ private void updateRootAccessOptions() {
+ String value = SystemProperties.get(ROOT_ACCESS_PROPERTY, "1");
+ mRootAccess.setValue(value);
+ mRootAccess.setSummary(getResources()
+ .getStringArray(R.array.root_access_entries)[Integer.valueOf(value)]);
+ }
+
+ private void writeRootAccessOptions(Object newValue) {
+ String oldValue = SystemProperties.get(ROOT_ACCESS_PROPERTY, "1");
+ SystemProperties.set(ROOT_ACCESS_PROPERTY, newValue.toString());
+ if (Integer.valueOf(newValue.toString()) < 2 && !oldValue.equals(newValue)
+ && "1".equals(SystemProperties.get("service.adb.root", "0"))) {
+ SystemProperties.set("service.adb.root", "0");
+ Settings.Secure.putInt(getActivity().getContentResolver(),
+ Settings.Secure.ADB_ENABLED, 0);
+ Settings.Secure.putInt(getActivity().getContentResolver(),
+ Settings.Secure.ADB_ENABLED, 1);
+ }
+ updateRootAccessOptions();
+ }
+
+ private void resetRootAccessOptions() {
+ String oldValue = SystemProperties.get(ROOT_ACCESS_PROPERTY, "1");
+ SystemProperties.set(ROOT_ACCESS_PROPERTY, "1");
+ if (!oldValue.equals("1") && "1".equals(SystemProperties.get("service.adb.root", "0"))) {
+ SystemProperties.set("service.adb.root", "0");
+ Settings.Secure.putInt(getActivity().getContentResolver(),
+ Settings.Secure.ADB_ENABLED, 0);
+ Settings.Secure.putInt(getActivity().getContentResolver(),
+ Settings.Secure.ADB_ENABLED, 1);
+ }
+ updateRootAccessOptions();
+ }
+
private void updateHdcpValues() {
ListPreference hdcpChecking = (ListPreference) findPreference(HDCP_CHECKING_KEY);
if (hdcpChecking != null) {
}
}
+ private void writeMockLocation() {
+ AppOpsManager appOpsManager = (AppOpsManager) getSystemService(Context.APP_OPS_SERVICE);
+
+ // Disable the app op of the previous mock location app if such.
+ List<PackageOps> packageOps = appOpsManager.getPackagesForOps(MOCK_LOCATION_APP_OPS);
+ if (packageOps != null) {
+ // Should be one but in case we are in a bad state due to use of command line tools.
+ for (PackageOps packageOp : packageOps) {
+ if (packageOp.getOps().get(0).getMode() != AppOpsManager.MODE_ERRORED) {
+ String oldMockLocationApp = packageOp.getPackageName();
+ try {
+ ApplicationInfo ai = getActivity().getPackageManager().getApplicationInfo(
+ oldMockLocationApp, PackageManager.GET_DISABLED_COMPONENTS);
+ appOpsManager.setMode(AppOpsManager.OP_MOCK_LOCATION, ai.uid,
+ oldMockLocationApp, AppOpsManager.MODE_ERRORED);
+ } catch (NameNotFoundException e) {
+ /* ignore */
+ }
+ }
+ }
+ }
+
+ // Enable the app op of the new mock location app if such.
+ if (!TextUtils.isEmpty(mMockLocationApp)) {
+ try {
+ ApplicationInfo ai = getActivity().getPackageManager().getApplicationInfo(
+ mMockLocationApp, PackageManager.GET_DISABLED_COMPONENTS);
+ appOpsManager.setMode(AppOpsManager.OP_MOCK_LOCATION, ai.uid,
+ mMockLocationApp, AppOpsManager.MODE_ALLOWED);
+ } catch (NameNotFoundException e) {
+ /* ignore */
+ }
+ }
+ }
+
private static void resetDebuggerOptions() {
try {
ActivityManagerNative.getDefault().setDebugApp(
private void updateDebuggerOptions() {
mDebugApp = Settings.Global.getString(
getActivity().getContentResolver(), Settings.Global.DEBUG_APP);
- updateCheckBox(mWaitForDebugger, Settings.Global.getInt(
+ updateSwitchPreference(mWaitForDebugger, Settings.Global.getInt(
getActivity().getContentResolver(), Settings.Global.WAIT_FOR_DEBUGGER, 0) != 0);
if (mDebugApp != null && mDebugApp.length() > 0) {
String label;
}
}
+ private void updateMockLocation() {
+ AppOpsManager appOpsManager = (AppOpsManager) getSystemService(Context.APP_OPS_SERVICE);
+
+ List<PackageOps> packageOps = appOpsManager.getPackagesForOps(MOCK_LOCATION_APP_OPS);
+ if (packageOps != null) {
+ for (PackageOps packageOp : packageOps) {
+ if (packageOp.getOps().get(0).getMode() == AppOpsManager.MODE_ALLOWED) {
+ mMockLocationApp = packageOps.get(0).getPackageName();
+ break;
+ }
+ }
+ }
+
+ if (!TextUtils.isEmpty(mMockLocationApp)) {
+ String label = mMockLocationApp;
+ try {
+ ApplicationInfo ai = getActivity().getPackageManager().getApplicationInfo(
+ mMockLocationApp, PackageManager.GET_DISABLED_COMPONENTS);
+ CharSequence appLabel = getPackageManager().getApplicationLabel(ai);
+ if (appLabel != null) {
+ label = appLabel.toString();
+ }
+ } catch (PackageManager.NameNotFoundException e) {
+ /* ignore */
+ }
+
+ mMockLocationAppPref.setSummary(getString(R.string.mock_location_app_set, label));
+ mHaveDebugSettings = true;
+ } else {
+ mMockLocationAppPref.setSummary(getString(R.string.mock_location_app_not_set));
+ }
+ }
+
private void updateVerifyAppsOverUsbOptions() {
- updateCheckBox(mVerifyAppsOverUsb, Settings.Global.getInt(getActivity().getContentResolver(),
+ updateSwitchPreference(mVerifyAppsOverUsb, Settings.Global.getInt(getActivity().getContentResolver(),
Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1) != 0);
mVerifyAppsOverUsb.setEnabled(enableVerifierSetting());
}
return !SystemProperties.get(PERSISTENT_DATA_BLOCK_PROP).equals("");
}
+ private static boolean showEnableMultiWindowPreference() {
+ return !"user".equals(Build.TYPE);
+ }
+
+ private void setEnableMultiWindow(boolean value) {
+ SystemProperties.set(MULTI_WINDOW_SYSTEM_PROPERTY, String.valueOf(value));
+ pokeSystemProperties();
+ }
+
private void updateBugreportOptions() {
+ final ComponentName bugreportStorageProviderComponentName =
+ new ComponentName("com.android.shell",
+ "com.android.shell.BugreportStorageProvider");
if ("user".equals(Build.TYPE)) {
final ContentResolver resolver = getActivity().getContentResolver();
final boolean adbEnabled = Settings.Global.getInt(
if (adbEnabled) {
mBugreport.setEnabled(true);
mBugreportInPower.setEnabled(true);
+ getPackageManager().setComponentEnabledSetting(
+ bugreportStorageProviderComponentName,
+ PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0);
} else {
mBugreport.setEnabled(false);
mBugreportInPower.setEnabled(false);
mBugreportInPower.setChecked(false);
Settings.Secure.putInt(resolver, Settings.Secure.BUGREPORT_IN_POWER_MENU, 0);
+ getPackageManager().setComponentEnabledSetting(
+ bugreportStorageProviderComponentName,
+ PackageManager.COMPONENT_ENABLED_STATE_DEFAULT, 0);
}
} else {
mBugreportInPower.setEnabled(true);
+ getPackageManager().setComponentEnabledSetting(
+ bugreportStorageProviderComponentName,
+ PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0);
}
}
}
private void updateStrictModeVisualOptions() {
- updateCheckBox(mStrictMode, currentStrictModeActiveIndex() == 1);
+ updateSwitchPreference(mStrictMode, currentStrictModeActiveIndex() == 1);
}
private void writePointerLocationOptions() {
}
private void updatePointerLocationOptions() {
- updateCheckBox(mPointerLocation, Settings.System.getInt(getActivity().getContentResolver(),
+ updateSwitchPreference(mPointerLocation,
+ Settings.System.getInt(getActivity().getContentResolver(),
Settings.System.POINTER_LOCATION, 0) != 0);
}
}
private void updateShowTouchesOptions() {
- updateCheckBox(mShowTouches, Settings.System.getInt(getActivity().getContentResolver(),
+ updateSwitchPreference(mShowTouches,
+ Settings.System.getInt(getActivity().getContentResolver(),
Settings.System.SHOW_TOUCHES, 0) != 0);
}
@SuppressWarnings("unused")
int enableGL = reply.readInt();
int showUpdates = reply.readInt();
- updateCheckBox(mShowScreenUpdates, showUpdates != 0);
+ updateSwitchPreference(mShowScreenUpdates, showUpdates != 0);
@SuppressWarnings("unused")
int showBackground = reply.readInt();
int disableOverlays = reply.readInt();
- updateCheckBox(mDisableOverlays, disableOverlays != 0);
+ updateSwitchPreference(mDisableOverlays, disableOverlays != 0);
reply.recycle();
data.recycle();
}
}
private void updateHardwareUiOptions() {
- updateCheckBox(mForceHardwareUi, SystemProperties.getBoolean(HARDWARE_UI_PROPERTY, false));
+ updateSwitchPreference(mForceHardwareUi, SystemProperties.getBoolean(HARDWARE_UI_PROPERTY, false));
}
private void writeHardwareUiOptions() {
}
private void updateMsaaOptions() {
- updateCheckBox(mForceMsaa, SystemProperties.getBoolean(MSAA_PROPERTY, false));
+ updateSwitchPreference(mForceMsaa, SystemProperties.getBoolean(MSAA_PROPERTY, false));
}
private void writeMsaaOptions() {
}
private void updateShowHwScreenUpdatesOptions() {
- updateCheckBox(mShowHwScreenUpdates,
+ updateSwitchPreference(mShowHwScreenUpdates,
SystemProperties.getBoolean(HardwareRenderer.DEBUG_DIRTY_REGIONS_PROPERTY, false));
}
}
private void updateShowHwLayersUpdatesOptions() {
- updateCheckBox(mShowHwLayersUpdates, SystemProperties.getBoolean(
+ updateSwitchPreference(mShowHwLayersUpdates, SystemProperties.getBoolean(
HardwareRenderer.DEBUG_SHOW_LAYERS_UPDATES_PROPERTY, false));
}
}
private void updateDebugLayoutOptions() {
- updateCheckBox(mDebugLayout,
+ updateSwitchPreference(mDebugLayout,
SystemProperties.getBoolean(View.DEBUG_LAYOUT_PROPERTY, false));
}
}
}
- private void updateUseNuplayerOptions() {
- updateCheckBox(
- mUseNuplayer, !SystemProperties.getBoolean(USE_AWESOMEPLAYER_PROPERTY, false));
- }
-
- private void writeUseNuplayerOptions() {
- SystemProperties.set(
- USE_AWESOMEPLAYER_PROPERTY, mUseNuplayer.isChecked() ? "false" : "true");
- pokeSystemProperties();
- }
-
private void updateUSBAudioOptions() {
- updateCheckBox(mUSBAudio, Settings.Secure.getInt(getContentResolver(),
+ updateSwitchPreference(mUSBAudio, Settings.Secure.getInt(getContentResolver(),
Settings.Secure.USB_AUDIO_AUTOMATIC_ROUTING_DISABLED, 0) != 0);
}
}
private void updateForceRtlOptions() {
- updateCheckBox(mForceRtlLayout, Settings.Global.getInt(getActivity().getContentResolver(),
+ updateSwitchPreference(mForceRtlLayout,
+ Settings.Global.getInt(getActivity().getContentResolver(),
Settings.Global.DEVELOPMENT_FORCE_RTL, 0) != 0);
}
}
private void updateWifiDisplayCertificationOptions() {
- updateCheckBox(mWifiDisplayCertification, Settings.Global.getInt(
+ updateSwitchPreference(mWifiDisplayCertification, Settings.Global.getInt(
getActivity().getContentResolver(),
Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, 0) != 0);
}
private void updateWifiVerboseLoggingOptions() {
boolean enabled = mWifiManager.getVerboseLoggingLevel() > 0;
- updateCheckBox(mWifiVerboseLogging, enabled);
+ updateSwitchPreference(mWifiVerboseLogging, enabled);
}
private void writeWifiVerboseLoggingOptions() {
private void updateWifiAggressiveHandoverOptions() {
boolean enabled = mWifiManager.getAggressiveHandover() > 0;
- updateCheckBox(mWifiAggressiveHandover, enabled);
+ updateSwitchPreference(mWifiAggressiveHandover, enabled);
}
private void writeWifiAggressiveHandoverOptions() {
private void updateWifiAllowScansWithTrafficOptions() {
boolean enabled = mWifiManager.getAllowScansWithTraffic() > 0;
- updateCheckBox(mWifiAllowScansWithTraffic, enabled);
+ updateSwitchPreference(mWifiAllowScansWithTraffic, enabled);
}
private void writeWifiAllowScansWithTrafficOptions() {
mWifiManager.setAllowScansWithTraffic(mWifiAllowScansWithTraffic.isChecked() ? 1 : 0);
}
+ private void updateLegacyDhcpClientOptions() {
+ updateSwitchPreference(mLegacyDhcpClient, Settings.Global.getInt(
+ getActivity().getContentResolver(),
+ Settings.Global.LEGACY_DHCP_CLIENT, 0) != 0);
+ }
+
+ private void writeLegacyDhcpClientOptions() {
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.LEGACY_DHCP_CLIENT,
+ mLegacyDhcpClient.isChecked() ? 1 : 0);
+ }
+
+ private void updateMobileDataAlwaysOnOptions() {
+ updateSwitchPreference(mMobileDataAlwaysOn, Settings.Global.getInt(
+ getActivity().getContentResolver(),
+ Settings.Global.MOBILE_DATA_ALWAYS_ON, 0) != 0);
+ }
+
+ private void writeMobileDataAlwaysOnOptions() {
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.MOBILE_DATA_ALWAYS_ON,
+ mMobileDataAlwaysOn.isChecked() ? 1 : 0);
+ }
+
private void updateLogdSizeValues() {
if (mLogdSize != null) {
String currentValue = SystemProperties.get(SELECT_LOGD_SIZE_PROPERTY);
updateLogdSizeValues();
}
+ private void updateUsbConfigurationValues() {
+ if (mUsbConfiguration != null) {
+ UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);
+
+ String[] values = getResources().getStringArray(R.array.usb_configuration_values);
+ String[] titles = getResources().getStringArray(R.array.usb_configuration_titles);
+ int index = 0;
+ for (int i = 0; i < titles.length; i++) {
+ if (manager.isFunctionEnabled(values[i])) {
+ index = i;
+ break;
+ }
+ }
+ mUsbConfiguration.setValue(values[index]);
+ mUsbConfiguration.setSummary(titles[index]);
+ mUsbConfiguration.setOnPreferenceChangeListener(this);
+ }
+ }
+
+ private void writeUsbConfigurationOption(Object newValue) {
+ UsbManager manager = (UsbManager)getActivity().getSystemService(Context.USB_SERVICE);
+ String function = newValue.toString();
+ manager.setCurrentFunction(function);
+ if (function.equals("none")) {
+ manager.setUsbDataUnlocked(false);
+ } else {
+ manager.setUsbDataUnlocked(true);
+ }
+ }
+
private void updateCpuUsageOptions() {
- updateCheckBox(mShowCpuUsage, Settings.Global.getInt(getActivity().getContentResolver(),
+ updateSwitchPreference(mShowCpuUsage,
+ Settings.Global.getInt(getActivity().getContentResolver(),
Settings.Global.SHOW_PROCESSES, 0) != 0);
}
}
private void updateImmediatelyDestroyActivitiesOptions() {
- updateCheckBox(mImmediatelyDestroyActivities, Settings.Global.getInt(
- getActivity().getContentResolver(), Settings.Global.ALWAYS_FINISH_ACTIVITIES, 0) != 0);
+ updateSwitchPreference(mImmediatelyDestroyActivities, Settings.Global.getInt(
+ getActivity().getContentResolver(), Settings.Global.ALWAYS_FINISH_ACTIVITIES, 0) != 0);
}
private void updateAnimationScaleValue(int which, ListPreference pref) {
}
private void updateShowAllANRsOptions() {
- updateCheckBox(mShowAllANRs, Settings.Secure.getInt(
- getActivity().getContentResolver(), Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0);
+ updateSwitchPreference(mShowAllANRs, Settings.Secure.getInt(
+ getActivity().getContentResolver(), Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0);
+ }
+
+ private void confirmEnableOemUnlock() {
+ DialogInterface.OnClickListener onConfirmListener = new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ Utils.setOemUnlockEnabled(getActivity(), true);
+ updateAllOptions();
+ }
+ };
+
+ new AlertDialog.Builder(getActivity())
+ .setTitle(R.string.confirm_enable_oem_unlock_title)
+ .setMessage(R.string.confirm_enable_oem_unlock_text)
+ .setPositiveButton(R.string.enable_text, onConfirmListener)
+ .setNegativeButton(android.R.string.cancel, null)
+ .create()
+ .show();
+ }
+
+ private void confirmEnableMultiWindowMode() {
+ DialogInterface.OnClickListener onConfirmListener = new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ setEnableMultiWindow((which == DialogInterface.BUTTON_POSITIVE) ? true : false);
+ updateAllOptions();
+ }
+ };
+
+ new AlertDialog.Builder(getActivity())
+ .setTitle(R.string.confirm_enable_multi_window_title)
+ .setMessage(R.string.confirm_enable_multi_window_text)
+ .setPositiveButton(R.string.enable_text, onConfirmListener)
+ .setNegativeButton(android.R.string.cancel, onConfirmListener)
+ .create()
+ .show();
}
@Override
writeDebuggerOptions();
updateDebuggerOptions();
}
+ } else if (requestCode == RESULT_MOCK_LOCATION_APP) {
+ if (resultCode == Activity.RESULT_OK) {
+ mMockLocationApp = data.getAction();
+ writeMockLocation();
+ updateMockLocation();
+ }
+ } else if (requestCode == REQUEST_CODE_ENABLE_OEM_UNLOCK) {
+ if (resultCode == Activity.RESULT_OK) {
+ if (mEnableOemUnlock.isChecked()) {
+ confirmEnableOemUnlock();
+ } else {
+ Utils.setOemUnlockEnabled(getActivity(), false);
+ }
+ }
} else {
super.onActivityResult(requestCode, resultCode, data);
}
} else if (preference == mBtHciSnoopLog) {
writeBtHciSnoopLogOptions();
} else if (preference == mEnableOemUnlock) {
- Utils.setOemUnlockEnabled(getActivity(), mEnableOemUnlock.isChecked());
- } else if (preference == mAllowMockLocation) {
- Settings.Secure.putInt(getActivity().getContentResolver(),
- Settings.Secure.ALLOW_MOCK_LOCATION,
- mAllowMockLocation.isChecked() ? 1 : 0);
+ if (!showKeyguardConfirmation(getResources(), REQUEST_CODE_ENABLE_OEM_UNLOCK)) {
+ if (mEnableOemUnlock.isChecked()) {
+ confirmEnableOemUnlock();
+ } else {
+ Utils.setOemUnlockEnabled(getActivity(), false);
+ }
+ }
+ } else if (preference == mMockLocationAppPref) {
+ Intent intent = new Intent(getActivity(), AppPicker.class);
+ intent.putExtra(AppPicker.EXTRA_REQUESTIING_PERMISSION,
+ Manifest.permission.ACCESS_MOCK_LOCATION);
+ startActivityForResult(intent, RESULT_MOCK_LOCATION_APP);
} else if (preference == mDebugViewAttributes) {
Settings.Global.putInt(getActivity().getContentResolver(),
Settings.Global.DEBUG_VIEW_ATTRIBUTES,
mDebugViewAttributes.isChecked() ? 1 : 0);
} else if (preference == mDebugAppPref) {
- startActivityForResult(new Intent(getActivity(), AppPicker.class), RESULT_DEBUG_APP);
+ Intent intent = new Intent(getActivity(), AppPicker.class);
+ intent.putExtra(AppPicker.EXTRA_DEBUGGABLE, true);
+ startActivityForResult(intent, RESULT_DEBUG_APP);
} else if (preference == mWaitForDebugger) {
writeDebuggerOptions();
} else if (preference == mVerifyAppsOverUsb) {
writeShowUpdatesOption();
} else if (preference == mDisableOverlays) {
writeDisableOverlaysOption();
+ } else if (preference == mEnableMultiWindow) {
+ if (mEnableMultiWindow.isChecked()) {
+ confirmEnableMultiWindowMode();
+ } else {
+ setEnableMultiWindow(false);
+ }
} else if (preference == mShowCpuUsage) {
writeCpuUsageOptions();
} else if (preference == mImmediatelyDestroyActivities) {
writeWifiAggressiveHandoverOptions();
} else if (preference == mWifiAllowScansWithTraffic) {
writeWifiAllowScansWithTrafficOptions();
- } else if (preference == mUseNuplayer) {
- writeUseNuplayerOptions();
+ } else if (preference == mLegacyDhcpClient) {
+ writeLegacyDhcpClientOptions();
+ } else if (preference == mMobileDataAlwaysOn) {
+ writeMobileDataAlwaysOnOptions();
} else if (preference == mUSBAudio) {
writeUSBAudioOptions();
+ } else if (INACTIVE_APPS_KEY.equals(preference.getKey())) {
+ startInactiveAppsFragment();
} else {
return super.onPreferenceTreeClick(preferenceScreen, preference);
}
return false;
}
+ private void startInactiveAppsFragment() {
+ ((SettingsActivity) getActivity()).startPreferencePanel(
+ InactiveApps.class.getName(),
+ null, R.string.inactive_apps_title, null, null, 0);
+ }
+
+ private boolean showKeyguardConfirmation(Resources resources, int requestCode) {
+ return new ChooseLockSettingsHelper(getActivity(), this).launchConfirmationActivity(
+ requestCode, resources.getString(R.string.oem_unlock_enable));
+ }
+
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
if (HDCP_CHECKING_KEY.equals(preference.getKey())) {
} else if (preference == mLogdSize) {
writeLogdSizeOption(newValue);
return true;
+ } else if (preference == mUsbConfiguration) {
+ writeUsbConfigurationOption(newValue);
+ return true;
} else if (preference == mWindowAnimationScale) {
writeAnimationScaleOption(0, mWindowAnimationScale, newValue);
return true;
} else if (preference == mSimulateColorSpace) {
writeSimulateColorSpace(newValue);
return true;
+ } else if (preference == mRootAccess) {
+ if ("0".equals(SystemProperties.get(ROOT_ACCESS_PROPERTY, "1"))
+ && !"0".equals(newValue)) {
+ mSelectedRootValue = newValue;
+ mDialogClicked = false;
+ if (mRootDialog != null) {
+ dismissDialogs();
+ }
+ mRootDialog = new AlertDialog.Builder(getActivity())
+ .setMessage(getResources().getString(R.string.root_access_warning_message))
+ .setTitle(R.string.root_access_warning_title)
+ .setIcon(android.R.drawable.ic_dialog_alert)
+ .setPositiveButton(android.R.string.yes, this)
+ .setNegativeButton(android.R.string.no, this).show();
+ mRootDialog.setOnDismissListener(this);
+ } else {
+ writeRootAccessOptions(newValue);
+ }
+ return true;
}
return false;
}
mEnableDialog.dismiss();
mEnableDialog = null;
}
+ if (mRootDialog != null) {
+ mRootDialog.dismiss();
+ mRootDialog = null;
+ }
}
public void onClick(DialogInterface dialog, int which) {
// Reset the toggle
mSwitchBar.setChecked(false);
}
+ } else if (dialog == mRootDialog) {
+ if (which == DialogInterface.BUTTON_POSITIVE) {
+ writeRootAccessOptions(mSelectedRootValue);
+ } else {
+ // Reset the option
+ writeRootAccessOptions("0");
+ }
}
}
}
}
+ private BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ updateUsbConfigurationValues();
+ }
+ };
+
static class SystemPropPoker extends AsyncTask<Void, Void, Void> {
@Override
protected Void doInBackground(Void... params) {
if (!showEnableOemUnlockPreference()) {
keys.add(ENABLE_OEM_UNLOCK);
}
+ if (!showEnableMultiWindowPreference()) {
+ keys.add(ENABLE_MULTI_WINDOW_KEY);
+ }
return keys;
}
};
OSDN Git Service
