/*
* Copyright (C) 2008 The Android Open Source Project
+ * Copyright (C) 2013-2014 The CyanogenMod Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
+import android.net.NetworkUtils;
+import android.net.wifi.IWifiManager;
+import android.net.wifi.WifiInfo;
import android.hardware.usb.IUsbManager;
import android.hardware.usb.UsbManager;
import android.net.wifi.WifiManager;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceChangeListener;
+import android.preference.Preference.OnPreferenceClickListener;
import android.preference.PreferenceGroup;
import android.preference.PreferenceScreen;
import android.preference.SwitchPreference;
import android.view.accessibility.AccessibilityManager;
import android.widget.Switch;
import android.widget.TextView;
+import android.widget.Toast;
import com.android.internal.logging.MetricsLogger;
+import com.android.settings.Settings.AppOpsSummaryActivity;
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 cyanogenmod.providers.CMSettings;
+import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
*/
public class DevelopmentSettings extends SettingsPreferenceFragment
implements DialogInterface.OnClickListener, DialogInterface.OnDismissListener,
- OnPreferenceChangeListener, SwitchBar.OnSwitchChangeListener, Indexable {
+ OnPreferenceChangeListener, SwitchBar.OnSwitchChangeListener, Indexable,
+ OnPreferenceClickListener {
private static final String TAG = "DevelopmentSettings";
/**
public static final String PREF_SHOW = "show";
private static final String ENABLE_ADB = "enable_adb";
+ private static final String ADB_NOTIFY = "adb_notify";
+ private static final String ADB_TCPIP = "adb_over_network";
private static final String CLEAR_ADB_KEYS = "clear_adb_keys";
private static final String ENABLE_TERMINAL = "enable_terminal";
- private static final String KEEP_SCREEN_ON = "keep_screen_on";
+ private static final String KEEP_SCREEN_ON_MODES = "keep_screen_on_modes";
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 HDCP_CHECKING_KEY = "hdcp_checking";
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";
private static final String DEBUG_APP_KEY = "debug_app";
private static final String WAIT_FOR_DEBUGGER_KEY = "wait_for_debugger";
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 COLOR_TEMPERATURE_KEY = "color_temperature";
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 ROOT_APPOPS_KEY = "root_appops";
+
+ private static final String UPDATE_RECOVERY_KEY = "update_recovery";
+ private static final String UPDATE_RECOVERY_PROPERTY = "persist.sys.recovery_update";
+
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 KILL_APP_LONGPRESS_BACK = "kill_app_longpress_back";
+
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 String DEVELOPMENT_TOOLS = "development_tools";
+
+ private static final String ADVANCED_REBOOT_KEY = "advanced_reboot";
+
+ private static final String DEVELOPMENT_SHORTCUT_KEY = "development_shortcut";
+
private static final int RESULT_DEBUG_APP = 1000;
private static final int RESULT_MOCK_LOCATION_APP = 1001;
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 static final String SUPERUSER_BINARY_PATH = "/system/xbin/su";
+
private IWindowManager mWindowManager;
private IBackupManager mBackupManager;
private DevicePolicyManager mDpm;
private boolean mDontPokeProperties;
private SwitchPreference mEnableAdb;
+ private SwitchPreference mAdbNotify;
+ private SwitchPreference mAdbOverNetwork;
private Preference mClearAdbKeys;
private SwitchPreference mEnableTerminal;
private Preference mBugreport;
private SwitchPreference mBugreportInPower;
- private SwitchPreference mKeepScreenOn;
+ private ListPreference mKeepScreenOn;
private SwitchPreference mBtHciSnoopLog;
private SwitchPreference mEnableOemUnlock;
private SwitchPreference mDebugViewAttributes;
private ListPreference mUsbConfiguration;
private ListPreference mTrackFrameTime;
private ListPreference mShowNonRectClip;
- private ListPreference mWindowAnimationScale;
- private ListPreference mTransitionAnimationScale;
- private ListPreference mAnimatorDurationScale;
+ private AnimationScalePreference mWindowAnimationScale;
+ private AnimationScalePreference mTransitionAnimationScale;
+ private AnimationScalePreference mAnimatorDurationScale;
private ListPreference mOverlayDisplayDevices;
private ListPreference mOpenGLTraces;
private ListPreference mAppProcessLimit;
private SwitchPreference mShowAllANRs;
+ private SwitchPreference mKillAppLongpressBack;
+
+ private ListPreference mRootAccess;
+ private Object mSelectedRootValue;
+ private PreferenceScreen mDevelopmentTools;
+ private ColorModePreference mColorModePreference;
+
+ private Preference mRootAppops;
+
+ private SwitchPreference mAdvancedReboot;
+
+ private SwitchPreference mUpdateRecovery;
+
+ private SwitchPreference mDevelopmentShortcut;
+
+ private SwitchPreference mColorTemperaturePreference;
private final ArrayList<Preference> mAllPrefs = new ArrayList<Preference>();
private boolean mDialogClicked;
private Dialog mEnableDialog;
private Dialog mAdbDialog;
-
+ private Dialog mAdbTcpDialog;
private Dialog mAdbKeysDialog;
private boolean mUnavailable;
+ private Dialog mRootDialog;
+ private Dialog mUpdateRecoveryDialog;
@Override
protected int getMetricsCategory() {
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 = findAndInitSwitchPref(ENABLE_ADB);
+
+ mAdbNotify = (SwitchPreference) findPreference(ADB_NOTIFY);
+ mAllPrefs.add(mAdbNotify);
+ mAdbOverNetwork = findAndInitSwitchPref(ADB_TCPIP);
+
mClearAdbKeys = findPreference(CLEAR_ADB_KEYS);
if (!SystemProperties.getBoolean("ro.adb.secure", false)) {
if (debugDebuggingCategory != null) {
mBugreport = findPreference(BUGREPORT);
mBugreportInPower = findAndInitSwitchPref(BUGREPORT_IN_POWER_KEY);
- mKeepScreenOn = findAndInitSwitchPref(KEEP_SCREEN_ON);
+ mKeepScreenOn = addListPreference(KEEP_SCREEN_ON_MODES);
mBtHciSnoopLog = findAndInitSwitchPref(BT_HCI_SNOOP_LOG);
mEnableOemUnlock = findAndInitSwitchPref(ENABLE_OEM_UNLOCK);
if (!showEnableOemUnlockPreference()) {
mDebugViewAttributes = findAndInitSwitchPref(DEBUG_VIEW_ATTRIBUTES);
mPassword = (PreferenceScreen) findPreference(LOCAL_BACKUP_PASSWORD);
mAllPrefs.add(mPassword);
+ mAdvancedReboot = findAndInitSwitchPref(ADVANCED_REBOOT_KEY);
+ mUpdateRecovery = findAndInitSwitchPref(UPDATE_RECOVERY_KEY);
+ mDevelopmentShortcut = findAndInitSwitchPref(DEVELOPMENT_SHORTCUT_KEY);
if (!android.os.Process.myUserHandle().equals(UserHandle.OWNER)) {
disableForUser(mClearAdbKeys);
disableForUser(mEnableTerminal);
disableForUser(mPassword);
+ disableForUser(mAdvancedReboot);
+ disableForUser(mUpdateRecovery);
+ disableForUser(mDevelopmentShortcut);
}
mDebugAppPref = findPreference(DEBUG_APP_KEY);
mMockLocationAppPref = findPreference(MOCK_LOCATION_APP_KEY);
mAllPrefs.add(mMockLocationAppPref);
- mVerifyAppsOverUsb = findAndInitSwitchPref(VERIFY_APPS_OVER_USB_KEY);
+ mVerifyAppsOverUsb = (SwitchPreference) findPreference(VERIFY_APPS_OVER_USB_KEY);
+ mAllPrefs.add(mVerifyAppsOverUsb);
if (!showVerifierSetting()) {
if (debugDebuggingCategory != null) {
debugDebuggingCategory.removePreference(mVerifyAppsOverUsb);
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);
+ mWindowAnimationScale = findAndInitAnimationScalePreference(WINDOW_ANIMATION_SCALE_KEY);
+ mTransitionAnimationScale = findAndInitAnimationScalePreference(TRANSITION_ANIMATION_SCALE_KEY);
+ mAnimatorDurationScale = findAndInitAnimationScalePreference(ANIMATOR_DURATION_SCALE_KEY);
mOverlayDisplayDevices = addListPreference(OVERLAY_DISPLAY_DEVICES_KEY);
mEnableMultiWindow = findAndInitSwitchPref(ENABLE_MULTI_WINDOW_KEY);
if (!showEnableMultiWindowPreference()) {
mAllPrefs.add(mShowAllANRs);
mResetSwitchPrefs.add(mShowAllANRs);
+ mKillAppLongpressBack = findAndInitSwitchPref(KILL_APP_LONGPRESS_BACK);
+
Preference hdcpChecking = findPreference(HDCP_CHECKING_KEY);
if (hdcpChecking != null) {
mAllPrefs.add(hdcpChecking);
removePreferenceForProduction(hdcpChecking);
}
+
+ mRootAccess = (ListPreference) findPreference(ROOT_ACCESS_KEY);
+ mRootAccess.setOnPreferenceChangeListener(this);
+
+ mRootAppops = (Preference) findPreference(ROOT_APPOPS_KEY);
+ mRootAppops.setOnPreferenceClickListener(this);
+
+ if (!removeRootOptionsIfRequired()) {
+ if (isRootForAppsAvailable()) {
+ mRootAccess.setEntries(R.array.root_access_entries);
+ mRootAccess.setEntryValues(R.array.root_access_values);
+ } else {
+ mRootAccess.setEntries(R.array.root_access_entries_adb);
+ mRootAccess.setEntryValues(R.array.root_access_values_adb);
+ }
+ mAllPrefs.add(mRootAccess);
+ mAllPrefs.add(mRootAppops);
+ }
+
+ mDevelopmentTools = (PreferenceScreen) findPreference(DEVELOPMENT_TOOLS);
+ if (Utils.updatePreferenceToSpecificActivityOrRemove(getActivity(),
+ getPreferenceScreen(), mDevelopmentTools.getKey(), 0)) {
+ mAllPrefs.add(mDevelopmentTools);
+ }
+
+ mColorModePreference = (ColorModePreference) findPreference(KEY_COLOR_MODE);
+ mColorModePreference.updateCurrentAndSupported();
+ if (mColorModePreference.getTransformsCount() < 2) {
+ removePreference(KEY_COLOR_MODE);
+ mColorModePreference = null;
+ }
+
+ mColorTemperaturePreference = (SwitchPreference) findPreference(COLOR_TEMPERATURE_KEY);
+ if (getResources().getBoolean(R.bool.config_enableColorTemperature)) {
+ mAllPrefs.add(mColorTemperaturePreference);
+ mResetSwitchPrefs.add(mColorTemperaturePreference);
+ } else {
+ removePreference(COLOR_TEMPERATURE_KEY);
+ mColorTemperaturePreference = null;
+ }
+
+ if (!getResources().getBoolean(R.bool.config_enableRecoveryUpdater)) {
+ removePreference(mUpdateRecovery);
+ mUpdateRecovery = null;
+ if (SystemProperties.getBoolean(UPDATE_RECOVERY_PROPERTY, false)) {
+ SystemProperties.set(UPDATE_RECOVERY_PROPERTY, "false");
+ pokeSystemProperties();
+ }
+ }
}
private ListPreference addListPreference(String prefKey) {
}
}
+ private AnimationScalePreference findAndInitAnimationScalePreference(String key) {
+ AnimationScalePreference pref = (AnimationScalePreference) findPreference(key);
+ pref.setOnPreferenceChangeListener(this);
+ pref.setOnPreferenceClickListener(this);
+ mAllPrefs.add(pref);
+ return pref;
+ }
+
private SwitchPreference findAndInitSwitchPref(String key) {
SwitchPreference pref = (SwitchPreference) findPreference(key);
if (pref == null) {
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);
setPrefsEnabledState(mLastEnabledState);
}
mSwitchBar.show();
+ updateKillAppLongpressBackOptions();
+
+ if (mColorModePreference != null) {
+ mColorModePreference.startListening();
+ mColorModePreference.updateCurrentAndSupported();
+ }
+ }
+
+ @Override
+ public void onPause() {
+ super.onPause();
+ if (mColorModePreference != null) {
+ mColorModePreference.stopListening();
+ }
}
@Override
mHaveDebugSettings = false;
updateSwitchPreference(mEnableAdb, Settings.Global.getInt(cr,
Settings.Global.ADB_ENABLED, 0) != 0);
+
+ mAdbNotify.setChecked(CMSettings.Secure.getInt(cr,
+ CMSettings.Secure.ADB_NOTIFY, 1) != 0);
+ updateAdbOverNetwork();
+
if (mEnableTerminal != null) {
updateSwitchPreference(mEnableTerminal,
context.getPackageManager().getApplicationEnabledSetting(TERMINAL_APP_PACKAGE)
}
updateSwitchPreference(mBugreportInPower, Settings.Secure.getInt(cr,
Settings.Secure.BUGREPORT_IN_POWER_MENU, 0) != 0);
- updateSwitchPreference(mKeepScreenOn, Settings.Global.getInt(cr,
- Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0) != 0);
+ updateStayAwakeOptions();
updateSwitchPreference(mBtHciSnoopLog, Settings.Secure.getInt(cr,
Settings.Secure.BLUETOOTH_HCI_LOG, 0) != 0);
if (mEnableOemUnlock != null) {
updateMobileDataAlwaysOnOptions();
updateSimulateColorSpace();
updateUSBAudioOptions();
+ updateRootAccessOptions();
+ updateAdvancedRebootOptions();
+ updateDevelopmentShortcutOptions();
+ if (mUpdateRecovery != null) {
+ updateUpdateRecoveryOptions();
+ }
+ if (mColorTemperaturePreference != null) {
+ updateColorTemperature();
+ }
+ }
+
+ private void writeAdvancedRebootOptions() {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADVANCED_REBOOT,
+ mAdvancedReboot.isChecked() ? 1 : 0);
+ }
+
+ private void updateAdvancedRebootOptions() {
+ mAdvancedReboot.setChecked(CMSettings.Secure.getInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADVANCED_REBOOT, 0) != 0);
+ }
+
+ private void resetDevelopmentShortcutOptions() {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.DEVELOPMENT_SHORTCUT, 0);
+ }
+
+ private void writeDevelopmentShortcutOptions() {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.DEVELOPMENT_SHORTCUT,
+ mDevelopmentShortcut.isChecked() ? 1 : 0);
+ }
+
+ private void updateDevelopmentShortcutOptions() {
+ mDevelopmentShortcut.setChecked(CMSettings.Secure.getInt(getActivity().getContentResolver(),
+ CMSettings.Secure.DEVELOPMENT_SHORTCUT, 0) != 0);
+ }
+
+ private void updateAdbOverNetwork() {
+ int port = CMSettings.Secure.getInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADB_PORT, 0);
+ boolean enabled = port > 0;
+
+ updateSwitchPreference(mAdbOverNetwork, enabled);
+
+ WifiInfo wifiInfo = null;
+
+ if (enabled) {
+ IWifiManager wifiManager = IWifiManager.Stub.asInterface(
+ ServiceManager.getService(Context.WIFI_SERVICE));
+ try {
+ wifiInfo = wifiManager.getConnectionInfo();
+ } catch (RemoteException e) {
+ Log.e(TAG, "wifiManager, getConnectionInfo()", e);
+ }
+ }
+
+ if (wifiInfo != null) {
+ String hostAddress = NetworkUtils.intToInetAddress(
+ wifiInfo.getIpAddress()).getHostAddress();
+ mAdbOverNetwork.setSummary(hostAddress + ":" + String.valueOf(port));
+ } else {
+ mAdbOverNetwork.setSummary(R.string.adb_over_network_summary);
+ }
}
private void resetDangerousOptions() {
}
resetDebuggerOptions();
writeLogdSizeOption(null);
+ resetRootAccessOptions();
+ resetAdbNotifyOptions();
+ resetVerifyAppsOverUsbOptions();
+ resetDevelopmentShortcutOptions();
+ if (mUpdateRecovery != null) {
+ resetUpdateRecoveryOptions();
+ }
writeAnimationScaleOption(0, mWindowAnimationScale, null);
writeAnimationScaleOption(1, mTransitionAnimationScale, null);
writeAnimationScaleOption(2, mAnimatorDurationScale, null);
pokeSystemProperties();
}
+ private void updateRootAccessOptions() {
+ String value = SystemProperties.get(ROOT_ACCESS_PROPERTY, "0");
+ mRootAccess.setValue(value);
+ mRootAccess.setSummary(getResources()
+ .getStringArray(R.array.root_access_entries)[Integer.valueOf(value)]);
+
+ if (mRootAppops != null) {
+ mRootAppops.setEnabled(isRootForAppsEnabled());
+ }
+ }
+
+ private boolean isRootForAppsAvailable() {
+ boolean exists = false;
+ try {
+ File f = new File(SUPERUSER_BINARY_PATH);
+ exists = f.exists();
+ } catch (SecurityException e) {
+ // Ignore
+ }
+ return exists;
+ }
+
+ public static boolean isRootForAppsEnabled() {
+ int value = SystemProperties.getInt(ROOT_ACCESS_PROPERTY, 0);
+ boolean daemonState =
+ SystemProperties.get("init.svc.su_daemon", "absent").equals("running");
+ return daemonState && (value == 1 || value == 3);
+ }
+
+ private void writeRootAccessOptions(Object newValue) {
+ String oldValue = SystemProperties.get(ROOT_ACCESS_PROPERTY, "0");
+ 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.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.ADB_ENABLED, 0);
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.ADB_ENABLED, 1);
+ }
+ updateRootAccessOptions();
+ }
+
+ private void resetRootAccessOptions() {
+ String oldValue = SystemProperties.get(ROOT_ACCESS_PROPERTY, "0");
+ SystemProperties.set(ROOT_ACCESS_PROPERTY, "0");
+ if (!oldValue.equals("0") && "1".equals(SystemProperties.get("service.adb.root", "0"))) {
+ SystemProperties.set("service.adb.root", "0");
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.ADB_ENABLED, 0);
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.ADB_ENABLED, 1);
+ }
+ updateRootAccessOptions();
+ }
+
+ private void resetAdbNotifyOptions() {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADB_NOTIFY, 1);
+ }
+
+ private void updateStayAwakeOptions() {
+ int index = Settings.Global.getInt(getActivity().getContentResolver(),
+ Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0);
+ final String[] values = getResources().getStringArray(R.array.keep_screen_on_values);
+ final String[] summaries = getResources().getStringArray(R.array.keep_screen_on_titles);
+ // The old value contained 0 (disable) or 3 (BATTERY_PLUGGED_AC|BATTERY_PLUGGED_USB)
+ // Currently only have 3 values (0: Not enabled; 1: debugging over usb; >2: charging)
+ // NOTE: If we have newer values, then we need to migrate
+ // this property
+ if (index >= values.length) {
+ index = values.length - 1;
+ }
+ mKeepScreenOn.setValue(values[index]);
+ mKeepScreenOn.setSummary(summaries[index]);
+ mKeepScreenOn.setOnPreferenceChangeListener(this);
+ }
+
private void updateHdcpValues() {
ListPreference hdcpChecking = (ListPreference) findPreference(HDCP_CHECKING_KEY);
if (hdcpChecking != null) {
}
}
+ private void writeKillAppLongpressBackOptions() {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.KILL_APP_LONGPRESS_BACK,
+ mKillAppLongpressBack.isChecked() ? 1 : 0);
+ }
+
+ private void updateKillAppLongpressBackOptions() {
+ mKillAppLongpressBack.setChecked(CMSettings.Secure.getInt(
+ getActivity().getContentResolver(), CMSettings.Secure.KILL_APP_LONGPRESS_BACK, 0) != 0);
+ }
+
private void updatePasswordSummary() {
try {
+ if (mBackupManager == null) {
+ Log.e(TAG, "Backup Manager is unavailable!");
+ return;
+ }
if (mBackupManager.hasBackupPassword()) {
mPassword.setSummary(R.string.local_backup_password_summary_change);
} else {
Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, mVerifyAppsOverUsb.isChecked() ? 1 : 0);
}
+ private void resetVerifyAppsOverUsbOptions() {
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1);
+ }
+
private boolean enableVerifierSetting() {
final ContentResolver cr = getActivity().getContentResolver();
if (Settings.Global.getInt(cr, Settings.Global.ADB_ENABLED, 0) == 0) {
mShowNonRectClip.setSummary(mShowNonRectClip.getEntries()[0]);
}
+ private void writeStayAwakeOptions(Object newValue) {
+ int val = Integer.parseInt((String) newValue);
+ Settings.Global.putInt(getActivity().getContentResolver(),
+ Settings.Global.STAY_ON_WHILE_PLUGGED_IN, val);
+ updateStayAwakeOptions();
+ }
+
private void writeShowNonRectClipOptions(Object newValue) {
SystemProperties.set(HardwareRenderer.DEBUG_SHOW_NON_RECTANGULAR_CLIP_PROPERTY,
newValue == null ? "" : newValue.toString());
}
}
+ private void updateColorTemperature() {
+ updateSwitchPreference(mColorTemperaturePreference,
+ SystemProperties.getBoolean(COLOR_TEMPERATURE_PROPERTY, false));
+ }
+
+ private void writeColorTemperature() {
+ SystemProperties.set(COLOR_TEMPERATURE_PROPERTY,
+ mColorTemperaturePreference.isChecked() ? "1" : "0");
+ pokeSystemProperties();
+ Toast.makeText(getActivity(), R.string.color_temperature_toast, Toast.LENGTH_LONG).show();
+ }
+
private void updateUSBAudioOptions() {
updateSwitchPreference(mUSBAudio, Settings.Secure.getInt(getContentResolver(),
Settings.Secure.USB_AUDIO_AUTOMATIC_ROUTING_DISABLED, 0) != 0);
updateLogdSizeValues();
}
- private void updateUsbConfigurationValues() {
+ private void updateUsbConfigurationValues(boolean isUnlocked) {
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++) {
+ // Assume if !isUnlocked -> charging, which should be at index 0
+ for (int i = 0; i < titles.length && isUnlocked; i++) {
if (manager.isFunctionEnabled(values[i])) {
index = i;
break;
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.setCurrentFunction(null);
manager.setUsbDataUnlocked(false);
} else {
+ manager.setCurrentFunction(function);
manager.setUsbDataUnlocked(true);
}
}
getActivity().getContentResolver(), Settings.Global.ALWAYS_FINISH_ACTIVITIES, 0) != 0);
}
- private void updateAnimationScaleValue(int which, ListPreference pref) {
+ private void updateAnimationScaleValue(int which, AnimationScalePreference pref) {
try {
float scale = mWindowManager.getAnimationScale(which);
if (scale != 1) {
mHaveDebugSettings = true;
}
- CharSequence[] values = pref.getEntryValues();
- for (int i=0; i<values.length; i++) {
- float val = Float.parseFloat(values[i].toString());
- if (scale <= val) {
- pref.setValueIndex(i);
- pref.setSummary(pref.getEntries()[i]);
- return;
- }
- }
- pref.setValueIndex(values.length-1);
- pref.setSummary(pref.getEntries()[0]);
+ pref.setScale(scale);
} catch (RemoteException e) {
}
}
updateAnimationScaleValue(2, mAnimatorDurationScale);
}
- private void writeAnimationScaleOption(int which, ListPreference pref, Object newValue) {
+ private void writeAnimationScaleOption(int which, AnimationScalePreference pref,
+ Object newValue) {
try {
float scale = newValue != null ? Float.parseFloat(newValue.toString()) : 1;
mWindowManager.setAnimationScale(which, scale);
}
private void confirmEnableOemUnlock() {
- DialogInterface.OnClickListener onConfirmListener = new DialogInterface.OnClickListener() {
+ DialogInterface.OnClickListener onEnableOemListener = new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
- Utils.setOemUnlockEnabled(getActivity(), true);
+ if (which == DialogInterface.BUTTON_POSITIVE) {
+ 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)
+ .setPositiveButton(R.string.enable_text, onEnableOemListener)
+ .setNegativeButton(android.R.string.cancel, onEnableOemListener)
+ .setCancelable(false)
.create()
.show();
}
.setMessage(R.string.confirm_enable_multi_window_text)
.setPositiveButton(R.string.enable_text, onConfirmListener)
.setNegativeButton(android.R.string.cancel, onConfirmListener)
+ .setCancelable(false)
.create()
.show();
}
+ private void updateUpdateRecoveryOptions() {
+ updateSwitchPreference(mUpdateRecovery, SystemProperties.getBoolean(
+ UPDATE_RECOVERY_PROPERTY, false));
+ }
+
+ private void writeUpdateRecoveryOptions() {
+ SystemProperties.set(UPDATE_RECOVERY_PROPERTY,
+ mUpdateRecovery.isChecked() ? "true" : "false");
+ pokeSystemProperties();
+ }
+
+ private static void resetUpdateRecoveryOptions() {
+ // User builds should update recovery by default
+ if ("user".equals(Build.TYPE)) {
+ SystemProperties.set(UPDATE_RECOVERY_PROPERTY, "true");
+ }
+ }
+
+ public static void initializeUpdateRecoveryOption(Context context) {
+ if (TextUtils.isEmpty(SystemProperties.get(UPDATE_RECOVERY_PROPERTY)) &&
+ context.getResources().getBoolean(R.bool.config_enableRecoveryUpdater)) {
+ resetUpdateRecoveryOptions();
+ }
+ }
+
@Override
public void onSwitchChanged(Switch switchView, boolean isChecked) {
if (switchView != mSwitchBar.getSwitch()) {
if (isChecked != mLastEnabledState) {
if (isChecked) {
mDialogClicked = false;
- if (mEnableDialog != null) dismissDialogs();
+ if (mEnableDialog != null) {
+ dismissDialogs();
+ }
mEnableDialog = new AlertDialog.Builder(getActivity()).setMessage(
getActivity().getResources().getString(
R.string.dev_settings_warning_message))
Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0);
mLastEnabledState = isChecked;
setPrefsEnabledState(mLastEnabledState);
+
+ // Hide development settings from the Settings menu (Android 4.2 behaviour)
+ getActivity().getSharedPreferences(PREF_FILE, Context.MODE_PRIVATE).edit()
+ .putBoolean(PREF_SHOW, false)
+ .apply();
}
}
}
}
@Override
+ public boolean onPreferenceClick(Preference preference) {
+ if (preference == mWindowAnimationScale ||
+ preference == mTransitionAnimationScale ||
+ preference == mAnimatorDurationScale) {
+ ((AnimationScalePreference) preference).click();
+ } else if (preference == mRootAppops) {
+ Activity mActivity = getActivity();
+ Intent intent = new Intent(Intent.ACTION_MAIN);
+ intent.putExtra("appops_tab", getString(R.string.app_ops_categories_su));
+ intent.setClass(mActivity, AppOpsSummaryActivity.class);
+ mActivity.startActivity(intent);
+ return true;
+ }
+ return false;
+ }
+
+ @Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
if (Utils.isMonkeyRunning()) {
return false;
if (preference == mEnableAdb) {
if (mEnableAdb.isChecked()) {
mDialogClicked = false;
- if (mAdbDialog != null) dismissDialogs();
+ if (mAdbDialog != null) {
+ dismissDialogs();
+ }
mAdbDialog = new AlertDialog.Builder(getActivity()).setMessage(
getActivity().getResources().getString(R.string.adb_warning_message))
.setTitle(R.string.adb_warning_title)
mVerifyAppsOverUsb.setChecked(false);
updateBugreportOptions();
}
+ } else if (preference == mAdbNotify) {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADB_NOTIFY,
+ mAdbNotify.isChecked() ? 1 : 0);
+ } else if (preference == mAdbOverNetwork) {
+ if (mAdbOverNetwork.isChecked()) {
+ if (mAdbTcpDialog != null) {
+ dismissDialogs();
+ }
+ mAdbTcpDialog = new AlertDialog.Builder(getActivity()).setMessage(
+ getResources().getString(R.string.adb_over_network_warning))
+ .setTitle(R.string.adb_over_network)
+ .setPositiveButton(android.R.string.yes, this)
+ .setNegativeButton(android.R.string.no, this)
+ .show();
+ mAdbTcpDialog.setOnDismissListener(this);
+ } else {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADB_PORT, -1);
+ updateAdbOverNetwork();
+ }
} else if (preference == mClearAdbKeys) {
if (mAdbKeysDialog != null) dismissDialogs();
mAdbKeysDialog = new AlertDialog.Builder(getActivity())
Settings.Secure.putInt(getActivity().getContentResolver(),
Settings.Secure.BUGREPORT_IN_POWER_MENU,
mBugreportInPower.isChecked() ? 1 : 0);
- } else if (preference == mKeepScreenOn) {
- Settings.Global.putInt(getActivity().getContentResolver(),
- Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
- mKeepScreenOn.isChecked() ?
- (BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB) : 0);
} else if (preference == mBtHciSnoopLog) {
writeBtHciSnoopLogOptions();
} else if (preference == mEnableOemUnlock) {
writeLegacyDhcpClientOptions();
} else if (preference == mMobileDataAlwaysOn) {
writeMobileDataAlwaysOnOptions();
+ } else if (preference == mColorTemperaturePreference) {
+ writeColorTemperature();
} else if (preference == mUSBAudio) {
writeUSBAudioOptions();
+ } else if (preference == mAdvancedReboot) {
+ writeAdvancedRebootOptions();
} else if (INACTIVE_APPS_KEY.equals(preference.getKey())) {
startInactiveAppsFragment();
+ } else if (preference == mDevelopmentShortcut) {
+ writeDevelopmentShortcutOptions();
+ } else if (preference == mKillAppLongpressBack) {
+ writeKillAppLongpressBackOptions();
+ } else if (preference == mUpdateRecovery) {
+ if (mSwitchBar.isChecked()) {
+ if (mUpdateRecoveryDialog != null) {
+ dismissDialogs();
+ }
+ if (mUpdateRecovery.isChecked()) {
+ mUpdateRecoveryDialog = new AlertDialog.Builder(getActivity()).setMessage(
+ getResources().getString(R.string.update_recovery_on_warning))
+ .setTitle(R.string.update_recovery_title)
+ .setPositiveButton(android.R.string.yes, this)
+ .setNegativeButton(android.R.string.no, this)
+ .show();
+ } else {
+ mUpdateRecoveryDialog = new AlertDialog.Builder(getActivity()).setMessage(
+ getResources().getString(R.string.update_recovery_off_warning))
+ .setTitle(R.string.update_recovery_title)
+ .setPositiveButton(android.R.string.yes, this)
+ .setNegativeButton(android.R.string.no, this)
+ .show();
+ }
+ mUpdateRecoveryDialog.setOnDismissListener(this);
+ }
} else {
return super.onPreferenceTreeClick(preferenceScreen, preference);
}
} else if (preference == mSimulateColorSpace) {
writeSimulateColorSpace(newValue);
return true;
+ } else if (preference == mRootAccess) {
+ if ("0".equals(SystemProperties.get(ROOT_ACCESS_PROPERTY, "0"))
+ && !"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)
+ .setPositiveButton(android.R.string.yes, this)
+ .setNegativeButton(android.R.string.no, this).show();
+ mRootDialog.setOnDismissListener(this);
+ } else {
+ writeRootAccessOptions(newValue);
+ }
+ return true;
+ } else if (preference == mKeepScreenOn) {
+ writeStayAwakeOptions(newValue);
+ return true;
}
return false;
}
mAdbDialog.dismiss();
mAdbDialog = null;
}
+ if (mAdbTcpDialog != null) {
+ mAdbTcpDialog.dismiss();
+ mAdbTcpDialog = null;
+ }
if (mAdbKeysDialog != null) {
mAdbKeysDialog.dismiss();
mAdbKeysDialog = null;
mEnableDialog.dismiss();
mEnableDialog = null;
}
+ if (mRootDialog != null) {
+ mRootDialog.dismiss();
+ mRootDialog = null;
+ }
+ if (mUpdateRecoveryDialog != null) {
+ mUpdateRecoveryDialog.dismiss();
+ mUpdateRecoveryDialog = null;
+ }
}
public void onClick(DialogInterface dialog, int which) {
mVerifyAppsOverUsb.setEnabled(true);
updateVerifyAppsOverUsbOptions();
updateBugreportOptions();
- } else {
- // Reset the toggle
- mEnableAdb.setChecked(false);
+ }
+ } else if (dialog == mAdbTcpDialog) {
+ if (which == DialogInterface.BUTTON_POSITIVE) {
+ CMSettings.Secure.putInt(getActivity().getContentResolver(),
+ CMSettings.Secure.ADB_PORT, 5555);
}
} else if (dialog == mAdbKeysDialog) {
if (which == DialogInterface.BUTTON_POSITIVE) {
Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 1);
mLastEnabledState = true;
setPrefsEnabledState(mLastEnabledState);
+
+ // Make sure the development settings is visible in the main Settings menu
+ // This is needed since we may have just turned off dev settings and want to
+ // turn it on again
+ getActivity().getSharedPreferences(PREF_FILE, Context.MODE_PRIVATE).edit()
+ .putBoolean(PREF_SHOW, true)
+ .apply();
+ }
+ } else if (dialog == mRootDialog) {
+ if (which == DialogInterface.BUTTON_POSITIVE) {
+ writeRootAccessOptions(mSelectedRootValue);
} else {
- // Reset the toggle
- mSwitchBar.setChecked(false);
+ // Reset the option
+ writeRootAccessOptions("0");
+ }
+ } else if (dialog == mUpdateRecoveryDialog) {
+ if (which == DialogInterface.BUTTON_POSITIVE) {
+ writeUpdateRecoveryOptions();
}
}
}
mEnableAdb.setChecked(false);
}
mAdbDialog = null;
+ } else if (dialog == mAdbTcpDialog) {
+ updateAdbOverNetwork();
+ mAdbTcpDialog = null;
} else if (dialog == mEnableDialog) {
if (!mDialogClicked) {
mSwitchBar.setChecked(false);
}
mEnableDialog = null;
+ } else if (dialog == mRootDialog) {
+ updateRootAccessOptions();
+ mRootDialog = null;
+ } else if (dialog == mUpdateRecoveryDialog) {
+ updateUpdateRecoveryOptions();
+ mUpdateRecoveryDialog = null;
}
}
private BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
- updateUsbConfigurationValues();
+ boolean isUnlocked = intent.getBooleanExtra(UsbManager.USB_DATA_UNLOCKED, false);
+ updateUsbConfigurationValues(isUnlocked);
}
};
OSDN Git Service
