¿Cómo se muestra el valor actual de una Preferencia de Android en el resumen de Preferencias?

Esto debe aparecer muy a menudo.

Cuando el usuario está editando preferencias en una aplicación de Android, me gustaría que puedan ver el valor actualmente establecido de la preferencia en el resumen de Preference .

Ejemplo: si tengo una configuración de Preferencia para “Descartar mensajes antiguos” que especifica el número de días después de los cuales los mensajes deben ser limpiados. En PreferenceActivity me gustaría que el usuario vea:

“Descartar mensajes antiguos” <- título

“Limpiar mensajes después de x días” <- resumen donde x es el valor de Preferencia actual

Crédito adicional: haga esto reutilizable, así que puedo aplicarlo fácilmente a todas mis preferencias independientemente de su tipo (para que funcione con EditTextPreference, ListPreference, etc. con una cantidad mínima de encoding).

Hay formas de hacer que esta sea una solución más genérica, si es que se adapta a sus necesidades.

Por ejemplo, si desea genéricamente tener todas las preferencias de la lista para mostrar su elección como un resumen, puede tener esto para su implementación onSharedPreferenceChanged :

 public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { Preference pref = findPreference(key); if (pref instanceof ListPreference) { ListPreference listPref = (ListPreference) pref; pref.setSummary(listPref.getEntry()); } } 

Esto es fácilmente extensible a otras clases de preferencia.

Y al usar las funciones getPreferenceCount y getPreference en PreferenceScreen y PreferenceCategory , puede escribir fácilmente una función genérica para recorrer el árbol de preferencias configurando los resúmenes de todas las preferencias de los tipos que desea a su representación de toString

Aquí está mi solución … FWIW

 package com.example.PrefTest; import android.content.SharedPreferences; import android.content.SharedPreferences.OnSharedPreferenceChangeListener; import android.os.Bundle; import android.preference.EditTextPreference; import android.preference.ListPreference; import android.preference.Preference; import android.preference.PreferenceActivity; import android.preference.PreferenceGroup; import android.preference.PreferenceManager; public class Preferences extends PreferenceActivity implements OnSharedPreferenceChangeListener { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); PreferenceManager.setDefaultValues(Preferences.this, R.xml.preferences, false); initSummary(getPreferenceScreen()); } @Override protected void onResume() { super.onResume(); // Set up a listener whenever a key changes getPreferenceScreen().getSharedPreferences() .registerOnSharedPreferenceChangeListener(this); } @Override protected void onPause() { super.onPause(); // Unregister the listener whenever a key changes getPreferenceScreen().getSharedPreferences() .unregisterOnSharedPreferenceChangeListener(this); } public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { updatePrefSummary(findPreference(key)); } private void initSummary(Preference p) { if (p instanceof PreferenceGroup) { PreferenceGroup pGrp = (PreferenceGroup) p; for (int i = 0; i < pGrp.getPreferenceCount(); i++) { initSummary(pGrp.getPreference(i)); } } else { updatePrefSummary(p); } } private void updatePrefSummary(Preference p) { if (p instanceof ListPreference) { ListPreference listPref = (ListPreference) p; p.setSummary(listPref.getEntry()); } if (p instanceof EditTextPreference) { EditTextPreference editTextPref = (EditTextPreference) p; if (p.getTitle().toString().toLowerCase().contains("password")) { p.setSummary("******"); } else { p.setSummary(editTextPref.getText()); } } if (p instanceof MultiSelectListPreference) { EditTextPreference editTextPref = (EditTextPreference) p; p.setSummary(editTextPref.getText()); } } } 

La documentación de Android dice que uno puede usar un marcador de formato de cadena en getSummary() :

Si el resumen tiene un marcador de formato de cadena (es decir, “% s” o “% 1 $ s”), el valor de la entrada actual se sustituirá en su lugar.

Simplemente especificando android:summary="Clean up messages after %s days" en la statement xml ListPreference funcionó para mí.

Nota: Esto solo funciona para ListPreference .

Si usa PreferenceFragment , así es como lo resolví. Es auto explicativo.

 public static class SettingsFragment extends PreferenceFragment implements OnSharedPreferenceChangeListener { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.settings); getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this); } @Override public void onResume() { super.onResume(); for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); ++i) { Preference preference = getPreferenceScreen().getPreference(i); if (preference instanceof PreferenceGroup) { PreferenceGroup preferenceGroup = (PreferenceGroup) preference; for (int j = 0; j < preferenceGroup.getPreferenceCount(); ++j) { Preference singlePref = preferenceGroup.getPreference(j); updatePreference(singlePref, singlePref.getKey()); } } else { updatePreference(preference, preference.getKey()); } } } @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { updatePreference(findPreference(key), key); } private void updatePreference(Preference preference, String key) { if (preference == null) return; if (preference instanceof ListPreference) { ListPreference listPreference = (ListPreference) preference; listPreference.setSummary(listPreference.getEntry()); return; } SharedPreferences sharedPrefs = getPreferenceManager().getSharedPreferences(); preference.setSummary(sharedPrefs.getString(key, "Default")); } } 

