SharedPreferences.onSharedPreferenceChangeListener no se llama constantemente

Estoy registrando un oyente de cambio de preferencia como este (en el onCreate()de mi actividad principal):

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

prefs.registerOnSharedPreferenceChangeListener(
   new SharedPreferences.OnSharedPreferenceChangeListener() {
       public void onSharedPreferenceChanged(
         SharedPreferences prefs, String key) {

         System.out.println(key);
       }
});

El problema es que no siempre se llama al oyente. Funciona las primeras veces que se cambia una preferencia, y luego ya no se llama hasta que desinstale y vuelva a instalar la aplicación. Ninguna cantidad de reinicio de la aplicación parece solucionarlo.

Encontré un hilo de la lista de correo informando el mismo problema, pero nadie realmente le respondió. ¿Qué estoy haciendo mal?

Esta es una disimulada. SharedPreferences mantiene a los oyentes en un WeakHashMap. Esto significa que no puede usar una clase interna anónima como escucha, ya que se convertirá en el objetivo de la recolección de basura tan pronto como abandone el alcance actual. Al principio funcionará, pero eventualmente, se recolectará la basura, se eliminará del WeakHashMap y dejará de funcionar.

Mantenga una referencia al oyente en un campo de su clase y estará bien, siempre que su instancia de clase no se destruya.

es decir, en lugar de:

prefs.registerOnSharedPreferenceChangeListener(
  new SharedPreferences.OnSharedPreferenceChangeListener() {
  public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
    // Implementation
  }
});

hacer esto:

// Use instance field for listener
// It will not be gc'd as long as this instance is kept referenced
listener = new SharedPreferences.OnSharedPreferenceChangeListener() {
  public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
    // Implementation
  }
};

prefs.registerOnSharedPreferenceChangeListener(listener);

La razón por la que la cancelación del registro en el método onDestroy soluciona el problema es porque para hacerlo tenía que guardar el oyente en un campo, evitando así el problema. Es salvar al oyente en un campo lo que soluciona el problema, no anular el registro en onDestroy.

ACTUALIZACIÓN : los documentos de Android se han actualizado con advertencias sobre este comportamiento. Entonces, el comportamiento extraño sigue siendo. Pero ahora está documentado.

esta respuesta aceptada está bien, ya que para mí está creando una nueva instancia cada vez que se reanuda la actividad

Entonces, ¿qué hay de mantener la referencia al oyente dentro de la actividad

OnSharedPreferenceChangeListener myPrefListner = new OnSharedPreferenceChangeListener(){
      public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
         // your stuff
      }
};

y en tu onResume y onPause

@Override     
protected void onResume() {
    super.onResume();          
    getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(myPrefListner);     
}



@Override     
protected void onPause() {         
    super.onPause();          
    getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(myPrefListner);

}

Esto será muy similar a lo que está haciendo, excepto que mantenemos una referencia sólida.

Como esta es la página más detallada para el tema, quiero agregar mi 50ct.

Tuve el problema de que no se llamaba a OnSharedPreferenceChangeListener. Mis preferencias compartidas se recuperan al comienzo de la actividad principal:

prefs = PreferenceManager.getDefaultSharedPreferences(this);

Mi código de PreferenceActivity es corto y no hace nada excepto mostrar las preferencias:

public class Preferences extends PreferenceActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // load the XML preferences file
        addPreferencesFromResource(R.xml.preferences);
    }
}

Cada vez que se presiona el botón de menú, creo la Actividad de Preferencia desde la Actividad principal:

@Override
public boolean onPrepareOptionsMenu(Menu menu) {
    super.onCreateOptionsMenu(menu);
    //start Preference activity to show preferences on screen
    startActivity(new Intent(this, Preferences.class));
    //hook into sharedPreferences. THIS NEEDS TO BE DONE AFTER CREATING THE ACTIVITY!!!
    prefs.registerOnSharedPreferenceChangeListener(this);
    return false;
}

Tenga en cuenta que el registro de OnSharedPreferenceChangeListener debe hacerse DESPUÉS de crear PreferenceActivity en este caso, de lo contrario, no se llamará al controlador en la actividad principal. Me tomó un tiempo dulce darme cuenta de que ...

