Android 在领域中实现回调并在presenter MVP中设置它以进行异步工作

在第一个问题中，我的方法是加载异步数据，当我从presenter完成1个方法时，我调用了第二个方法，但此时仍然加载了数据。在那之后，我解决了这个问题，我需要设置一些对realm方法的回调，以确保我的数据已加载，下载之后，我需要从数据库中获取数据并在视图中反映。但是我在实现接口方面有一些问题。最好的方法是什么？我将尝试编写以下代码：

在我的演示者中：

getViewState().showListProgress();
    repository.loadDataFromNetworkToDB();

    List<Anime> animeList = repository.loadDataFromDbToPresenter();
    if (animeList.size() == 0) {
        System.out.println("you are loosing!S");
        Throwable error = new Throwable();
        onLoadingFailed(error);
    } else {
        onLoadingFinish();
        onLoadingSuccess(animeList);
    }

@Override
public void loadData() {
    view.onDataStarted();

    repository.getAnimeFromNetwork();

    liveData = repository.findAnimes();

    liveData.observeForever(new Observer<RealmResults<Anime>>() {
        @Override
        public void onChanged(@Nullable RealmResults<Anime> animes) {
            if (animes != null) {
                if (animes.size() == 0) {
                    //nothing
                    System.out.println("Result realmResult: " + animes.size());
                } else {
                    view.onDataCompleted();
                    System.out.println("My result before Background sticky concurrent mark sweep GC: " + animes.size());
                    List<Anime> animeList = new ArrayList<>();
                    animeList.addAll(animes);
                    view.showData(animeList);
                    //Trying to stop liveData - helplessness
                    liveData.removeObserver(this::onChanged);
                }
            } else {
                System.out.println("null" + animes);
            }
        }
    });

之后，我从网络下载数据，并在模型中使用了两个功能：

public void loadDataFromNetworkToDB() {
    Realm realm = Realm.getDefaultInstance();

    ghibliService.getAnimeList()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(list -> {
                AnimeDbHelper dbHelper = new AnimeDbHelper(realm, list);
                dbHelper.saveToDatabase(this);
            });
}

@Override
public List<Anime> loadDataFromDbToPresenter() {
    List<Anime> animeList = new ArrayList<>();
    Realm realm = Realm.getDefaultInstance();
    try {
        final RealmResults<Anime> animeResults = realm.where(Anime.class).findAll();
        for (int i = 0; i < animeResults.size(); i++) {
            animeList.add(animeResults.get(i).toEntity());
        }
    } finally {
        if (realm != null) {
            realm.close();
        }
    }
    return animeList;

}

@Override
public boolean onRealmSuccess() {
    System.out.println("Success");
    return true;
}

@Override
public boolean onRealmError() {
    System.out.println("Error");
    return false;
}

public void loadDataFromNetworkToDB（）{
Realm Realm=Realm.getDefaultInstance（）；
吉卜力副作用。getAnimeList（）
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（列表->{
AnimeDbHelper dbHelper=新的AnimeDbHelper（领域，列表）；
dbHelper.saveToDatabase（此）；
});
}
@凌驾
公共列表loadDataFromDbToPresenter（）{
List animeList=new ArrayList（）；
Realm Realm=Realm.getDefaultInstance（）；
试一试{
final RealmResults animeResults=realm.where（Anime.class）.findAll（）；
for（int i=0；i

好的，下面的代码解决了我的问题，但是在我得到更新的列表对象后，我捕获了如下异常：

I/art: Background sticky concurrent mark sweep GC freed 5614(449KB) AllocSpace objects, 18(288KB) LOS objects, 33% free, 1691KB/2MB, paused 5.354ms total 10.731ms
I/art: Background sticky concurrent mark sweep GC freed 7039(557KB) AllocSpace objects, 22(352KB) LOS objects, 39% free, 1561KB/2MB, paused 10.554ms total 15.931ms 

显然，演示者应该有自己的生命周期，我们需要在某个地方删除liveData。 在我的模型中：

public RealmLiveData<Anime> findAnimes() {
    Realm realm = Realm.getDefaultInstance();
    RealmLiveData<Anime> realmLiveData;
    try {
        realmLiveData = new RealmLiveData<>(realm.where(Anime.class).findAllAsync());
    } finally {
        if (realm != null) {
            realm.close();
        }
    }
    return realmLiveData;
}

public RealmLiveData findAnimes（）{
Realm Realm=Realm.getDefaultInstance（）；
RealmLiveData RealmLiveData；
试一试{
realmLiveData=newrealmlivedata（realm.where（Anime.class.findalsync（））；
}最后{
if（realm！=null）{
realm.close（）；
}
}
返回realmLiveData；
}

在我的演示者中：

getViewState().showListProgress();
    repository.loadDataFromNetworkToDB();

    List<Anime> animeList = repository.loadDataFromDbToPresenter();
    if (animeList.size() == 0) {
        System.out.println("you are loosing!S");
        Throwable error = new Throwable();
        onLoadingFailed(error);
    } else {
        onLoadingFinish();
        onLoadingSuccess(animeList);
    }

@Override
public void loadData() {
    view.onDataStarted();

    repository.getAnimeFromNetwork();

    liveData = repository.findAnimes();

    liveData.observeForever(new Observer<RealmResults<Anime>>() {
        @Override
        public void onChanged(@Nullable RealmResults<Anime> animes) {
            if (animes != null) {
                if (animes.size() == 0) {
                    //nothing
                    System.out.println("Result realmResult: " + animes.size());
                } else {
                    view.onDataCompleted();
                    System.out.println("My result before Background sticky concurrent mark sweep GC: " + animes.size());
                    List<Anime> animeList = new ArrayList<>();
                    animeList.addAll(animes);
                    view.showData(animeList);
                    //Trying to stop liveData - helplessness
                    liveData.removeObserver(this::onChanged);
                }
            } else {
                System.out.println("null" + animes);
            }
        }
    });

@覆盖
公共void loadData（）{
view.onDataStarted（）；
getAnimeFromNetwork（）；
liveData=repository.findAnimes（）；
liveData.observeForver（新的观察者（）{
@凌驾
更改后的公共无效（@Nullable RealmResults animes）{
如果（动画！=null）{
如果（animes.size（）==0）{
//没什么
System.out.println（“结果realmResult:+animes.size（））；
}否则{
view.onDataCompleted（）；
System.out.println（“背景粘性并发标记扫描GC:+animes.size（）之前的我的结果”）；
List animeList=new ArrayList（）；
动物学家。阿达尔（动画）；
view.showData（动物列表）；
//试图阻止liveData-无助
removeObserver（this:：onChanged）；
}
}否则{
System.out.println（“空”+动画）；
}
}
});

RealmLiveData：

public class RealmLiveData<T extends RealmModel> extends LiveData<RealmResults<T>> {
private RealmResults<T> results;
private final RealmChangeListener<RealmResults<T>> listener =
        new RealmChangeListener<RealmResults<T>>() {
            @Override
            public void onChange(RealmResults<T> results) {
                setValue(results);
            }
        };
public RealmLiveData(RealmResults<T> realmResults) {
    results = realmResults;
}
@Override
protected void onActive() {
    results.addChangeListener(listener);
}
@Override
protected void onInactive() {
    results.removeChangeListener(listener);
}

公共类RealmLiveData扩展了LiveData{
私人地产结果；
私有最终RealmChangeListener侦听器=
新的RealmChangeListener（）{
@凌驾
更改后的公共void（RealmResults结果）{
设定值（结果）；
}
};
公共RealmLiseData（RealmResults RealmResults）{
结果=真实结果；
}
@凌驾
受保护的void onActive（）{
结果：addChangeListener（listener）；
}
@凌驾
受保护的void onInactive（）{
结果：removeChangeListener（listener）；
}

下载后，我需要从数据库中获取数据并在视图中反映。

为什么不使用LiveData？如何使用LiveData解决问题？只需查看数据，然后调用repository.loadDataFromDbToPresenter（），我得到的大小是0。我是否应该在循环中重复它，直到得到一些数据？如果使用添加到

RealmResults

中的

RealmChangeListener

，则不需要在

onTransactionCall.onRealmSuccess（）；

中重新加载数据（并且RealmResults保留为字段引用）使用

observeForever

并在观察者中删除观察者而不是按原计划使用观察者的任何特定原因：（在onCreateView中订阅，在onDestroyView中删除观察者）？因为我使用了另一个库，其中演示者的状态在活动旋转时保存等。因此，我需要拒绝此路径并从ViewModel扩展，并使用google的一些ArhitArchitecture组件。老实说，我只是指使用

observe（lifecycleOwner，{…

依靠自动取消订阅这个答案有助于我找到正确的解决方案。