Android 从LiveData（房间数据库）填充微调器

我在哪里

我正在尝试使用Room用数据库中的数据填充微调器。数据是一个术语列表，其中包含与之相关的课程

我想在创建新课程时使用微调器，以选择与之关联的术语

当前，微调器不显示默认选项，但如果单击微调器，它将显示要从中选择的数据列表。从微调器中选择某个对象后，它不会显示所选内容

以下是我将数据加载到微调器适配器的代码：

        termsList = new ArrayList<>();
        termIdList = new ArrayList<>();
        mTermViewModel = new ViewModelProvider(this).get(TermViewModel.class);
        mTermViewModel.getAllTerms().observe(this, new Observer<List<TermEntity>>() {
            @Override
            public void onChanged(@Nullable final List<TermEntity> terms) {
                for (TermEntity term : terms) {
                    termsList.add(term.getTermName());
                    termIdList.add(term.getTermId());
                }
            }
        });

        ArrayAdapter<String> adapter = new ArrayAdapter<>(getContext(), android.R.layout.simple_spinner_item, termsList);
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        mTermSpinner.setAdapter(adapter);
    }

termsList=newarraylist（）；
termIdList=newarraylist（）；
mTermViewModel=newViewModelProvider（this.get）（TermViewModel.class）；
mTermViewModel.getAllTerms（）.observe（这是一个新的观察者（）{
@凌驾
更改后的公共void（@Nullable final List terms）{
用于（术语实体术语：术语）{
termsList.add（term.getTermName（））；
添加（term.getTermId（））；
}
}
});
ArrayAdapter=新的ArrayAdapter（getContext（），android.R.layout.simple\u微调器\u项，termsList）；
setDropDownViewResource（android.R.layout.simple\u微调器\u下拉菜单\u项）；
mTermSpinner.setAdapter（适配器）；
}

这是术语

@Dao
public interface TermDAO {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    void insert(TermEntity term);

    @Query("DELETE FROM terms")
    void deleteAllTerms();

    @Query("SELECT * FROM terms ORDER BY termId ASC")
    LiveData<List<TermEntity>> getAllTerms();

    @Query("SELECT * FROM terms WHERE termId = :termId")
    LiveData<List<TermEntity>> getTerm(int termId);

    @Query("SELECT termId FROM terms WHERE termName = :termName")
    LiveData<List<TermEntity>> getTermIdByTermName(String termName);
}

@Dao
公共接口TermDAO{
@插入（onConflict=OnConflictStrategy.REPLACE）
无效插入（术语实体术语）；
@查询（“从术语中删除”）
void deleteAllTerms（）；
@查询（“按术语ID ASC从术语订单中选择*）
LiveData getAllTerms（）；
@查询（“从术语中选择*，其中termId=：termId”）
LiveData getTerm（int termId）；
@查询（“从termName=：termName的术语中选择termId”）
LiveData getTermIdByTermName（字符串termName）；
}

这是术语视图模型

public class TermViewModel extends AndroidViewModel {
    private SchoolTrackerRepository mRepository;
    private LiveData<List<TermEntity>> mAllTerms;

    public TermViewModel(@NonNull Application application) {
        super(application);
        mRepository = new SchoolTrackerRepository(application);
        mAllTerms = mRepository.getAllTerms();
    }

    public LiveData<List<TermEntity>> getAllTerms() {
        return mAllTerms;
    }

    public void insert(TermEntity termEntity) {
        mRepository.insert(termEntity);
    }
}

公共类TermViewModel扩展了AndroidViewModel{
私立学校田径场；
私有LiveData术语；
公共术语视图模型（@NonNull应用程序）{
超级（应用）；
mRepository=新学校跟踪报告（申请）；
mAllTerms=mRepository.getAllTerms（）；
}
公共LiveData getAllTerms（）{
返回条件；
}
公共作废插入（术语实体术语实体）{
mRepository.insert（术语实体）；
}
}

我想在微调器中显示术语名称，并使用相应的termId执行查询

我尝试过的

我曾尝试使用可变LiveData而不是LiveData，但当我尝试运行它时，出现了一个错误，错误是：

错误：不确定如何将游标转换为此方法的返回类型

我真是不知所措。谢谢你的帮助

添加了存储库

public class SchoolTrackerRepository {
    private TermDAO mTermDAO;
    private CourseDAO mCourseDAO;
    int termId;
    private LiveData<List<TermEntity>> mAllTerms;
    private LiveData<List<CourseEntity>> mAllCourses;
    private LiveData<List<CourseEntity>> mAssociatedCourses;

    public SchoolTrackerRepository(Application application) {
        SchoolTrackerDatabase db = SchoolTrackerDatabase.getDatabase(application);
        mTermDAO = db.termDAO();
        mCourseDAO = db.courseDAO();

        mAllTerms = mTermDAO.getAllTerms();
        mAllCourses = mCourseDAO.getAllCourses();
    }

