SharedPreferences.onSharedPreferenceChangeListener nie jest wywoływany konsekwentnie

Rejestruję odbiornik zmiany preferencji w ten sposób (w onCreate()mojej głównej działalności):

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

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

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

Problem w tym, że słuchacz nie zawsze jest wywoływany. Działa po raz pierwszy, gdy preferencje są zmieniane, a następnie nie są wywoływane, dopóki nie odinstaluję i ponownie nie zainstaluję aplikacji. Wydaje się, że żadna ilość ponownego uruchomienia aplikacji nie naprawi tego.

Znalazłem wątek na liście mailingowej zgłaszający ten sam problem, ale tak naprawdę nikt mu nie odpowiedział. Co ja robię źle?

To jest podstępne. SharedPreferences utrzymuje nasłuchujących w WeakHashMap. Oznacza to, że nie można używać anonimowej klasy wewnętrznej jako detektora, ponieważ stanie się ona celem odśmiecania, gdy tylko opuścisz obecny zakres. Będzie to działało na początku, ale ostatecznie zostanie zebrane śmieci, usunięte z WeakHashMap i przestanie działać.

Zachowaj odniesienie do słuchacza w polu swojej klasy, a będziesz w porządku, pod warunkiem, że instancja klasy nie zostanie zniszczona.

tj. zamiast:

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

Zrób to:

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

Przyczyną wyrejestrowania się w metodzie onDestroy jest naprawienie problemu, ponieważ w tym celu trzeba było zapisać słuchacza w polu, co zapobiegło problemowi. To zapisanie nasłuchiwania w polu, które rozwiązuje problem, a nie wyrejestrowanie się z onDestroy.

AKTUALIZACJA : Dokumenty Androida zostały zaktualizowane o ostrzeżenia o tym zachowaniu. Tak więc dziwne zachowanie pozostaje. Ale teraz jest to udokumentowane.

ta zaakceptowana odpowiedź jest w porządku, ponieważ dla mnie tworzy ona nową instancję za każdym razem, gdy aktywność zostanie wznowiona

co powiesz na zachowanie odniesienia do słuchacza w ramach działania

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

oraz w onResume i onPause

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



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

}

będzie to bardzo podobne do tego, co robisz, z wyjątkiem tego, że utrzymujemy twarde referencje.

Ponieważ jest to najbardziej szczegółowa strona tematu, chcę dodać 50ct.

Miałem problem, że nie wywołano OnSharedPreferenceChangeListener. Moje współdzielone preferencje są pobierane na początku głównej aktywności przez:

prefs = PreferenceManager.getDefaultSharedPreferences(this);

Mój kod preferencji jest krótki i nie robi nic poza pokazaniem preferencji:

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

Za każdym naciśnięciem przycisku menu tworzę PreferenceActivity z głównego działania:

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

Należy pamiętać, że rejestracja OnSharedPreferenceChangeListener musi zostać wykonana PO utworzeniu PreferenceActivity w tym przypadku, w przeciwnym razie moduł obsługi w głównym działaniu nie zostanie wywołany !!! Uświadomienie sobie, że ...

Zaakceptowana odpowiedź tworzy za SharedPreferenceChangeListenerkażdym razem, gdy onResumejest wywoływana. @Samuel rozwiązuje to, czyniąc SharedPreferenceListenerczłonka klasy Activity. Ale istnieje trzecie i prostsze rozwiązanie, którego Google używa również w tym kodzie kodowym . Spraw, aby klasa działań implementowała OnSharedPreferenceChangeListenerinterfejs i zastępowała onSharedPreferenceChangeddziałanie, skutecznie czyniąc samo działanie 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);
    }
}

Kod Kotlin dla rejestru SharedPreferenceChangeListener wykrywa, kiedy nastąpi zmiana na zapisanym kluczu:

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

możesz umieścić ten kod w onStart () lub w innym miejscu .. * Zastanów się, że musisz użyć

 if(key=="YourKey")

lub kody wewnątrz bloku „// Zrób coś” będą uruchamiane niepoprawnie dla każdej zmiany, która nastąpi w dowolnym innym kluczu w sharePreferences

Więc nie wiem, czy to naprawdę komukolwiek by pomogło, rozwiązało to mój problem. Mimo że OnSharedPreferenceChangeListenerwdrożyłem zgodnie z przyjętą odpowiedzią . Mimo to miałem niespójność z wezwaniem słuchacza.

Przyszedłem tutaj, aby zrozumieć, że Android po prostu wysyła go do śmieci po pewnym czasie. Spojrzałem na mój kod. Ku mojemu wstydowi nie zadeklarowałem GLOBALNIE słuchacza, ale zamiast tego w onCreateView. A to dlatego, że słuchałem Android Studio z poleceniem konwersji odbiornika na zmienną lokalną.

Ma to sens, że nasłuchiwania są przechowywane w WeakHashMap, ponieważ przez większość czasu programiści wolą pisać taki kod.

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

To może wydawać się niezłe. Ale jeśli kontener OnSharedPreferenceChangeListeners nie był WeakHashMap, byłoby bardzo źle. Jeśli powyższy kod został napisany w działaniu. Ponieważ używasz niestatycznej (anonimowej) klasy wewnętrznej, która niejawnie przechowuje odwołanie do otaczającej instancji. Spowoduje to wyciek pamięci.

Co więcej, jeśli trzymasz detektor jako pole, możesz użyć registerOnSharedPreferenceChangeListener na początku i wywołać unregisterOnSharedPreferenceChangeListener na końcu. Ale nie można uzyskać dostępu do zmiennej lokalnej w metodzie spoza jej zakresu. Masz więc tylko możliwość zarejestrowania się, ale nie ma możliwości wyrejestrowania słuchacza. Zatem użycie WeakHashMap rozwiąże problem. Tak właśnie polecam.

Jeśli utworzysz instancję detektora jako pole statyczne, unikniesz wycieku pamięci spowodowanego przez niestatyczną klasę wewnętrzną. Ale ponieważ nasłuchiwanie może być wielokrotne, powinno być związane z instancją. Zmniejszy to koszty obsługi wywołania zwrotnego onSharedPreferenceChanged .

Podczas czytania danych czytelnych dla programu Word udostępnianych przez pierwszą aplikację, powinniśmy

Zastąpić

getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE);

z

getSharedPreferences("PREF_NAME", Context.MODE_MULTI_PROCESS);

w drugiej aplikacji, aby uzyskać zaktualizowaną wartość w drugiej aplikacji.

Ale nadal nie działa ...