android-lifecycle - Android MediatorLiveData 将多个 LiveData 结果组合成单个 LiveData 对象（在 Java 中）

Question

我使用 2 LiveDatas 从单独的表到我的应用程序的存储库中。我将这两个LiveDatas 作为源添加到CustomMediatorLiveData扩展的类中MediatorLiveData。在each 方法的onChanged回调中，我将两个s 的值发送到一个将两者结合并返回一个设置为对象的单个方法中。我在我的存储库中创建了一个对象，并将这两个s 作为构造函数的参数传递。addSourceLiveDataLiveDataLiveDatavalueCustomMediatorLiveDataCustomMediatorLiveDataLiveData

这会运行并且不会给出任何错误，但它会弄乱 LiveData 本身的数据。

示例：如果日期最初是 2020 年 8 月 15 日，那么它可能类似于 0001 年 8 月 14 日。

CustomMediatorLiveData：

public class CustomMediatorLiveData extends MediatorLiveData<List<Object>> {
    private List<Note> notes = Collections.emptyList();
    private List<RecurringTask> recurringTasks = Collections.emptyList();

    public CustomMediatorLiveData(LiveData<List<Note>> liveNotes, LiveData<List<RecurringTask>> liveRecurringTasks) {
        addSource(liveNotes, notes1 -> {
            if (notes1 != null) {
                this.notes = notes1;
            }
            setValue(combineData(notes,recurringTasks));
        });

        addSource(liveRecurringTasks, recurringTasks1 -> {
            if (recurringTasks1 != null) {
                this.recurringTasks = recurringTasks1;
            }
            setValue(combineData(notes,recurringTasks));
        });
    }


    // This method adds the 2 lists into one and sorts them based on dates and priority.
    
    private List<Object> combineData(List<Note> notes, List<RecurringTask> recurringTasks) {
        List<Object> combinedList = new ArrayList<>();
        if (notes != null && !notes.isEmpty())
            combinedList.addAll(notes);
        if(recurringTasks!=null && !recurringTasks.isEmpty())
        combinedList.addAll(recurringTasks);

        Collections.sort(combinedList, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                Date d1, d2;
                Note n1 = null, n2 = null;
                RecurringTask r1 = null, r2 = null;

                if (o1 instanceof Note && o2 instanceof Note) {
                    int hmm = Boolean.compare(((Note) o2).isPriority(), ((Note) o1).isPriority());
                    if (hmm != 0)
                        return hmm;
                }

                if (o1 instanceof Note) {
                    d1 = ((Note) o1).getEnd_date();
                    n1 = ((Note) o1);
                } else {
                    d1 = ((RecurringTask) o1).getEnd_date();
                    r1 = ((RecurringTask) o1);
                }

                if (o2 instanceof Note) {
                    d2 = ((Note) o2).getEnd_date();
                    n2 = ((Note) o2);
                } else {
                    d2 = ((RecurringTask) o2).getEnd_date();
                    r2 = ((RecurringTask) o2);
                }

                if (n1 != null) {
                    if (r2 != null) {
                        if (n1.isPriority()) {
                            return -1;
                        }
                    }
                }

                if (n2 != null) {
                    if (r1 != null) {
                        if (n2.isPriority()) {
                            return 1;
                        }
                    }
                }

                long l1 = d1.getTime() - d2.getTime();

                if (l1 > 0) {
                    return 1;
                } else if (l1 < 0) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });

        return combinedList;

    }
}

注意存储库类：

public class NoteRepository {

    private String DB_NAME = "db_task";

    Context context;
    private RecurringDao recurringDao; 
    private LiveData<List<RecurringTask>> upcomingRecurringTasks;
    private LiveData<List<Note>> upcomingTasks;
    private CustomMediatorLiveData customMediatorLiveData;

    private NoteDatabase noteDatabase;

    public NoteRepository(Context context) {
        noteDatabase = NoteDatabase.getInstance(context);

        recurringDao = noteDatabase.recurringDao();

        upcomingRecurringTasks = recurringDao.getUpcomingRecurringTask();
        upcomingTasks = noteDatabase.daoAccess().fetchUpcomingTasks();

        this.context = context;

        customMediatorLiveData = new CustomMediatorLiveData(upcomingTasks, upcomingRecurringTasks);

    }

    public LiveData<List<Object>> getCustomMediatorLiveData() {
        return customMediatorLiveData;
    }

    public LiveData<List<RecurringTask>> getUpcomingRecurringTasks() {
        return upcomingRecurringTasks;
    }

    public LiveData<List<Note>> fetchUpcomingTasks() {
        return NoteDatabase.getInstance(context).daoAccess().fetchUpcomingTasks();
    }


}

我尝试使用该MediatorLiveData对象并将两个LiveData源添加到存储库本身中，但同样的问题仍然存在。

实现这一点的正确方法是什么？如何将 2 LiveDatas 组合成一个LiveData可以观察到的单个。