    public LiveData<List<TermEntity>> getAllTerms() {
        return mAllTerms;
    }

    public LiveData<List<CourseEntity>> getAllCourses() {
        return mAllCourses;
    }

    public LiveData<List<CourseEntity>> getmAssociatedCourses(int termId) {
        return mAssociatedCourses;
    }

    public void insert(TermEntity termEntity) {
        new insertAsyncTask1(mTermDAO).execute(termEntity);
    }

    private static class insertAsyncTask1 extends AsyncTask<TermEntity, Void, Void> {
        private TermDAO mAsyncTaskDAO;

        insertAsyncTask1(TermDAO dao) {
            mAsyncTaskDAO = dao;
        }

        @Override
        protected Void doInBackground(final TermEntity... params) {
            mAsyncTaskDAO.insert(params[0]);
            return null;
        }
    }

    public void insert(CourseEntity courseEntity) {
        new insertAsyncTask2(mCourseDAO).execute(courseEntity);
    }

    private static class insertAsyncTask2 extends AsyncTask<CourseEntity, Void, Void> {
        private CourseDAO mAsyncCourseDAO;

        insertAsyncTask2(CourseDAO dao) {
            mAsyncCourseDAO = dao;
        }

        @Override
        protected Void doInBackground(final CourseEntity... params) {
            mAsyncCourseDAO.insert(params[0]);
            return null;
        }
    }
}

SchoolTrackerRepository公立学校{
私有TermDAO-mTermDAO；
私人课程Dao mCourseDAO；
国际术语；
私有LiveData术语；
私人直播课程；
私人LiveData MassaociatedCourses；
公立学校轨道存储库（应用程序）{
SchoolTrackerDatabase db=SchoolTrackerDatabase.getDatabase（应用程序）；
mTermDAO=db.termDAO（）；
mCourseDAO=db.courseDAO（）；
mAllTerms=mTermDAO.getAllTerms（）；
mAllCourses=mCourseDAO.getAllCourses（）；
}
公共LiveData getAllTerms（）{
返回条件；
}
公共LiveData getAllCourses（）{
返回课程；
}
公共LiveData GetMassAssociatedCourses（int termId）{
返回集体课程；
}
公共作废插入（术语实体术语实体）{
新的insertAsyncTask1（mTermDAO）.execute（termEntity）；
}
私有静态类insertAsyncTask1扩展了AsyncTask{
私人TermDAO mAsyncTaskDAO；
insertAsyncTask1（TermDAO dao）{
mAsyncTaskDAO=dao；
}
@凌驾
受保护的Void doInBackground（最终术语实体…参数）{
mAsyncTaskDAO.insert（参数[0]）；
返回null；
}
}
公共无效插入（CourseEntity CourseEntity）{
新的insertAsyncTask2（mCourseDAO）.execute（courseEntity）；
}
私有静态类insertAsyncTask2扩展了AsyncTask{
私人课程Dao mAsyncCourseDAO；
insertAsyncTask2（课程道道）{
mAsyncCourseDAO=dao；
}
@凌驾
受保护的空白背景（最终课程资格…参数）{
mAsyncCourseDAO.insert（参数[0]）；
返回null；
}
}
}

我猜您在更新

termsList

变量后缺少NOTIFYDATASETCHANGE

尝试一下这个：

ArrayAdapter<String> adapter = new ArrayAdapter<>(getContext(), android.R.layout.simple_spinner_item, termsList);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mTermSpinner.setAdapter(adapter);

mTermViewModel = new ViewModelProvider(this).get(TermViewModel.class);
mTermViewModel.getAllTerms().observe(this, new Observer<List<TermEntity>>() {
    @Override
    public void onChanged(@Nullable final List<TermEntity> terms) {
        for (TermEntity term : terms) {
            termsList.add(term.getTermName());
            termIdList.add(term.getTermId());
        }

        //notifyDataSetChanged after update termsList variable here
        adapter.notifyDataSetChanged();
    }
});

ArrayAdapter adapter=新的ArrayAdapter（getContext（），android.R.layout.simple\u spinner\u项，termsList）；
setDropDownViewResource（android.R.layout.simple\u微调器\u下拉菜单\u项）；
mTermSpinner.setAdapter（适配器）；
mTermViewModel=newViewModelProvider（this.get）（TermViewModel.class）；
mTermViewModel.getAllTerms（）.observe（这是一个新的观察者（）{
@凌驾
更改后的公共void（@Nullable final List terms）{
用于（术语实体术语：术语）{
termsList.add（term.getTermName（））；
添加（term.getTermId（））；
}
//更新termsList变量后notifyDataSetChanged在此
adapter.notifyDataSetChanged（）；
}
});

在这里写下你的

SchoolTrackerRepository

代码我已经添加了存储库。就是这样！我必须在onChanged（）之前声明适配器。非常感谢你。