So aktualisieren Sie LiveData eines ViewModel vom Hintergrunddienst und aktualisieren die Benutzeroberfläche

Question 1

Vor kurzem erkunde ich die Android-Architektur, die kürzlich von Google eingeführt wurde. Von dem Dokumentation Ich habe das gefunden:

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

Die Aktivität kann wie folgt auf diese Liste zugreifen:

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

Meine Frage ist, ich werde dies tun:

in dem loadUsers() Funktion rufe ich die Daten asynchron ab, wobei ich zuerst die Datenbank (Raum) auf diese Daten überprüfen werde

Wenn ich die Daten dort nicht erhalte, mache ich einen API-Aufruf, um die Daten vom Webserver abzurufen.
Ich werde die abgerufenen Daten in die Datenbank (Raum) einfügen und die Benutzeroberfläche entsprechend den Daten aktualisieren.

Was ist die empfohlene Vorgehensweise, um dies zu tun?

Wenn ich ein beginne Service um die API von der aufzurufen loadUsers() Methode, wie kann ich die aktualisieren MutableLiveData<List<User>> users davon variabel Service?

Question 2

Ich gehe davon aus, dass Sie verwenden Komponenten der Android-Architektur. Eigentlich ist es egal, wo Sie anrufen service, asynctask or handler um die Daten zu aktualisieren. Sie können die Daten aus dem Dienst oder aus der Asynctask mit einfügen postValue(..) Methode. Ihre Klasse würde so aussehen:

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

Als die users ist LiveData, Room Die Datenbank ist dafür verantwortlich, Benutzerdaten bereitzustellen, wo immer sie eingefügt werden.

Note: In einer MVVM-ähnlichen Architektur ist das Repository hauptsächlich für das Überprüfen und Abrufen lokaler Daten und entfernter Daten verantwortlich.

Question 3

Sie können verwenden MutableLiveData<T>.postValue(T value) Methode aus dem Hintergrundthread.

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

Question 4

… in der Funktion loadUsers() rufe ich die Daten asynchron ab … Wenn ich einen Dienst starte, um die API von der Methode loadUsers() aufzurufen, wie kann ich dann die MutableLiveData>-Benutzervariable von diesem Dienst aktualisieren?

Wenn die App Benutzerdaten in einem Hintergrundthread abruft, postValue (statt setValue) wird nützlich sein.

In der Methode loadData gibt es einen Verweis auf das Objekt MutableLiveData “users”. Die loadData-Methode ruft auch einige neue Benutzerdaten von irgendwoher ab (z. B. einem Repository).

Wenn nun die Ausführung in einem Hintergrund-Thread erfolgt, aktualisiert MutableLiveData.postValue() externe Beobachter des MutableLiveData-Objekts.

Vielleicht so etwas:

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

}

Question 5

Werfen Sie einen Blick auf die Leitfaden zur Android-Architektur das begleitet die neuen Architekturmodule wie LiveData und ViewModel. Sie diskutieren genau dieses Thema eingehend.

In ihren Beispielen setzen sie es nicht in einen Dienst. Schauen Sie sich an, wie sie es mit einem „Repository“-Modul und Retrofit lösen. Die Anhänge unten enthalten vollständigere Beispiele, einschließlich der Übermittlung des Netzwerkstatus, der Meldung von Fehlern usw.

Question 6

Wenn Sie Ihre API dann im Repository aufrufen,

Im Repository:

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

Im ViewModel

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

Im Aktivität/Fragment

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

Hinweis: Wenn Sie JAVA_1.8 Lambda hier verwenden, können Sie ohne es verwenden