SharedPreferences.onSharedPreferenceChangeListener wird nicht konsistent aufgerufen

Ich registriere einen Listener für Präferenzänderungen wie folgt (in onCreate()meiner Hauptaktivität):

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

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

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

Das Problem ist, dass der Hörer nicht immer angerufen wird. Es funktioniert für die ersten Male, wenn eine Einstellung geändert wird, und wird dann nicht mehr aufgerufen, bis ich die App deinstalliere und neu installiere. Kein Neustart der Anwendung scheint das Problem zu beheben.

Ich habe einen Mailinglisten- Thread gefunden , der das gleiche Problem meldet, aber niemand hat ihm wirklich geantwortet. Was mache ich falsch?

Dies ist eine hinterhältige. SharedPreferences hält Listener in einer WeakHashMap. Dies bedeutet, dass Sie keine anonyme innere Klasse als Listener verwenden können, da diese zum Ziel der Speicherbereinigung wird, sobald Sie den aktuellen Bereich verlassen. Es wird zuerst funktionieren, aber irgendwann wird Müll gesammelt, aus der WeakHashMap entfernt und funktioniert nicht mehr.

Behalten Sie einen Verweis auf den Listener in einem Feld Ihrer Klasse bei, und Sie sind in Ordnung, vorausgesetzt, Ihre Klasseninstanz wird nicht zerstört.

dh anstelle von:

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

mach das:

// 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);

Der Grund für die Aufhebung der Registrierung in der onDestroy-Methode ist, dass Sie den Listener in einem Feld speichern mussten, um das Problem zu vermeiden. Es ist das Speichern des Listeners in einem Feld, das das Problem behebt, nicht das Aufheben der Registrierung in onDestroy.

UPDATE : Die Android-Dokumente wurden mit Warnungen zu diesem Verhalten aktualisiert . So bleibt seltsames Verhalten. Aber jetzt ist es dokumentiert.

Diese akzeptierte Antwort ist in Ordnung, da für mich jedes Mal, wenn die Aktivität fortgesetzt wird, eine neue Instanz erstellt wird

Wie wäre es also, wenn Sie den Verweis auf den Hörer innerhalb der Aktivität behalten?

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

und in Ihrem onResume und onPause

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



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

}

Dies wird sehr ähnlich zu dem sein, was Sie tun, außer dass wir eine harte Referenz beibehalten.

Da dies die detaillierteste Seite für das Thema ist, möchte ich meine 50ct hinzufügen.

Ich hatte das Problem, dass OnSharedPreferenceChangeListener nicht aufgerufen wurde. Meine SharedPreferences werden zu Beginn der Hauptaktivität abgerufen von:

prefs = PreferenceManager.getDefaultSharedPreferences(this);

Mein PreferenceActivity-Code ist kurz und zeigt nur die Einstellungen an:

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

Jedes Mal, wenn die Menütaste gedrückt wird, erstelle ich die PreferenceActivity aus der Hauptaktivität:

@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;
}

Beachten Sie, dass die Registrierung des OnSharedPreferenceChangeListener in diesem Fall nach dem Erstellen der PreferenceActivity erfolgen muss, da sonst der Handler in der Hauptaktivität nicht aufgerufen wird !!! Ich brauchte einige süße Zeit, um zu erkennen, dass ...

Die akzeptierte Antwort erstellt SharedPreferenceChangeListenerjedes Mal einen onResumeAufruf. @Samuel löst das Problem , indem er SharedPreferenceListenerMitglied der Aktivitätsklasse wird. Es gibt jedoch eine dritte und einfachere Lösung, die Google auch in diesem Codelab verwendet . Lassen Sie Ihre Aktivitätsklasse die OnSharedPreferenceChangeListenerSchnittstelle implementieren und onSharedPreferenceChangedin der Aktivität überschreiben , sodass die Aktivität selbst effektiv zu einer Aktivität wird 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);
    }
}

Kotlin-Code für das Register SharedPreferenceChangeListener erkennt, wann Änderungen am gespeicherten Schlüssel vorgenommen werden:

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

Sie können diesen Code in onStart () oder an einer anderen Stelle einfügen. * Beachten Sie, dass Sie ihn verwenden müssen

 if(key=="YourKey")

oder Ihre Codes im Block "// Do Something" werden bei jeder Änderung, die an einem anderen Schlüssel in sharedPreferences vorgenommen wird, falsch ausgeführt

Ich weiß also nicht, ob dies wirklich jemandem helfen würde, es hat mein Problem gelöst. Obwohl ich das OnSharedPreferenceChangeListenerwie in der akzeptierten Antwort angegeben umgesetzt hatte . Trotzdem hatte ich eine Inkonsistenz mit dem angerufenen Hörer.

Ich bin hierher gekommen, um zu verstehen, dass Android es nach einiger Zeit nur zur Speicherbereinigung sendet. Also schaute ich auf meinen Code. Zu meiner Schande hatte ich den Hörer nicht GLOBAL deklariert, sondern im onCreateView. Und das lag daran, dass ich mir das Android Studio angehört habe, in dem ich aufgefordert wurde, den Listener in eine lokale Variable umzuwandeln.

Es ist sinnvoll, dass die Listener in WeakHashMap gespeichert bleiben. Da Entwickler es meistens vorziehen, den Code so zu schreiben.

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

Das mag nicht schlecht erscheinen. Wenn der Container von OnSharedPreferenceChangeListeners jedoch nicht WeakHashMap wäre, wäre dies sehr schlecht. Wenn der obige Code in einer Aktivität geschrieben wurde. Da Sie eine nicht statische (anonyme) innere Klasse verwenden, die implizit die Referenz der einschließenden Instanz enthält. Dies führt zu einem Speicherverlust.

Wenn Sie den Listener als Feld behalten, können Sie am Anfang registerOnSharedPreferenceChangeListener verwenden und am Ende unregisterOnSharedPreferenceChangeListener aufrufen . Sie können jedoch nicht auf eine lokale Variable in einer Methode außerhalb ihres Gültigkeitsbereichs zugreifen. Sie haben also nur die Möglichkeit, sich zu registrieren, aber keine Möglichkeit, die Registrierung des Hörers aufzuheben. Durch die Verwendung von WeakHashMap wird das Problem behoben. Dies ist der Weg, den ich empfehle.

Wenn Sie die Listener-Instanz als statisches Feld festlegen, wird der durch nicht statische innere Klasse verursachte Speicherverlust vermieden. Da die Listener jedoch mehrere sein können, sollte dies instanzbezogen sein. Dies reduziert die Kosten für die Bearbeitung des onSharedPreferenceChanged- Rückrufs.

Beim Lesen von Word-lesbaren Daten, die von der ersten App gemeinsam genutzt werden, sollten wir dies tun

Ersetzen

getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE);

mit

getSharedPreferences("PREF_NAME", Context.MODE_MULTI_PROCESS);

in der zweiten App, um den aktualisierten Wert in der zweiten App zu erhalten.

Aber es funktioniert immer noch nicht ...