Diferença de setValue () e postValue () em MutableLiveData

Existem duas maneiras de alterar o valor de MutableLiveData. Mas qual é a diferença entre setValue()e postValue()em MutableLiveData.

Não consegui encontrar documentação para o mesmo.

Aqui está a aula MutableLiveDatade 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);
    }
}

Com base na documentação:

setValue () :

Define o valor. Se houver observadores ativos, o valor será despachado para eles. Este método deve ser chamado a partir do thread principal.

postValue () :

Publica uma tarefa em um thread principal para definir o valor fornecido. Se você chamar esse método várias vezes antes de um thread principal executar uma tarefa postada, apenas o último valor será despachado.

Para resumir, a principal diferença seria:

setValue()método deve ser chamado a partir do thread principal. Mas se você precisar definir um valor de um thread de segundo plano, postValue()deve ser usado.

Todas as respostas acima estão corretas. Mas mais uma diferença importante. Se você chamar postValue()em um campo que não tem observadores e depois ligar getValue(), você não receberá o valor que definiu em postValue(). Portanto, tome cuidado se você trabalhar em threads de fundo sem observadores.

setValue()é chamado diretamente do thread do chamador, notifica os observadores de forma síncrona e altera o LiveDatavalor imediatamente. Ele pode ser chamado apenas a partir de MainThread.
postValue()usa dentro de algo como isso new Handler(Looper.mainLooper()).post(() -> setValue()), então ele é executado setValueatravés Handlerde MainThread. Ele pode ser chamado de qualquer thread.

setValue()

Define o valor. Se houver observadores ativos, o valor será despachado para eles.

Este método deve ser chamado a partir do thread principal .

postValue

Se você precisar definir um valor de um thread de segundo plano, você pode usar postValue(Object)

Publica uma tarefa em um thread principal para definir o valor fornecido.

Se você chamar esse método várias vezes antes de um thread principal executar uma tarefa postada, apenas o último valor será despachado.

Esta não é uma resposta direta ao problema acima. As respostas de Sagar e w201 são fantásticas. Mas uma regra prática simples que uso em ViewModels para MutableLiveData é:

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

Substitua mutValpelo valor desejado.

setValue()método deve ser chamado a partir do thread principal. Se você precisar definir um valor de um thread de segundo plano, você pode usarpostValue() .

Mais aqui .

Em nosso aplicativo, usamos um LiveData único que contém dados para várias visualizações em uma atividade / tela. Basicamente, N não de conjuntos de dados para N de visualizações. Isso nos incomodou um pouco, devido à forma como o postData foi projetado. E temos objeto de estado em LD que transmite a visão sobre qual visão precisa ser atualizada.

então LD se parece com isto:

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

Existem algumas visualizações (view_1 e view_2) que tiveram que ser atualizadas quando um evento ocorre ... significa que elas devem ser notificadas ao mesmo tempo quando o evento ocorre. Então, liguei:

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

Isso não funcionaria por razões que conhecemos.

O que entendi é que basicamente um LD deve representar apenas uma visão. Então, não há chance de você ter que chamar postData () duas vezes seguidas. Mesmo se você chamar, a maneira como postData lida com isso para você é o que você também esperaria (mostrando os dados mais recentes para você na visualização). Tudo cai bem no lugar.

Um LD -> uma Visualização. PERFEITO

Um LD -> visualizações múltiplas PODE EXISTIR UM COMPORTAMENTO ESTRANHO