Mi opción es extender ListPreference y está limpio:

 public class ListPreferenceShowSummary extends ListPreference { private final static String TAG = ListPreferenceShowSummary.class.getName(); public ListPreferenceShowSummary(Context context, AttributeSet attrs) { super(context, attrs); init(); } public ListPreferenceShowSummary(Context context) { super(context); init(); } private void init() { setOnPreferenceChangeListener(new OnPreferenceChangeListener() { @Override public boolean onPreferenceChange(Preference arg0, Object arg1) { arg0.setSummary(getEntry()); return true; } }); } @Override public CharSequence getSummary() { return super.getEntry(); } } 

Luego agregas en tu settings.xml:

  

Puede anular las clases predeterminadas de Preferencia e implementar la característica.

 public class MyListPreference extends ListPreference { public MyListPreference(Context context) { super(context); } public MyListPreference(Context context, AttributeSet attrs) { super(context, attrs); } @Override public void setValue(String value) { super.setValue(value); setSummary(getEntry()); } } 

Más tarde en usted xml puede usar preferencias personalizadas como

  

Después de varias horas que he pasado para resolver ese problema, he implementado este código:

[ACTUALIZACIÓN: el listado de la versión final]

 public class MyPreferencesActivity extends PreferenceActivity { ... ListPreference m_updateList; ... @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); m_updateList = (ListPreference) findPreference(getString(R.string.pref_update_interval_key)); String currentValue = m_updateList.getValue(); if (currentValue == null) { m_updateList.setValue((String)m_updateList.getEntryValues()[DEFAULT_UPDATE_TIME_INDEX]); currentValue = m_updateList.getValue(); } updateListSummary(currentValue); m_updateList.setOnPreferenceChangeListener(new OnPreferenceChangeListener() { @Override public boolean onPreferenceChange(Preference preference, Object newValue) { updateListSummary(newValue.toString()); return true; } }); } private void updateListSummary(String newValue) { int index = m_updateList.findIndexOfValue(newValue); CharSequence entry = m_updateList.getEntries()[index]; m_updateList.setSummary(entry); } } 

Esa fue la única solución que funcionó bien para mí. Antes he intentado crear una subclase desde ListPreferences e implementar android: summary = “bla bla bla% s”. Ninguno funcionó.

