Différence de setValue () et postValue () dans MutableLiveData

Il existe deux façons de valoriser le changement MutableLiveData. Mais quelle est la différence entre setValue()& postValue()in MutableLiveData.

Je n'ai pas pu trouver de documentation pour le même.

Voici la classe MutableLiveDatad'Android.

package android.arch.lifecycle;

/**
 * {@link LiveData} which publicly exposes {@link #setValue(T)} and {@link #postValue(T)} method.
 *
 * @param <T> The type of data hold by this instance
 */
@SuppressWarnings("WeakerAccess")
public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

Basé sur la documentation:

setValue () :

Définit la valeur. S'il y a des observateurs actifs, la valeur leur sera envoyée. Cette méthode doit être appelée à partir du thread principal.

postValue () :

Publie une tâche sur un thread principal pour définir la valeur donnée. Si vous avez appelé cette méthode plusieurs fois avant qu'un thread principal n'exécute une tâche publiée, seule la dernière valeur serait distribuée.

Pour résumer, la principale différence serait:

setValue()La méthode doit être appelée à partir du thread principal. Mais si vous avez besoin de définir une valeur à partir d'un thread d'arrière-plan, postValue()doit être utilisé.

Toutes les réponses ci-dessus sont correctes. Mais une autre différence importante. Si vous appelez un postValue()champ qui n'a pas d'observateurs et que vous appelez ensuite getValue(), vous ne recevez pas la valeur que vous avez définie postValue(). Soyez donc prudent si vous travaillez dans des threads d'arrière-plan sans observateurs.

setValue()est appelé directement à partir du thread de l'appelant, notifie les observateurs de manière synchrone et modifie la LiveDatavaleur immédiatement. Il ne peut être appelé qu'à partir de MainThread.
postValue()utilise à l'intérieur quelque chose comme ça new Handler(Looper.mainLooper()).post(() -> setValue()), donc il s'exécute setValuevia Handlerdans MainThread. Il peut être appelé depuis n'importe quel thread.

setValue()

Définit la valeur. S'il y a des observateurs actifs, la valeur leur sera envoyée.

Cette méthode doit être appelée à partir du thread principal .

postValue

Si vous avez besoin de définir une valeur à partir d'un thread d'arrière-plan, vous pouvez utiliser postValue(Object)

Publie une tâche sur un thread principal pour définir la valeur donnée.

Si vous avez appelé cette méthode plusieurs fois avant qu'un thread principal n'exécute une tâche publiée, seule la dernière valeur serait distribuée.

Ce n'est pas une réponse directe au problème ci-dessus. Les réponses de Sagar et w201 sont géniales. Mais une règle de base simple que j'utilise dans ViewModels pour MutableLiveData est:

private boolean isMainThread() {
    return Looper.myLooper() == Looper.getMainLooper();
}

private MutableLiveData<Boolean> mutVal = new MutableLiveData<>(false);
public LiveData<Boolean> getMutVal() { return this.mutVal;  }
public void setMutVal(boolean val) {
    if (isMainThread()) mutVal.setValue(val);
    else mutVal.postValue(val);
}

Remplacez mutValpar la valeur souhaitée.

setValue()La méthode doit être appelée à partir du thread principal. Si vous avez besoin de définir une valeur à partir d'un thread d'arrière-plan, vous pouvez utiliserpostValue() .

Plus ici .

Dans notre application, nous avions utilisé un seul LiveData qui contient des données pour plusieurs vues dans une activité / un écran. Fondamentalement, N pas de jeux de données pour N pas de vues. Cela nous a un peu dérangés parce que la façon dont postData est conçu. Et nous avons un objet d'état dans LD qui indique quelle vue doit être mise à jour.

donc LD ressemble à ceci:

LD {
   state (view_1, view_2, view_3 …),
   model_that_contains_data_of_all_views
}

Il y a quelques vues (view_1 et view_2) qui ont dû être mises à jour lorsqu'un événement se produit. Cela signifie qu'elles doivent être notifiées en même temps lorsqu'un événement se produit. Alors, j'ai appelé:

postData(LD(view_1, data))
postData(LD(view_2, data)

Cela ne fonctionnerait pas pour des raisons que nous connaissons.

Ce que j'ai compris, c'est que fondamentalement, un LD ne devrait représenter qu'une seule vue. Alors il n'y a aucune chance que vous ayez à appeler postData () deux fois de suite. Même si vous appelez, la façon dont postData le gère pour vous est ce à quoi vous vous attendez également (montrant les dernières données pour vous). Tout tombe bien en place.

Un LD -> une vue. PARFAIT

Un LD -> plusieurs vues IL PEUT ÊTRE UN COMPORTEMENT ÉTRANGE