How to do opposite of of preference attribute android:dependency?

Is there XML attribute that does the exact opposite of android:dependency?

What I would like the dependent preference to be enabled when the other is NOT checked and disabled when it IS checked.

edit: maybe the issue isn't with android:dependency maybe there is an xml attribute that I can add to make the default for that preference disabled and then android:dependency will toggle it the opposite way like i want.

edit again: I tried setting android:enabled="false" in the preference and it disables it like i want but even with it being dependent on the other preference it didn't enable it like i had hoped

Actually found it on my own and figured I'd just post it here to help anyone that might have this same issue:

android:disableDependentsState="true"

Put that in the controlling preference.

Dmytro Zarezenko asked what if you wanted some dependencies to be enabled when the preference on which they depend is true and some to be enabled when that preference is false.

Use the method described above to set the all the dependant preferences of one type (which ever have the greater number). Then (with the class having implements OnSharedPreferenceChangeListener) have code like this in the Preference Activity and/or Preference Fragment:

@Override
public void onResume()
{
    super.onResume();
    sharedPreferences.registerOnSharedPreferenceChangeListener(this);
}
@Override
public void onPause()
{
    super.onPause();
    sharedPreferences.unregisterOnSharedPreferenceChangeListener(this);
}
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
{
    if (key.equals("pref_that_they_depend-upon")
    {
        // Iterate over the preferences that need to be enabled or disabled,
        // lets say there is just one called the_awkward_one.
        Preference preference = findPreference("the_awkward_one");
        // Or preference.setEnabled(! sharedPreferences.getBoolean(("pref_that_they_depend-upon", defaultValue));
        preference.setEnabled(sharedPreferences.getBoolean(("pref_that_they_depend-upon", defaultValue));
    }
}
        
        

This is my code sample for doing this from code and not XML.

  String eitherKey = "either";
  String orKey = "or";
  CheckBoxPreference either = new CheckBoxPreference(this);
  either.setKey(eitherKey);
  either.setTitle("Either");
  either.setSummary("It is either one or");
  either.setDefaultValue(false);
  either.setDisableDependentsState(true);
  inlinePrefCat.addPreference(either);
  
  try
  {
     //Crossfade Time
     CheckBoxPreference or = new CheckBoxPreference(this);
     or.setKey(orKey);
     or.setTitle("Or");
     or.setSummary("the other");
     inlinePrefCat.addPreference(or);
     or.setDependency(eitherKey);
  }
  catch (Exception e)
  {
  }

I need to change value of dependent preference, so i post my code below, if anyone wants to do this:

@Override
public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
	if(preference.getKey().equals("key_a")) {
		((CheckBoxPreference)findPreference("key_b").setChecked(false);
	}
	return super.onPreferenceTreeClick(preferenceScreen, preference);
}

Make your PreferenceActivity implement

SharedPreferences.OnSharedPreferenceChangeListener

declare in PreferenceActivity:

SharedPreferences prefs;

initialize in onCreate:

SharedPreferences sPrefs = PreferenceManager.getDefaultSharedPreferences(this); prefs = sPrefs;

and register on shared preference change listener

prefs.registerOnSharedPreferenceChangeListener(this);

do the same as Steve said in onResume and onPause methods.

implementation of onSharedPreferenceChanged listener:

@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
	Log.d("SettingsActivity","onSharedPreferenceChanged LISTENER FIRED");
	if (key.equals(getString(R.string.key_call))) {
		//if call true
		if (sharedPreferences.getBoolean(getString(R.string.key_call), false)) {
			Preference preference = findPreference(getString(R.string.key_record));
			preference.setEnabled(false);
		} else { // if call false
			Preference preference = findPreference(getString(R.string.key_record));
			preference.setEnabled(true);
		}
	}
	if (key.equals(getString(R.string.key_record))) {
		//if record true
		if (sharedPreferences.getBoolean(getString(R.string.key_record), false)) {
			Preference preference = findPreference(getString(R.string.key_call));
			preference.setEnabled(false);
		} else { // if record false
			Preference preference = findPreference(getString(R.string.key_call));
			preference.setEnabled(true);
		}
	}
}

In this case, I have 2 mutually exclusive Preferences in PreferenceActivity. Call and Record. When both are unchecked, both can be checked, but as user checks one of them, the other becomes disabled (greyed out). As user unchecks the checked preference, the user can check the other one.

On both of them other preferences can depend and that can be worked out with android:dependancy attribute in XML file.