Este es el código que necesita para establecer el resumen al valor elegido. También establece los valores al inicio y respeta los valores predeterminados, no solo en el cambio. Simplemente cambie “R.layout.prefs” a su archivo xml y extienda el método setSummary según sus necesidades. En realidad, solo está manejando ListPreferences, pero es fácil de personalizar para respetar otras Preferencias.

 package de.koem.timetunnel; import android.content.SharedPreferences; import android.content.SharedPreferences.OnSharedPreferenceChangeListener; import android.os.Bundle; import android.preference.ListPreference; import android.preference.Preference; import android.preference.PreferenceActivity; import android.preference.PreferenceGroup; public class Prefs extends PreferenceActivity implements OnSharedPreferenceChangeListener { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); this.addPreferencesFromResource(R.layout.prefs); this.initSummaries(this.getPreferenceScreen()); this.getPreferenceScreen().getSharedPreferences() .registerOnSharedPreferenceChangeListener(this); } /** * Set the summaries of all preferences */ private void initSummaries(PreferenceGroup pg) { for (int i = 0; i < pg.getPreferenceCount(); ++i) { Preference p = pg.getPreference(i); if (p instanceof PreferenceGroup) this.initSummaries((PreferenceGroup) p); // recursion else this.setSummary(p); } } /** * Set the summaries of the given preference */ private void setSummary(Preference pref) { // react on type or key if (pref instanceof ListPreference) { ListPreference listPref = (ListPreference) pref; pref.setSummary(listPref.getEntry()); } } /** * used to change the summary of a preference */ public void onSharedPreferenceChanged(SharedPreferences sp, String key) { Preference pref = findPreference(key); this.setSummary(pref); } // private static final String LOGTAG = "Prefs"; } 

koem

Tal vez como ListPreference: modifique getSummary para obtener lo que desea:

 package your.package.preference; import android.content.Context; import android.util.AttributeSet; public class EditTextPreference extends android.preference.EditTextPreference{ public EditTextPreference(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public EditTextPreference(Context context, AttributeSet attrs) { super(context, attrs); } public EditTextPreference(Context context) { super(context); } @Override public CharSequence getSummary() { if(super.getSummary() == null) return null; String summary = super.getSummary().toString(); return String.format(summary, getText()); } } 

Y usa esto en tu xml:

  

Entonces puede escribir un resumen con %s lugar del valor real.

En realidad, CheckBoxPreference tiene la capacidad de especificar un resumen diferente basado en el valor de la checkbox. Vea los atributos de android: summaryOff y android: summaryOn (así como los métodos correspondientes de CheckBoxPreference).

Para EditTextPreference:

 public class MyEditTextPreference extends EditTextPreference { public MyEditTextPreference(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public MyEditTextPreference(Context context, AttributeSet attrs) { super(context, attrs); } @Override public void setText(String text) { super.setText(text); setSummary(text); } } 

Si alguien todavía está buscando respuestas a esto, debe verificar la respuesta de treinta y tres años .

  

Android reemplazará% s con el valor de cadena actual de la preferencia, tal como se muestra en el selector de ListPreference.

Gracias por este consejo!

Tengo una pantalla de preferencias y quiero mostrar el valor de cada preferencia de lista como el resumen.

Este es mi camino ahora:

 public class Preferences extends PreferenceActivity implements OnSharedPreferenceChangeListener { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); } @Override protected void onResume() { super.onResume(); // Set up initial values for all list preferences Map sharedPreferencesMap = getPreferenceScreen().getSharedPreferences().getAll(); Preference pref; ListPreference listPref; for (Map.Entry entry : sharedPreferencesMap.entrySet()) { pref = findPreference(entry.getKey()); if (pref instanceof ListPreference) { listPref = (ListPreference) pref; pref.setSummary(listPref.getEntry()); } } // Set up a listener whenever a key changes getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this); } @Override protected void onPause() { super.onPause(); // Unregister the listener whenever a key changes getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this); } public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { Preference pref = findPreference(key); if (pref instanceof ListPreference) { ListPreference listPref = (ListPreference) pref; pref.setSummary(listPref.getEntry()); } } 

Esto funciona para mí, pero me pregunto cuál es la mejor solución (rendimiento, estabilidad, escalabilidad): ¿la que está mostrando Koem o esta?

Gracias, Reto, por la explicación detallada!

En caso de que sea de alguna ayuda para alguien, tuve que cambiar el código propuesto por Reto Meier para que funcione con el SDK para Android 1.5.

 @Override protected void onResume() { super.onResume(); // Setup the initial values mListPreference.setSummary("Current value is " + mListPreference.getEntry().toString()); // Set up a listener whenever a key changes ... } 

Se aplica el mismo cambio para la función de callback onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)

Aclamaciones,

Chris

Resolví el problema con el siguiente descendiente de ListPreference:

 public class EnumPreference extends ListPreference { public EnumPreference(Context aContext, AttributeSet attrs) { super(aContext,attrs); } @Override protected View onCreateView(ViewGroup parent) { setSummary(getEntry()); return super.onCreateView(parent); } @Override protected boolean persistString(String aNewValue) { if (super.persistString(aNewValue)) { setSummary(getEntry()); notifyChanged(); return true; } else { return false; } } } 

Parece funcionar bien para mí en 1.6 hasta 4.0.4.

 public class ProfileManagement extends PreferenceActivity implements OnPreferenceChangeListener { EditTextPreference screenName; ListPreference sex; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.layout.profile_management); screenName = (EditTextPreference) findPreference("editTextPref"); sex = (ListPreference) findPreference("sexSelector"); screenName.setOnPreferenceChangeListener(this); sex.setOnPreferenceChangeListener(this); } @Override public boolean onPreferenceChange(Preference preference, Object newValue) { preference.setSummary(newValue.toString()); return true; } } 

He visto todas las respuestas votadas cómo configurar el resumen con el valor actual exacto, pero el OP también quería algo como:

“Limpiar mensajes después de x días” * <- resumen donde x es el valor de Preferencia actual

Aquí está mi respuesta para lograr eso

Como dice la documentación sobre ListPreference.getSummary() :

Devuelve el resumen de esta ListPreference. Si el resumen tiene un marcador de formato de cadena (es decir, “% s” o “% 1 $ s”), el valor de la entrada actual se sustituirá en su lugar.

Sin embargo, probé en varios dispositivos y parece que no funciona. Con algunas investigaciones, encontré una buena solución en esta respuesta . Simplemente consiste en extender cada Preference que use y anular getSummary() para que funcione según lo especificado por la documentación de Android.

Si solo desea mostrar el valor de texto sin formato de cada campo como su resumen, el siguiente código debería ser el más fácil de mantener. Requiere solo dos cambios (líneas 13 y 21, marcados con “cambiar aquí”):

 package com.my.package; import android.content.SharedPreferences; import android.content.SharedPreferences.OnSharedPreferenceChangeListener; import android.os.Bundle; import android.preference.EditTextPreference; import android.preference.ListPreference; import android.preference.Preference; import android.preference.PreferenceActivity; public class PreferencesActivity extends PreferenceActivity implements OnSharedPreferenceChangeListener { private final String[] mAutoSummaryFields = { "pref_key1", "pref_key2", "pref_key3" }; // change here private final int mEntryCount = mAutoSummaryFields.length; private Preference[] mPreferenceEntries; @SuppressWarnings("deprecation") @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences_file); // change here mPreferenceEntries = new Preference[mEntryCount]; for (int i = 0; i < mEntryCount; i++) { mPreferenceEntries[i] = getPreferenceScreen().findPreference(mAutoSummaryFields[i]); } } @SuppressWarnings("deprecation") @Override protected void onResume() { super.onResume(); for (int i = 0; i < mEntryCount; i++) { updateSummary(mAutoSummaryFields[i]); // initialization } getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this); // register change listener } @SuppressWarnings("deprecation") @Override protected void onPause() { super.onPause(); getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this); // unregister change listener } private void updateSummary(String key) { for (int i = 0; i < mEntryCount; i++) { if (key.equals(mAutoSummaryFields[i])) { if (mPreferenceEntries[i] instanceof EditTextPreference) { final EditTextPreference currentPreference = (EditTextPreference) mPreferenceEntries[i]; mPreferenceEntries[i].setSummary(currentPreference.getText()); } else if (mPreferenceEntries[i] instanceof ListPreference) { final ListPreference currentPreference = (ListPreference) mPreferenceEntries[i]; mPreferenceEntries[i].setSummary(currentPreference.getEntry()); } break; } } } public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { updateSummary(key); } } 

Aquí está mi solución:

Cree un método de preferencia ‘getter’.

 protected String getPreference(Preference x) { // http://stackoverflow.com/questions/3993982/how-to-check-type-of-variable-in-java if (x instanceof CheckBoxPreference) return "CheckBoxPreference"; else if (x instanceof EditTextPreference) return "EditTextPreference"; else if (x instanceof ListPreference) return "ListPreference"; else if (x instanceof MultiSelectListPreference) return "MultiSelectListPreference"; else if (x instanceof RingtonePreference) return "RingtonePreference"; else if (x instanceof SwitchPreference) return "SwitchPreference"; else if (x instanceof TwoStatePreference) return "TwoStatePreference"; else if (x instanceof DialogPreference) // Needs to be after ListPreference return "DialogPreference"; else return "undefined"; } 

Cree un método ‘setSummaryInit’.

 public void onSharedPreferenceChanged(SharedPreferences prefs, String key) { Log.i(TAG, "+ onSharedPreferenceChanged(prefs:" + prefs + ", key:" + key + ")"); if( key != null ) { updatePreference(prefs, key); setSummary(key); } else { Log.e(TAG, "Preference without key!"); } Log.i(TAG, "- onSharedPreferenceChanged()"); } protected boolean setSummary() { return _setSummary(null); } protected boolean setSummary(String sKey) { return _setSummary(sKey); } private boolean _setSummary(String sKey) { if (sKey == null) Log.i(TAG, "Initializing"); else Log.i(TAG, sKey); // Get Preferences SharedPreferences sharedPrefs = PreferenceManager .getDefaultSharedPreferences(this); // Iterate through all Shared Preferences // http://stackoverflow.com/questions/9310479/how-to-iterate-through-all-keys-of-shared-preferences Map keys = sharedPrefs.getAll(); for (Map.Entry entry : keys.entrySet()) { String key = entry.getKey(); // Do work only if initializing (null) or updating specific preference key if ( (sKey == null) || (sKey.equals(key)) ) { String value = entry.getValue().toString(); Preference pref = findPreference(key); String preference = getPreference(pref); Log.d("map values", key + " | " + value + " | " + preference); pref.setSummary(key + " | " + value + " | " + preference); if (sKey != null) return true; } } return false; } private void updatePreference(SharedPreferences prefs, String key) { Log.i(TAG, "+ updatePreference(prefs:" + prefs + ", key:" + key + ")"); Preference pref = findPreference(key); String preferenceType = getPreference(pref); Log.i(TAG, "preferenceType = " + preferenceType); Log.i(TAG, "- updatePreference()"); } 

Inicializar

Cree una clase pública que PreferenceActivity e implemente OnSharedPreferenceChangeListener

 protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); PreferenceManager.setDefaultValues(this, R.xml.global_preferences, false); this.addPreferencesFromResource(R.xml.global_preferences); this.getPreferenceScreen().getSharedPreferences() .registerOnSharedPreferenceChangeListener(this); } protected void onResume() { super.onResume(); setSummary(); } 

Simplemente:

 listPreference.setSummary("%s"); 

FYI:

 findPreference(CharSequence key) This method was deprecated in API level 11. This function is not relevant for a modern fragment-based PreferenceActivity. 

Razón de más para ver la resbaladiza Answer de @ASD anterior ( fuente encontrada aquí ) diciendo que use %s en android:summary para cada campo en preferences.xml . (El valor actual de preferencia se sustituye por %s )

enter image description here

  

Aquí, todos estos están recortados de Eclipse sample SettingsActivity . Tengo que copiar todos estos demasiados códigos para mostrar cómo estos desarrolladores de Android eligen perfectamente para un estilo de encoding más generalizado y estable.

Dejé los códigos para adaptar PreferenceActivity a la tableta y una API mayor.

 public class SettingsActivity extends PreferenceActivity { @Override protected void onPostCreate(Bundle savedInstanceState) { super.onPostCreate(savedInstanceState); setupSummaryUpdatablePreferencesScreen(); } private void setupSummaryUpdatablePreferencesScreen() { // In the simplified UI, fragments are not used at all and we instead // use the older PreferenceActivity APIs. // Add 'general' preferences. addPreferencesFromResource(R.xml.pref_general); // Bind the summaries of EditText/List/Dialog preferences to // their values. When their values change, their summaries are updated // to reflect the new value, per the Android Design guidelines. bindPreferenceSummaryToValue(findPreference("example_text")); bindPreferenceSummaryToValue(findPreference("example_list")); } /** * A preference value change listener that updates the preference's summary * to reflect its new value. */ private static Preference.OnPreferenceChangeListener sBindPreferenceSummaryToValueListener = new Preference.OnPreferenceChangeListener() { private String TAG = SettingsActivity.class.getSimpleName(); @Override public boolean onPreferenceChange(Preference preference, Object value) { String stringValue = value.toString(); if (preference instanceof ListPreference) { // For list preferences, look up the correct display value in // the preference's 'entries' list. ListPreference listPreference = (ListPreference) preference; int index = listPreference.findIndexOfValue(stringValue); // Set the summary to reflect the new value. preference.setSummary( index >= 0 ? listPreference.getEntries()[index] : null); } else { // For all other preferences, set the summary to the value's // simple string representation. preference.setSummary(stringValue); } Log.i(TAG, "pref changed : " + preference.getKey() + " " + value); return true; } }; /** * Binds a preference's summary to its value. More specifically, when the * preference's value is changed, its summary (line of text below the * preference title) is updated to reflect the value. The summary is also * immediately updated upon calling this method. The exact display format is * dependent on the type of preference. * * @see #sBindPreferenceSummaryToValueListener */ private static void bindPreferenceSummaryToValue(Preference preference) { // Set the listener to watch for value changes. preference.setOnPreferenceChangeListener(sBindPreferenceSummaryToValueListener); // Trigger the listener immediately with the preference's // current value. sBindPreferenceSummaryToValueListener.onPreferenceChange(preference, PreferenceManager .getDefaultSharedPreferences(preference.getContext()) .getString(preference.getKey(), "")); } } 

xml/pref_general.xml

         

values/strings_activity_settings.xml

    Display name John Smith Add friends to messages  Always When possible Never   1 0 -1   

NOTA: En realidad, solo quiero comentar que “la muestra de Google para PreferenceActivity también es interesante”. Pero no tengo suficientes puntos de reputación. Por favor, no me culpen.

(Perdón por mal inglés)

Debe usar la función bindPreferenceSummaryToValue en el método onCreate.

Ejemplo:

  @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Add 'general' preferences, defined in the XML file addPreferencesFromResource(R.xml.pref_general); // For all preferences, attach an OnPreferenceChangeListener so the UI summary can be // updated when the preference changes. bindPreferenceSummaryToValue(findPreference(getString(R.string.pref_location_key))); bindPreferenceSummaryToValue(findPreference(getString(R.string.pref_units_key))); } 

See lesson 3 on Udacity Android Course: https://www.udacity.com/course/viewer#!/c-ud853/l-1474559101/e-1643578599/m-1643578601

For EditTextPreference :

I came to this solution, of course, just if you need particular edittextpreference but you could do this with every Preference:

…………

 private static final String KEY_EDIT_TEXT_PREFERENCE2 = "on_a1"; public static String value = ""; 

…………

 private void updatePreference(Preference preference, String key) { if (key.equals(KEY_EDIT_TEXT_PREFERENCE2)) { preference = findPreference(key); if (preference instanceof EditTextPreference) { editTextPreference = (EditTextPreference) preference; editTextPreference.setSummary(editTextPreference.getText()); value = editTextPreference.getText().toString(); return; } SharedPreferences sharedPrefs = getPreferenceManager().getSharedPreferences(); preference.setSummary(sharedPrefs.getString(KEY_EDIT_TEXT_PREFERENCE2, "")); } } 

Then in onResume();

 @Override public void onResume() { super.onResume(); SharedPreferences etext = getPreferenceManager().getSharedPreferences(); String str = etext.getString("value", ""); editTextPreference = (EditTextPreference) findPreference(KEY_EDIT_TEXT_PREFERENCE2); editTextPreference.setText(str); editTextPreference.setSummary(editTextPreference.getText()); getPreferenceScreen().getSharedPreferences() .registerOnSharedPreferenceChangeListener(this); } 

En:

 @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { updatePreference(findPreference(key), key); } 

My solution is to create a custom EditTextPreference , used in XML like this:

EditTextPreference.java :-

 package com.example; import android.content.Context; import android.util.AttributeSet; public class EditTextPreference extends android.preference.EditTextPreference { public EditTextPreference(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public EditTextPreference(Context context, AttributeSet attrs) { super(context, attrs); } public EditTextPreference(Context context) { super(context, null); } @Override protected void onDialogClosed(boolean positiveResult) { super.onDialogClosed(positiveResult); setSummary(getSummary()); } @Override public CharSequence getSummary() { return getText(); } } 

To set the summary of a ListPreference to the value selected in a dialog you could use this code:

 package yourpackage; import android.content.Context; import android.util.AttributeSet; public class ListPreference extends android.preference.ListPreference { public ListPreference(Context context, AttributeSet attrs) { super(context, attrs); } protected void onDialogClosed(boolean positiveResult) { super.onDialogClosed(positiveResult); if (positiveResult) setSummary(getEntry()); } protected void onSetInitialValue(boolean restreValue, Object defaultValue) { super.onSetInitialValue(restreValue, defaultValue); setSummary(getEntry()); } } 

and reference the yourpackage.ListPreference object in your preferences.xml remembering to specify there your android:defaultValue as this triggers the call to onSetInitialValue() .

If you want you can then modify the text before calling setSummary() to whatever suits your application.

Because I’m using a custom PreferenceDataStore , I can’t add a listener to some SharedPreference so I’ve had to write a somewhat hacky solution that listens to each preference:

 class SettingsFragment : PreferenceFragmentCompat(), Preference.OnPreferenceChangeListener { private val handler: Handler by lazy { Handler(Looper.getMainLooper()) } override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) { preferenceManager.preferenceDataStore = prefs addPreferencesFromResource(R.xml.app_preferences) onPreferenceChange(preferenceScreen, null) } override fun onPreferenceChange(preference: Preference, newValue: Any?): Boolean { preference.onPreferenceChangeListener = this when (preference) { is PreferenceGroup -> for (i in 0 until preference.preferenceCount) { onPreferenceChange(preference.getPreference(i), null) } is ListPreference -> { if (preference.value == null) { preference.isPersistent = false preference.value = Preference::class.java.getDeclaredField("mDefaultValue") .apply { isAccessible = true } .get(preference).toString() preference.isPersistent = true } postPreferenceUpdate(Runnable { preference.summary = preference.entry }) } } return true } /** * We can't directly update the preference summary update because [onPreferenceChange]'s result * is used to decide whether or not to update the pref value. */ private fun postPreferenceUpdate(r: Runnable) = handler.post(r) } 

Here is a working solution for all EditTextPreference s inside of a PreferenceFragment based on @tdeveaux answer:

 public class SettingsFragment extends PreferenceFragment implements SharedPreferences.OnSharedPreferenceChangeListener { private static final String TAG = "SettingsFragment"; @Override public void onCreate (Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this); } @Override public void onResume () { super.onResume(); for (int i = 0; i < getPreferenceScreen().getPreferenceCount(); ++i) { Preference preference = getPreferenceScreen().getPreference(i); updatePreference(preference); } } @Override public void onSharedPreferenceChanged (SharedPreferences sharedPreferences, String key) { updatePreference(findPreference(key)); } private void updatePreference (Preference preference) { if (preference instanceof EditTextPreference) { EditTextPreference editTextPreference = (EditTextPreference)preference; editTextPreference.setSummary(editTextPreference.getText()); } } } 

I found this way to make EditTextPreference from support library handle "%s" in summary (as ListPreference already handles):

 public class EditTextPreference extends android.support.v7.preference.EditTextPreference { public EditTextPreference(Context context, AttributeSet attrs) { super(context, attrs); } @Override public void setText(String text) { super.setText(text); notifyChanged(); } @Override public CharSequence getSummary() { String text = super.getText(); String summary = super.getSummary().toString(); return String.format(summary, text == null ? "" : text); } } 

In xml it will look like this:

  

The concise solution by 1 line of code:

 @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); bindPreferenceSummaryToValue(findPreference("mySetting")); // initialize summary sBindPreferenceSummaryToValueListener.onPreferenceChange(findPreference("mySetting"), ((ListPreference) findPreference("mySetting")).getEntry()); }