So aktualisieren Sie LiveData eines ViewModel über den Hintergrunddienst und die Update-Benutzeroberfläche

Kürzlich beschäftige ich mich mit Android-Architektur, die kürzlich von Google eingeführt wurde. Aus der Dokumentation habe ich folgendes 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:

1. In der loadUsers()Funktion rufe ich die Daten asynchron ab, wobei ich zuerst die Datenbank (Raum) auf diese Daten überprüfe

2. Wenn ich die Daten dort nicht erhalte, werde ich einen API-Aufruf durchführen, um die Daten vom Webserver abzurufen.

3. Ich werde die abgerufenen Daten in die Datenbank (Raum) einfügen und die Benutzeroberfläche entsprechend den Daten aktualisieren.

Was ist der empfohlene Ansatz, um dies zu tun?

Wie kann ich die Variable von dort aktualisieren, wenn ich a starte Service, um die API über die loadUsers()Methode aufzurufen ?MutableLiveData<List<User>> usersService

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

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

Da das usersist LiveData, Roomist Datenbank verantwortlich für die Datennutzer überall dort , wo es eingesetzt wird.

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

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

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

... in der Funktion loadUsers () rufe ich die Daten asynchron ab ... Wenn ich einen Dienst zum Aufrufen der API über die Methode loadUsers () starte, wie kann ich die Variable MutableLiveData> users von diesem Dienst aktualisieren?

Wenn die App Benutzerdaten in einem Hintergrundthread abruft , ist postValue (anstelle von setValue ) hilfreich.

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

Wenn sich die Ausführung in einem Hintergrundthread befindet, wird MutableLiveData.postValue () außerhalb der Beobachter des MutableLiveData-Objekts aktualisiert.

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

}

Schauen Sie sich den Android-Architekturleitfaden an , der die neuen Architekturmodule wie LiveDataund begleitet ViewModel. Sie diskutieren genau dieses Thema ausführlich.

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

Wenn Sie Ihre API im Repository aufrufen, dann

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

In ViewModel

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

In 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 hier JAVA_1.8 Lambda verwenden, können Sie es auch ohne verwenden