La respuesta aceptada crea un SharedPreferenceChangeListenercada vez que onResumese llama. @Samuel lo resuelve al hacer SharedPreferenceListenerun miembro de la clase Actividad. Pero hay una tercera y más sencilla solución que Google también usa en este codelab . Haga que su clase de actividad implemente la OnSharedPreferenceChangeListenerinterfaz y anule onSharedPreferenceChangedla actividad, haciendo que la actividad en sí sea a SharedPreferenceListener.

public class MainActivity extends Activity implements SharedPreferences.OnSharedPreferenceChangeListener {

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String s) {

    }

    @Override
    protected void onStart() {
        super.onStart();
        PreferenceManager.getDefaultSharedPreferences(this)
                .registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        PreferenceManager.getDefaultSharedPreferences(this)
                .unregisterOnSharedPreferenceChangeListener(this);
    }
}

Código de Kotlin para el registro SharedPreferenceChangeListener que detecta cuando se producirán cambios en la clave guardada:

  PreferenceManager.getDefaultSharedPreferences(this)
        .registerOnSharedPreferenceChangeListener { sharedPreferences, key ->
            if(key=="language") {
                //Do Something 
            }
        }

puede poner este código en onStart (), o en otro lugar .. * Tenga en cuenta que debe usar

 if(key=="YourKey")

o sus códigos dentro del bloque "// Do Something" se ejecutarán incorrectamente para cada cambio que ocurra en cualquier otra clave en sharedPreferences

Entonces, no sé si esto realmente ayudaría a alguien, resolvió mi problema. A pesar de que había implementado lo OnSharedPreferenceChangeListenerque dice la respuesta aceptada . Aún así, tuve una inconsistencia con la llamada del oyente.

Vine aquí para entender que el Android simplemente lo envía para la recolección de basura después de algún tiempo. Entonces, miré mi código. Para mi vergüenza, no había declarado al oyente GLOBALMENTE, sino dentro del onCreateView. Y eso fue porque escuché a Android Studio diciéndome que convirtiera el oyente a una variable local.

Tiene sentido que los oyentes se mantengan en WeakHashMap. Debido a que la mayoría de las veces, los desarrolladores prefieren escribir el código de esta manera.

PreferenceManager.getDefaultSharedPreferences(getApplicationContext()).registerOnSharedPreferenceChangeListener(
    new OnSharedPreferenceChangeListener() {
    @Override
    public void onSharedPreferenceChanged(
        SharedPreferences sharedPreferences, String key) {
        Log.i(LOGTAG, "testOnSharedPreferenceChangedWrong key =" + key);
    }
});

Esto puede parecer no está mal. Pero si el contenedor de OnSharedPreferenceChangeListeners no fuera WeakHashMap, sería muy malo si el código anterior se escribiera en una actividad. Como está utilizando una clase interna no estática (anónima) que implícitamente contiene la referencia de la instancia de cierre. Esto causará pérdida de memoria.

Además, si mantiene el oyente como un campo, puede usar registerOnSharedPreferenceChangeListener al principio y llamar a unregisterOnSharedPreferenceChangeListener al final. Pero no puede acceder a una variable local en un método fuera de su alcance. Por lo tanto, solo tiene la oportunidad de registrarse, pero no la posibilidad de cancelar el registro del oyente. Por lo tanto, usar WeakHashMap resolverá el problema. Esta es la forma que recomiendo.

Si realiza la instancia de escucha como un campo estático, evitará la pérdida de memoria causada por la clase interna no estática. Pero como los oyentes podrían ser múltiples, debería estar relacionado con la instancia. Esto reducirá el costo de manejar la devolución de llamada onSharedPreferenceChanged .

Al leer los datos legibles de Word compartidos por la primera aplicación, deberíamos

Reemplazar

getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE);

con

getSharedPreferences("PREF_NAME", Context.MODE_MULTI_PROCESS);

en la segunda aplicación para obtener un valor actualizado en la segunda aplicación.

Pero aún así no está funcionando ...