public String addEnableAccessibilityService(String nameService) {
    try {
      String enableSer =
          Settings.Secure.getString(
              cntx.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
      if (!enableSer.contains(nameService)) {
        // If not is enabled we activate the AccessibilityService
        // Service
        Settings.Secure.putInt(
            cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); // Enable
        // accessibility
        Settings.Secure.putString(
            cntx.getContentResolver(),
            Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES,
            nameService); // Put
        // the
        // package
        // name
        // and
        // the
        // accesibility
        // service
        Settings.Secure.putInt(
            cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); // Enable
        // accessibility
      }

      return MESSAGE_OK;
    } catch (Exception e) {
      e.printStackTrace();
      return MESSAGE_ERROR;
    }
  }
  // ensure that this accessibility service is enabled.
  // the service watches for google voice notifications to know when to check for new
  // messages.
  private void ensureEnabled() {
    Set<ComponentName> enabledServices = getEnabledServicesFromSettings();
    ComponentName me = new ComponentName(this, getClass());
    if (enabledServices.contains(me) && connected) return;

    enabledServices.add(me);

    // Update the enabled services setting.
    StringBuilder enabledServicesBuilder = new StringBuilder();
    // Keep the enabled services even if they are not installed since we
    // have no way to know whether the application restore process has
    // completed. In general the system should be responsible for the
    // clean up not settings.
    for (ComponentName enabledService : enabledServices) {
      enabledServicesBuilder.append(enabledService.flattenToString());
      enabledServicesBuilder.append(ENABLED_ACCESSIBILITY_SERVICES_SEPARATOR);
    }
    final int enabledServicesBuilderLength = enabledServicesBuilder.length();
    if (enabledServicesBuilderLength > 0) {
      enabledServicesBuilder.deleteCharAt(enabledServicesBuilderLength - 1);
    }
    Settings.Secure.putString(
        getContentResolver(),
        Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES,
        enabledServicesBuilder.toString());

    // Update accessibility enabled.
    Settings.Secure.putInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 0);
    Settings.Secure.putInt(getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1);
  }
  @Override
  public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {

    if (Utils.isMonkeyRunning()) {
      return false;
    }

    if (preference == mEnableAdb) {
      if (mEnableAdb.isChecked()) {
        mOkClicked = false;
        if (mOkDialog != null) dismissDialog();
        mOkDialog =
            new AlertDialog.Builder(getActivity())
                .setMessage(getActivity().getResources().getString(R.string.adb_warning_message))
                .setTitle(R.string.adb_warning_title)
                .setIcon(android.R.drawable.ic_dialog_alert)
                .setPositiveButton(android.R.string.yes, this)
                .setNegativeButton(android.R.string.no, this)
                .show();
        mOkDialog.setOnDismissListener(this);
      } else {
        Settings.Secure.putInt(getActivity().getContentResolver(), Settings.Secure.ADB_ENABLED, 0);
      }
    } else if (preference == mKeepScreenOn) {
      Settings.System.putInt(
          getActivity().getContentResolver(),
          Settings.System.STAY_ON_WHILE_PLUGGED_IN,
          mKeepScreenOn.isChecked()
              ? (BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB)
              : 0);
    } else if (preference == mAllowMockLocation) {
      Settings.Secure.putInt(
          getActivity().getContentResolver(),
          Settings.Secure.ALLOW_MOCK_LOCATION,
          mAllowMockLocation.isChecked() ? 1 : 0);
    } else if (preference == mStrictMode) {
      writeStrictModeVisualOptions();
    } else if (preference == mPointerLocation) {
      writePointerLocationOptions();
    } else if (preference == mShowTouches) {
      writeShowTouchesOptions();
    } else if (preference == mShowScreenUpdates) {
      writeFlingerOptions();
    } else if (preference == mShowCpuUsage) {
      writeCpuUsageOptions();
    } else if (preference == mImmediatelyDestroyActivities) {
      writeImmediatelyDestroyActivitiesOptions();
    } else if (preference == mShowAllANRs) {
      writeShowAllANRsOptions();
    } else if (preference == mForceHardwareUi) {
      writeHardwareUiOptions();
    }

    return false;
  }
  public boolean onPreferenceChange(Preference arg0, Object arg1) {

    final String key = arg0.getKey();

    if (KEY_NETWORK_MODE_SETTING.equals(key)) {

      int oldNetworkMode =
          android.provider.Settings.Secure.getInt(
              getContentResolver(), Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode);

      int newNetworkMode = Integer.valueOf((String) arg1).intValue();

      newNetworkMode = GeminiUtils.getNetworkMode(newNetworkMode);

      Settings.Secure.putInt(
          getContentResolver(), Settings.Secure.PREFERRED_NETWORK_MODE, newNetworkMode);

      if (newNetworkMode != oldNetworkMode) {

        Intent intent = new Intent(GeminiUtils.NETWORK_MODE_CHANGE_BROADCAST, null);
        intent.putExtra(GeminiUtils.OLD_NETWORK_MODE, oldNetworkMode);
        intent.putExtra(GeminiUtils.NETWORK_MODE_CHANGE_BROADCAST, newNetworkMode);
        intent.putExtra(Phone.GEMINI_SIM_ID_KEY, Phone.GEMINI_SIM_1);
        showDialog(DIALOG_NETWORK_MODE_CHANGE);
        setCancelable(false);
        getActivity().sendBroadcast(intent);
        Xlog.i(TAG, "Send broadcast of " + GeminiUtils.NETWORK_MODE_CHANGE_BROADCAST);
      }
    }
    return true;
  }
        @Override
        public void setNightMode(int mode) {
            switch (mode) {
                case UiModeManager.MODE_NIGHT_NO:
                case UiModeManager.MODE_NIGHT_YES:
                case UiModeManager.MODE_NIGHT_AUTO:
                    break;
                default:
                    throw new IllegalArgumentException("Unknown mode: " + mode);
            }

            final long ident = Binder.clearCallingIdentity();
            try {
                synchronized (mLock) {
                    if (isDoingNightModeLocked() && mNightMode != mode) {
                        Settings.Secure.putInt(getContext().getContentResolver(),
                                Settings.Secure.UI_NIGHT_MODE, mode);
                        mNightMode = mode;
                        updateLocked(0, 0);
                    }
                }
            } finally {
                Binder.restoreCallingIdentity(ident);
            }
        }
 public void stopUpdates() {
   // revert previous location settings
   final ContentResolver contentResolver = getContentResolver();
   Settings.Secure.putInt(contentResolver, Settings.Secure.LOCATION_MODE, mCurrentLocationmode);
   LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
   stopSelf();
 }
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    if (!mIsRunning) {
      final Context context = getApplicationContext();
      mIsRunning = true;
      final ContentResolver contentResolver = getContentResolver();
      try {
        mCurrentLocationmode =
            Settings.Secure.getInt(contentResolver, Settings.Secure.LOCATION_MODE);
        if (mCurrentLocationmode != Settings.Secure.LOCATION_MODE_HIGH_ACCURACY) {
          Settings.Secure.putInt(
              contentResolver,
              Settings.Secure.LOCATION_MODE,
              Settings.Secure.LOCATION_MODE_HIGH_ACCURACY);
        }
      } catch (SettingNotFoundException e) {
        Log.e(TAG, "Unable find location settings.", e);
      }
      int state = intent.getIntExtra(SERVICE_PARAM, Config.ANTITHEFT_STATE.NORMAL.getState());
      if (state == Config.ANTITHEFT_STATE.THEFT.getState()) {
        mConstantReporting = true;
      }

      buildGoogleApiClient();
    }

    if (mGoogleApiClient.isConnected()) {
      restartLocationUpdates();
    }

    return START_REDELIVER_INTENT;
  }
  public String removeEnableAccessibilityService(String nameService) {
    try {
      String enableSer =
          Settings.Secure.getString(
              cntx.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
      if (enableSer.contains(nameService)) { // check if the
        // AccessibilityService is
        // enabled
        // If is enabled we disable the AccessibilityService
        Settings.Secure.putInt(
            cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 0); // Disable
        // Accessibility
        Settings.Secure.putString(
            cntx.getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, ""); // Clear
        // the
        // enabled
        // accessibility
        // service

      } else {
        // If not is enabled we activate the AccessibilityService
        // Service
        Settings.Secure.putInt(
            cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); // Enable
        // accessibility
        Settings.Secure.putString(
            cntx.getContentResolver(),
            Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES,
            "<AccessibilityService Package>/<AccessivilityService Name>"); // Put
        // the
        // package
        // name
        // and
        // the
        // accesibility
        // service
        Settings.Secure.putInt(
            cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1); // Enable
        // accessibility
      }

      return MESSAGE_OK;
    } catch (Exception e) {
      e.printStackTrace();
      return MESSAGE_ERROR;
    }
  }
 private void handleTogglePowerButtonEndsCallPreferenceClick() {
   Settings.Secure.putInt(
       getContentResolver(),
       Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR,
       (mTogglePowerButtonEndsCallPreference.isChecked()
           ? Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_HANGUP
           : Settings.Secure.INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF));
 }
 private void saveInputMethodSelectorVisibility(String value) {
   try {
     int intValue = Integer.valueOf(value);
     Settings.Secure.putInt(
         getContentResolver(), Settings.Secure.INPUT_METHOD_SELECTOR_VISIBILITY, intValue);
     updateInputMethodSelectorSummary(intValue);
   } catch (NumberFormatException e) {
   }
 }
 public void onClick(DialogInterface dialog, int which) {
   if (which == DialogInterface.BUTTON_POSITIVE) {
     mOkClicked = true;
     Settings.Secure.putInt(getActivity().getContentResolver(), Settings.Secure.ADB_ENABLED, 1);
   } else {
     // Reset the toggle
     mEnableAdb.setChecked(false);
   }
 }
  private void toggleTouchpad() {
    mTouchpadEnabled = !mTouchpadEnabled;
    nativeToggleTouchpad(mTouchpadEnabled);

    int enabled = mTouchpadEnabled ? 1 : 0;
    Settings.Secure.putInt(mContext.getContentResolver(), SETTING_TOUCHPAD_STATUS, enabled);

    notifyKey(ASUSDEC_TOUCHPAD, mTouchpadEnabled ? ASUSDEC_STATUS_ON : ASUSDEC_STATUS_OFF);
  }
  public String enableTouchMode(String enable) {
    try {

      if (Settings.Secure.getString(
              cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED)
          .contains("1")) { // The
        // accessibility
        // should
        // be
        // enable
        if (enable.equalsIgnoreCase("0")) { // Check if touch
          // exploration is
          // enabled
          Settings.Secure.putInt(
              cntx.getContentResolver(), Settings.Secure.TOUCH_EXPLORATION_ENABLED, 0); // disable
          // the
          // touch
          // exploration
          Log.d(
              tag,
              "touch exploration:  "
                  + Settings.Secure.getString(
                      cntx.getContentResolver(), Settings.Secure.TOUCH_EXPLORATION_ENABLED));

        } else if (enable.equalsIgnoreCase("1")) {
          Settings.Secure.putInt(
              cntx.getContentResolver(), Settings.Secure.TOUCH_EXPLORATION_ENABLED, 1); // enable
          // the
          // touch
          // exploration
          Log.d(
              tag,
              "touch exploration:  "
                  + Settings.Secure.getString(
                      cntx.getContentResolver(), Settings.Secure.TOUCH_EXPLORATION_ENABLED));
        }
      }
      return MESSAGE_OK;
    } catch (Exception e) {

      e.printStackTrace();
      return MESSAGE_ERROR;
    }
  }
 @Override
 public void onSharedPreferenceChanged(SharedPreferences arg0, String arg1) {
   // TODO Auto-generated method stub
   final int val = arg0.getInt(Prefs.TICKER_TIME_PREF, Prefs.TICKER_TIME_DEFAULT);
   if (val != mTickerTime) {
     mTickerTime = val;
   }
   WGUtil.LogD(TAG, "---------ret=" + val);
   Settings.Secure.putInt(mContext.getContentResolver(), Prefs.TICKER_TIME_PREF, val);
 }
 @Override
 public boolean onPreferenceChange(Preference preference, Object newValue) {
   if (preference == mPrivacyGuardDefault) {
     boolean value = (Boolean) newValue;
     Settings.Secure.putInt(
         getContentResolver(), Settings.Secure.PRIVACY_GUARD_DEFAULT, value ? 1 : 0);
     return true;
   }
   return false;
 }
  public String setPitchTTS(String pitch) {
    try {
      int p = Integer.parseInt(pitch);
      if (p >= 0 && p <= 500) {
        Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.TTS_DEFAULT_PITCH, p);

        Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 0);

        Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1);
      } else {
        Log.d(tag, "Pitch param: value not valid ");
        return MESSAGE_ERROR;
      }
      return MESSAGE_OK;
    } catch (Exception e) {
      e.printStackTrace();
      return MESSAGE_ERROR;
    }
  }
  @Override
  public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {

    if (Utils.isMonkeyRunning()) {
      return false;
    }

    if (preference == mEnableAdb) {
      if (mEnableAdb.isChecked()) {
        mOkClicked = false;
        if (mOkDialog != null) dismissDialog();
        mOkDialog =
            new AlertDialog.Builder(this)
                .setMessage(getResources().getString(R.string.adb_warning_message))
                .setTitle(R.string.adb_warning_title)
                .setIcon(android.R.drawable.ic_dialog_alert)
                .setPositiveButton(android.R.string.yes, this)
                .setNegativeButton(android.R.string.no, this)
                .show();
        mOkDialog.setOnDismissListener(this);
      } else {
        Settings.Secure.putInt(getContentResolver(), Settings.Secure.ADB_ENABLED, 0);
        SystemProperties.set("persist.service.adb.enable", "0");
      }
    } else if (preference == mAdbNotify) {
      Settings.Secure.putInt(
          getContentResolver(), Settings.Secure.ADB_NOTIFY, mAdbNotify.isChecked() ? 1 : 0);
    } else if (preference == mKeepScreenOn) {
      Settings.System.putInt(
          getContentResolver(),
          Settings.System.STAY_ON_WHILE_PLUGGED_IN,
          mKeepScreenOn.isChecked()
              ? (BatteryManager.BATTERY_PLUGGED_AC | BatteryManager.BATTERY_PLUGGED_USB)
              : 0);
    } else if (preference == mAllowMockLocation) {
      Settings.Secure.putInt(
          getContentResolver(),
          Settings.Secure.ALLOW_MOCK_LOCATION,
          mAllowMockLocation.isChecked() ? 1 : 0);
    }

    return false;
  }
 public void onClick(DialogInterface dialog, int which) {
   if (which == DialogInterface.BUTTON_POSITIVE) {
     mOkClicked = true;
     Settings.Secure.putInt(getContentResolver(), Settings.Secure.ADB_ENABLED, 1);
     SystemProperties.set("persist.service.adb.enable", "1");
   } else {
     // Reset the toggle
     mEnableAdb.setChecked(false);
   }
 }
  @Override
  public boolean onPreferenceChange(Preference preference, Object objValue) {

    // kill-app long press back
    if (preference == mKillAppLongPressBack) {
      boolean value = (Boolean) objValue;
      Settings.Secure.putInt(resolver, KILL_APP_LONGPRESS_BACK, value ? 1 : 0);
      return true;
    }
    return false;
  }
  public String setRateTTS(String rate) {
    try {

      int r = Integer.parseInt(rate);
      if (r >= 0 && r <= 500) {
        Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.TTS_DEFAULT_RATE, r);

        Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 0);

        Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, 1);
      } else {
        Log.d(tag, "Rate param: value not valid ");
        return MESSAGE_ERROR;
      }
      return MESSAGE_OK;
    } catch (Exception e) {
      e.printStackTrace();
      return MESSAGE_ERROR;
    }
  }
 private void resetNetworkModeToDefault() {
   android.provider.Settings.Secure.putInt(
       getPhone().getContext().getContentResolver(),
       android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
       Settings.preferredNetworkMode);
   // Set the Modem
   getPhone()
       .setPreferredNetworkType(
           Settings.preferredNetworkMode,
           this.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
 }
 public boolean onPreferenceChange(Preference preference, Object newValue) {
   if (preference == mSelectLongPressTimeoutPreference) {
     String stringValue = (String) newValue;
     Settings.Secure.putInt(
         getContentResolver(), Settings.Secure.LONG_PRESS_TIMEOUT, Integer.parseInt(stringValue));
     mSelectLongPressTimeoutPreference.setSummary(
         mLongPressTimeoutValuetoTitleMap.get(stringValue));
     return true;
   }
   return false;
 }
 public String enableAccessibility(String accesibility) {
   try {
     int e = Integer.parseInt(accesibility);
     if (e == 0 || e == 1) {
       Settings.Secure.putInt(cntx.getContentResolver(), Settings.Secure.ACCESSIBILITY_ENABLED, e);
     }
     return MESSAGE_OK;
   } catch (Exception e) {
     e.printStackTrace();
     return MESSAGE_ERROR;
   }
 }
    @Override
    public void onPreferenceToggled(String preferenceKey, boolean enabled) {
      // Parse the enabled services.
      Set<ComponentName> enabledServices = getEnabledServicesFromSettings(getActivity());

      // Determine enabled services and accessibility state.
      ComponentName toggledService = ComponentName.unflattenFromString(preferenceKey);
      final boolean accessibilityEnabled;
      if (enabled) {
        // Enabling at least one service enables accessibility.
        accessibilityEnabled = true;
        enabledServices.add(toggledService);
      } else {
        // Check how many enabled and installed services are present.
        int enabledAndInstalledServiceCount = 0;
        Set<ComponentName> installedServices = sInstalledServices;
        for (ComponentName enabledService : enabledServices) {
          if (installedServices.contains(enabledService)) {
            enabledAndInstalledServiceCount++;
          }
        }
        // Disabling the last service disables accessibility.
        accessibilityEnabled =
            enabledAndInstalledServiceCount > 1
                || (enabledAndInstalledServiceCount == 1
                    && !installedServices.contains(toggledService));
        enabledServices.remove(toggledService);
      }

      // Update the enabled services setting.
      StringBuilder enabledServicesBuilder = new StringBuilder();
      // Keep the enabled services even if they are not installed since we have
      // no way to know whether the application restore process has completed.
      // In general the system should be responsible for the clean up not settings.
      for (ComponentName enabledService : enabledServices) {
        enabledServicesBuilder.append(enabledService.flattenToString());
        enabledServicesBuilder.append(ENABLED_ACCESSIBILITY_SERVICES_SEPARATOR);
      }
      final int enabledServicesBuilderLength = enabledServicesBuilder.length();
      if (enabledServicesBuilderLength > 0) {
        enabledServicesBuilder.deleteCharAt(enabledServicesBuilderLength - 1);
      }
      Settings.Secure.putString(
          getContentResolver(),
          Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES,
          enabledServicesBuilder.toString());

      // Update accessibility enabled.
      Settings.Secure.putInt(
          getContentResolver(),
          Settings.Secure.ACCESSIBILITY_ENABLED,
          accessibilityEnabled ? 1 : 0);
    }
 @Override
 protected boolean persistBoolean(boolean value) {
   if (shouldPersist()) {
     if (value == getPersistedBoolean(!value)) {
       // It's already there, so the same as persisting
       return true;
     }
     Settings.Secure.putInt(getContext().getContentResolver(), getKey(), value ? 1 : 0);
     return true;
   }
   return false;
 }
        @Override
        public void onReceive(Context context, Intent intent) {

          String action = intent.getAction();

          if (action.equals(TelephonyIntents.ACTION_SIM_INDICATOR_STATE_CHANGED)) {

            int slotId = intent.getIntExtra(TelephonyIntents.INTENT_KEY_ICC_SLOT, -1);
            int simStatus = intent.getIntExtra(TelephonyIntents.INTENT_KEY_ICC_STATE, -1);
            Xlog.i(TAG, "receive notification of  sim slot = " + slotId + " status = " + simStatus);

            if ((slotId == Phone.GEMINI_SIM_1) && (simStatus >= 0)) {
              mNetworkMode.setStatus(simStatus);
            }

          } else if (action.equals(GeminiUtils.NETWORK_MODE_CHANGE_RESPONSE)) {

            if (!intent.getBooleanExtra(GeminiUtils.NETWORK_MODE_CHANGE_RESPONSE, true)) {
              Xlog.i(TAG, "BroadcastReceiver: network mode change failed! restore the old value.");
              android.provider.Settings.Secure.putInt(
                  getContentResolver(),
                  android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
                  intent.getIntExtra(OLD_NETWORK_MODE, 0));
            } else {
              Xlog.i(TAG, "BroadcastReceiver: network mode change succeed! set the new value.");
              android.provider.Settings.Secure.putInt(
                  getContentResolver(),
                  android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
                  intent.getIntExtra(GeminiUtils.NEW_NETWORK_MODE, 0));
            }

            if (isDialogShowing(DIALOG_NETWORK_MODE_CHANGE)) {
              removeDialog(DIALOG_NETWORK_MODE_CHANGE);
            }
          }
        }
 @Override
 public void onPreferenceToggled(String preferenceKey, boolean enabled) {
   Settings.Secure.putInt(
       getContentResolver(), Settings.Secure.TOUCH_EXPLORATION_ENABLED, enabled ? 1 : 0);
   if (enabled) {
     SharedPreferences preferences = getActivity().getPreferences(Context.MODE_PRIVATE);
     final boolean launchAccessibilityTutorial =
         !preferences.getBoolean(KEY_ACCESSIBILITY_TUTORIAL_LAUNCHED_ONCE, false);
     if (launchAccessibilityTutorial) {
       preferences.edit().putBoolean(KEY_ACCESSIBILITY_TUTORIAL_LAUNCHED_ONCE, true).commit();
       Intent intent = new Intent(AccessibilityTutorialActivity.ACTION);
       getActivity().startActivity(intent);
     }
   }
 }
  @Override
  public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
    if (preference == menuButtonLocation) {
      Settings.System.putInt(
          getActivity().getContentResolver(),
          Settings.System.LOCKSCREEN_ENABLE_MENU_KEY,
          ((CheckBoxPreference) preference).isChecked() ? 1 : 0);
      return true;
    } else if (preference == mLockScreenTimeoutUserOverride) {
      Settings.Secure.putInt(
          getActivity().getContentResolver(),
          Settings.Secure.LOCK_SCREEN_LOCK_USER_OVERRIDE,
          ((CheckBoxPreference) preference).isChecked() ? 1 : 0);
      return true;

    } else if (preference == mLockscreenBattery) {

      Settings.System.putInt(
          getActivity().getContentResolver(),
          Settings.System.LOCKSCREEN_BATTERY,
          ((CheckBoxPreference) preference).isChecked() ? 1 : 0);
      return true;

    } else if (preference == mVolumeWake) {

      Settings.System.putInt(
          getActivity().getContentResolver(),
          Settings.System.VOLUME_WAKE_SCREEN,
          ((CheckBoxPreference) preference).isChecked() ? 1 : 0);
      return true;
    } else if (preference == mVolumeMusic) {

      Settings.System.putInt(
          getActivity().getContentResolver(),
          Settings.System.VOLUME_MUSIC_CONTROLS,
          ((CheckBoxPreference) preference).isChecked() ? 1 : 0);
      return true;

    } else if (keys.contains(preference.getKey())) {
      Log.e("RC_Lockscreens", "key: " + preference.getKey());
      return Settings.System.putInt(
          getActivity().getContentResolver(),
          preference.getKey(),
          ((CheckBoxPreference) preference).isChecked() ? 1 : 0);
    }

    return super.onPreferenceTreeClick(preferenceScreen, preference);
  }
  /** returns true on success, false if the user must correct something */
  boolean saveToDb() {

    String hostname = mHostnameField.getText().toString().trim();
    String portStr = mPortField.getText().toString().trim();
    int port = -1;

    int result = validate(hostname, portStr);
    if (result > 0) {
      showError(result);
      return false;
    }

    if (portStr.length() > 0) {
      try {
        port = Integer.parseInt(portStr);
      } catch (NumberFormatException ex) {
        return false;
      }
    }

    // FIXME: The best solution would be to make a better UI that would
    // disable editing of the text boxes if the user chooses to use the
    // default settings. i.e. checking a box to always use the default
    // carrier. http:/b/issue?id=756480
    // FIXME: This currently will not work if the default host is blank and
    // the user has cleared the input boxes in order to not use a proxy.
    // This is a UI problem and can be solved with some better form
    // controls.
    // FIXME: If the user types in a proxy that matches the default, should
    // we keep that setting? Can be fixed with a new UI.
    ContentResolver res = getContentResolver();
    if (hostname.equals(Proxy.getDefaultHost()) && port == Proxy.getDefaultPort()) {
      // If the user hit the default button and didn't change any of
      // the input boxes, treat it as if the user has not specified a
      // proxy.
      hostname = null;
    }

    if (!TextUtils.isEmpty(hostname)) {
      hostname += ':' + portStr;
    }
    Settings.Secure.putString(res, Settings.Secure.HTTP_PROXY, hostname);
    Settings.Secure.putInt(
        res, Settings.Secure.HTTP_PROXY_WIFI_ONLY, mProxyWifiOnly.isChecked() ? 1 : 0);
    sendBroadcast(new Intent(Proxy.PROXY_CHANGE_ACTION));

    return true;
  }
 public boolean setPriority(BluetoothDevice device, int priority) {
   enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
   synchronized (BluetoothHeadsetService.this) {
     if (!BluetoothAdapter.checkBluetoothAddress(device.getAddress())) {
       return false;
     }
     if (priority < BluetoothHeadset.PRIORITY_OFF) {
       return false;
     }
     Settings.Secure.putInt(
         getContentResolver(),
         Settings.Secure.getBluetoothHeadsetPriorityKey(device.getAddress()),
         priority);
     if (DBG) log("Saved priority " + device + " = " + priority);
     return true;
   }
 }