SharedPreferences.onSharedPreferenceChangeListener non chiamato in modo coerente

Sto registrando un listener di modifica preferenze come questo (nella onCreate()mia attività principale):

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

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

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

Il problema è che l'ascoltatore non viene sempre chiamato. Funziona per le prime volte in cui una preferenza viene modificata, quindi non viene più chiamata finché non disinstallo e reinstallo l'app. Nessuna quantità di riavvio dell'applicazione sembra risolverlo.

Ho trovato un thread della mailing list che riportava lo stesso problema, ma nessuno gli ha veramente risposto. Che cosa sto facendo di sbagliato?

Questo è subdolo. SharedPreferences mantiene gli ascoltatori in una WeakHashMap. Ciò significa che non è possibile utilizzare una classe interna anonima come listener, poiché diventerà la destinazione della Garbage Collection non appena si esce dall'ambito corrente. Funzionerà inizialmente, ma alla fine verrà raccolta dei rifiuti, rimossa da WeakHashMap e smetterà di funzionare.

Conserva un riferimento all'ascoltatore in un campo della tua classe e sarai OK, a condizione che l'istanza della tua classe non venga distrutta.

cioè invece di:

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

Fai questo:

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

Il motivo dell'annullamento della registrazione nel metodo onDestroy risolve il problema è perché per farlo è stato necessario salvare l'ascoltatore in un campo, evitando così il problema. È il salvataggio dell'ascoltatore in un campo che risolve il problema, non l'annullamento della registrazione in onDestroy.

AGGIORNAMENTO : i documenti Android sono stati aggiornati con avvisi su questo comportamento. Quindi, rimane un comportamento strano. Ma ora è documentato.

questa risposta accettata è ok, poiché per me sta creando una nuova istanza ogni volta che l'attività riprende

che ne dite di mantenere il riferimento all'ascoltatore all'interno dell'attività

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

e nel tuo onResume e onPause

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



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

}

questo sarà molto simile a quello che stai facendo, tranne per il fatto che stiamo mantenendo un duro riferimento.

Poiché questa è la pagina più dettagliata per l'argomento, voglio aggiungere il mio 50ct.

Ho avuto il problema che OnSharedPreferenceChangeListener non è stato chiamato. Le mie condivisioni condivise vengono recuperate all'inizio dell'attività principale da:

prefs = PreferenceManager.getDefaultSharedPreferences(this);

Il mio codice Preferenza attiva è breve e non fa altro che mostrare le preferenze:

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

Ogni volta che si preme il pulsante menu creo PreferenceActivity dall'attività principale:

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

Nota che la registrazione di OnSharedPreferenceChangeListener deve essere effettuata DOPO la creazione di PreferenceActivity in questo caso, altrimenti il ​​gestore nell'attività principale non verrà chiamato !!! Mi ci è voluto un po 'di tempo dolce per rendermi conto che ...

La risposta accettata crea un SharedPreferenceChangeListenerogni volta che onResumeviene chiamato. @Samuel lo risolve creando SharedPreferenceListenerun membro della classe Activity. Ma c'è una terza e una soluzione più semplice che Google utilizza anche in questo codice . Rendi la tua classe di attività implementare l' OnSharedPreferenceChangeListenerinterfaccia e sovrascrivere onSharedPreferenceChangedl'attività, rendendola effettivamente un'attività 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);
    }
}

Codice di Kotlin per il registro SharedPreferenceChangeListener rileva quando si verificherà una modifica sulla chiave salvata:

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

puoi inserire questo codice in onStart () o altrove. * Considera che devi usare

 if(key=="YourKey")

oppure i tuoi codici all'interno del blocco "// Do Something" verranno eseguiti in modo errato per ogni modifica che si verificherà in qualsiasi altra chiave in sharedPreferences

Quindi, non so se questo aiuterebbe davvero qualcuno, ha risolto il mio problema. Anche se avevo implementato OnSharedPreferenceChangeListenercome indicato dalla risposta accettata . Tuttavia, avevo un'incongruenza con l'ascoltatore chiamato.

Sono venuto qui per capire che Android lo ha appena inviato per la raccolta dei rifiuti dopo qualche tempo. Quindi ho dato un'occhiata al mio codice. Con mia vergogna, non avevo dichiarato l'ascoltatore GLOBALMENTE ma invece all'interno onCreateView. E questo perché ho ascoltato Android Studio che mi diceva di convertire l'ascoltatore in una variabile locale.

È logico che gli ascoltatori siano mantenuti in WeakHashMap, poiché la maggior parte delle volte gli sviluppatori preferiscono scrivere il codice in questo modo.

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

Questo potrebbe non sembrare negativo. Ma se il contenitore OnSharedPreferenceChangeListeners non fosse WeakHashMap, sarebbe molto male. Se il codice sopra fosse scritto in un'attività. Dato che stai usando una classe interna non statica (anonima) che conterrà implicitamente il riferimento dell'istanza che la racchiude. Ciò causerà una perdita di memoria.

Inoltre, se si mantiene il listener come campo, è possibile utilizzare registerOnSharedPreferenceChangeListener all'inizio e chiamare unregisterOnSharedPreferenceChangeLhangeener alla fine. Ma non è possibile accedere a una variabile locale in un metodo al di fuori del suo ambito. Quindi hai solo l'opportunità di registrarti ma non hai la possibilità di annullare la registrazione dell'ascoltatore. Pertanto, l'utilizzo di WeakHashMap risolverà il problema. Questo è il modo in cui raccomando.

Se si crea l'istanza del listener come campo statico, si eviterà la perdita di memoria causata dalla classe interna non statica. Ma poiché gli ascoltatori potrebbero essere multipli, dovrebbe essere correlato all'istanza. Ciò ridurrà il costo di gestione del callback onSharedPreferenceChanged .

Mentre leggiamo i dati leggibili in Word condivisi dalla prima app, dovremmo

Sostituire

getSharedPreferences("PREF_NAME", Context.MODE_PRIVATE);

con

getSharedPreferences("PREF_NAME", Context.MODE_MULTI_PROCESS);

nella seconda app per ottenere un valore aggiornato nella seconda app.

Ma ancora non funziona ...