Como atualizar o LiveData de um ViewModel do serviço de segundo plano e Atualizar UI

Recentemente, estou explorando a arquitetura Android, que foi introduzida recentemente pelo Google. Na documentação , encontrei o seguinte:

public class MyViewModel extends ViewModel {
    private MutableLiveData<List<User>> users;
    public LiveData<List<User>> getUsers() {
        if (users == null) {
            users = new MutableLiveData<List<Users>>();
            loadUsers();
        }
        return users;
    }

    private void loadUsers() {
        // do async operation to fetch users
    }
}

a atividade pode acessar essa lista da seguinte maneira:

public class MyActivity extends AppCompatActivity {
    public void onCreate(Bundle savedInstanceState) {
        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
        model.getUsers().observe(this, users -> {
            // update UI
        });
    }
}

Minha pergunta é, vou fazer isso:

1. na loadUsers()função, estou buscando os dados de forma assíncrona, onde primeiro verificarei o banco de dados (Room) para esses dados

2. Se eu não conseguir os dados lá, farei uma chamada de API para buscar os dados do servidor web.

3. Vou inserir os dados buscados no banco de dados (Room) e atualizar a IU de acordo com os dados.

Qual é a abordagem recomendada para fazer isso?

Se eu começar Servicea chamar a API a partir do loadUsers()método, como posso atualizar a MutableLiveData<List<User>> usersvariável a partir disso Service?

Presumo que você esteja usando componentes de arquitetura Android . Na verdade, não importa onde você está ligando service, asynctask or handlerpara atualizar os dados. Você pode inserir os dados do serviço ou da asynctask usando o postValue(..)método. Sua classe ficaria assim:

private void loadUsers() {
    // do async operation to fetch users and use postValue() method
    users.postValue(listOfData)
}

Como usersestá LiveData, o Roombanco de dados é responsável por fornecer os dados dos usuários onde quer que esteja inserido.

Note: Na arquitetura tipo MVVM, o repositório é principalmente responsável por verificar e puxar dados locais e dados remotos.

Você pode usar o MutableLiveData<T>.postValue(T value)método do thread em segundo plano.

private void loadUsers() {
    // do async operation to fetch users and use postValue() method
   users.postValue(listOfData)
}

... na função loadUsers () estou buscando os dados de forma assíncrona ... Se eu iniciar um serviço para chamar a API do método loadUsers (), como posso atualizar a variável MutableLiveData> users desse serviço?

Se o aplicativo estiver buscando dados do usuário em um thread de segundo plano, postValue (em vez de setValue ) será útil.

No método loadData, há uma referência ao objeto "usuários" MutableLiveData. O método loadData também busca alguns dados novos do usuário em algum lugar (por exemplo, um repositório).

Agora, se a execução for em um thread de segundo plano, MutableLiveData.postValue () atualiza observadores externos do objeto MutableLiveData.

Talvez algo assim:

private MutableLiveData<List<User>> users;

.
.
.

private void loadUsers() {
    // do async operation to fetch users
    ExecutorService service =  Executors.newSingleThreadExecutor();
    service.submit(new Runnable() {
        @Override
        public void run() {
            // on background thread, obtain a fresh list of users
            List<String> freshUserList = aRepositorySomewhere.getUsers();

            // now that you have the fresh user data in freshUserList, 
            // make it available to outside observers of the "users" 
            // MutableLiveData object
            users.postValue(freshUserList);        
        }
    });

}

Dê uma olhada no guia de arquitetura do Android que acompanha os novos módulos de arquitetura como LiveDatae ViewModel. Eles discutem exatamente esse assunto em profundidade.

Em seus exemplos, eles não o colocam em serviço. Dê uma olhada em como eles resolvem isso usando um módulo de "repositório" e Retrofit. Os adendos na parte inferior incluem exemplos mais completos, incluindo comunicação do estado da rede, relatórios de erros, etc.

Se você está chamando sua API no Repositório, então,

No Repositório :

public MutableLiveData<LoginResponseModel> checkLogin(LoginRequestModel loginRequestModel) {
    final MutableLiveData<LoginResponseModel> data = new MutableLiveData<>();
    apiService.checkLogin(loginRequestModel)
            .enqueue(new Callback<LoginResponseModel>() {
                @Override
                public void onResponse(@NonNull Call<LoginResponseModel> call, @Nullable Response<LoginResponseModel> response) {
                    if (response != null && response.isSuccessful()) {
                        data.postValue(response.body());
                        Log.i("Response ", response.body().getMessage());
                    }
                }

                @Override
                public void onFailure(@NonNull Call<LoginResponseModel> call, Throwable t) {
                    data.postValue(null);
                }
            });
    return data;
}

Em ViewModel

public LiveData<LoginResponseModel> getUser() {
    loginResponseModelMutableLiveData = repository.checkLogin(loginRequestModel);
    return loginResponseModelMutableLiveData;
}

Em atividade / fragmento

loginViewModel.getUser().observe(LoginActivity.this, loginResponseModel -> {
        if (loginResponseModel != null) {
            Toast.makeText(LoginActivity.this, loginResponseModel.getUser().getType(), Toast.LENGTH_SHORT).show();
        }
    });

Observação: usando JAVA_1.8 lambda aqui, você pode usar sem ele