Fatal编程技术网
  • android/
  • Android 如何使用行ID将数据加载到详细信息活动中？

Android 如何使用行ID将数据加载到详细信息活动中？

android database

Android 如何使用行ID将数据加载到详细信息活动中？,android,database,repository,android-room,dao,Android,Database,Repository,Android Room,Dao,我使用android room架构构建了一个room数据库。现在，从一个recyclerview片段开始，当用户点击其中一个回收项目时，应用程序会带他详细了解该项目的活动 现在，我使用以下代码从片段发送项目ID： holder.parentLayout.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) {

我使用android room架构构建了一个room数据库。现在，从一个recyclerview片段开始，当用户点击其中一个回收项目时，应用程序会带他详细了解该项目的活动

现在，我使用以下代码从片段发送项目ID：

holder.parentLayout.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                Intent intent = new Intent(mContext.getContext(), MaterialItemView.class);
                intent.putExtra("ID", String.valueOf(mMaterial.get(position).getId()));
                mContext.startActivity(intent);
            }
它工作是因为ID到达了另一边

我需要帮助来使用ID解析或加载此数据到详细信息活动中。

这是我的详细活动：

  TextView mMaterialName;
    TextView mMaterialBrand;
    private RawMaterialViewModel mMaterialViewModel;
    private List<RawMaterialsEntity> mMaterial; // Cached copy of Materials
    RawMaterialsEntity rawMaterialsEntity;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.material_item_view);

        mMaterialName = findViewById(R.id.material_name_view);
        mMaterialBrand = findViewById(R.id.material_brand_view);

        mMaterialViewModel = new ViewModelProvider(this).get(RawMaterialViewModel.class);
        // Update the cached copy of the words in the adapter.

        Intent intent = getIntent();
        if (intent != null && intent.hasExtra("ID")) {
            int id = intent.getIntExtra("ID", -1);
            // TODO: get material details based on material id


        } else {
            // ...
        }

TextView材质名称；
TextView材料品牌；
私人原料模型-材料模型；
私人名单材料；//材料的缓存副本
原始材料实体原始材料实体；
@凌驾
创建时受保护的void（@Nullable Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.material\u item\u视图）；
mMaterialName=findViewById（R.id.material\u name\u视图）；
M材料品牌=findViewById（R.id.材料品牌视图）；
mMaterialViewModel=新的ViewModelProvider（this.get）（RawMaterialViewModel.class）；
//更新适配器中单词的缓存副本。
Intent=getIntent（）；
if（intent！=null&&intent.hasExtra（“ID”））{
int id=intent.getIntExtra（“id”，-1）；
//TODO:根据物料id获取物料详细信息
}否则{
// ...
}
这是我的刀：

@Dao
public interface RawMaterialsDao {

    @Insert
    void insertMaterial(RawMaterialsEntity rawMaterialsEntity);

    @Query("DELETE FROM raw_materials")
    void deleteAll();

    @Query("SELECT * FROM raw_materials WHERE material_name = :name")
    List<RawMaterialsEntity> findMaterial(String name);

    @Query("SELECT * FROM raw_materials WHERE id = :id")
    List<RawMaterialsEntity> findMaterialById(int id);

    @Query("DELETE FROM raw_materials WHERE material_name = :name")
    void deleteMaterial(String name);

    @Query("SELECT * from raw_materials")
    LiveData<List<RawMaterialsEntity>> getAllMaterials();

    @Query ("UPDATE raw_materials SET cost_per_gm = material_cost/material_weight")
    void divide();

    @Query ("UPDATE raw_materials SET total_cost = material_cost*material_quantity")
    void totalCost();

}

@Dao
公共接口RawMaterialsDao{
@插入
作废插入材料（RawMaterialsEntity RawMaterialsEntity）；
@查询（“从原材料中删除”）
void deleteAll（）；
@查询（“从原材料中选择*，其中材料名称=：名称”）
列表findMaterial（字符串名称）；
@查询（“从id=：id的原材料中选择*）
列出findMaterialById（int id）；
@查询（“从原材料中删除，其中材料名称=：名称”）
无效删除材料（字符串名称）；
@查询（“从原材料中选择*）
LiveData getAllMaterials（）；
@查询（“更新原材料设置成本每总经理=材料成本/材料重量”）
无效分割（）；
@查询（“更新原材料设置总成本=材料成本*材料数量”）
无效总成本（）；
}
我的存储库：

public class ChefsBoxRepository {

    private MutableLiveData<List<RawMaterialsEntity>> searchResults = new MutableLiveData<>();
    private LiveData<List<RawMaterialsEntity>> allMaterials;
    private RawMaterialsDao rawMaterialDao;

    //public constructor
    public ChefsBoxRepository(Application application) {
        ChefsBoxRoomDataBase db;
        db = ChefsBoxRoomDataBase.getDatabase(application);
        rawMaterialDao = db.rawMaterialDao();
        allMaterials = rawMaterialDao.getAllMaterials();

    }

    //used by the view model
    public LiveData<List<RawMaterialsEntity>> getAllMaterials() {
        return allMaterials;
    }
    //used by the view model
    public MutableLiveData<List<RawMaterialsEntity>> getSearchResults() {
        return searchResults;
    }

    public void insertMaterial(RawMaterialsEntity newMaterial) {
        InsertAsyncTask task = new InsertAsyncTask(rawMaterialDao);
        task.execute(newMaterial);
    }

    public void costPerGm(){
        CostPerGmAsyncTask task = new CostPerGmAsyncTask(rawMaterialDao);
        task.execute();
    }

    public void totalCost(){
        TotalCostAsyncTask task = new TotalCostAsyncTask(rawMaterialDao);
        task.execute();
    }
    public void deleteMaterial(String name) {
        DeleteAsyncTask task = new DeleteAsyncTask(rawMaterialDao);
        task.execute(name);
    }

    public void findMaterial(String name) {
        QueryAsyncTask task = new QueryAsyncTask(rawMaterialDao);
        task.delegate = this;
        task.execute(name);
    }

    public void findMaterialById(int id) {
        QueryAsyncTask2 task = new QueryAsyncTask2(rawMaterialDao);
        task.delegate = this;
        task.execute(id);
    }

    private void asyncFinished(List<RawMaterialsEntity> results) {
        searchResults.setValue(results);
    }

    //QueryAsyncTask for calling items from database
    private static class QueryAsyncTask extends
            AsyncTask<String, Void, List<RawMaterialsEntity>> {

        private RawMaterialsDao asyncTaskDao;
        private ChefsBoxRepository delegate = null;

        QueryAsyncTask(RawMaterialsDao dao) {
            asyncTaskDao = dao;
        }

        @Override
        protected List<RawMaterialsEntity> doInBackground(final String... params) {
            return asyncTaskDao.findMaterial(params[0]);
        }

        @Override
        protected void onPostExecute(List<RawMaterialsEntity> result) {
            delegate.asyncFinished(result);
        }
    }

    //QueryAsyncTask for calling items from database
    private static class QueryAsyncTask2 extends
            AsyncTask<Integer, Void, List<RawMaterialsEntity>> {

        private RawMaterialsDao asyncTaskDao;
        private ChefsBoxRepository delegate = null;

        QueryAsyncTask2(RawMaterialsDao dao) {
            asyncTaskDao = dao;
        }

        @Override
        protected List<RawMaterialsEntity> doInBackground(final Integer... params) {
            return asyncTaskDao.findMaterialById(params[0]);
        }

        @Override
        protected void onPostExecute(List<RawMaterialsEntity> result) {
            delegate.asyncFinished(result);
        }
    }

    //InsertAsyncTask for inserting items to the database
    private static class InsertAsyncTask extends AsyncTask<RawMaterialsEntity, Void, Void> {

        private RawMaterialsDao asyncTaskDao;

        InsertAsyncTask(RawMaterialsDao dao) {
            asyncTaskDao = dao;
        }

        @Override
        protected Void doInBackground(final RawMaterialsEntity... params) {
            asyncTaskDao.insertMaterial(params[0]);
            return null;
        }
    }

    //DeleteAsyncTask for deleting items from the database
    private static class DeleteAsyncTask extends AsyncTask<String, Void, Void> {

        private RawMaterialsDao asyncTaskDao;

        DeleteAsyncTask(RawMaterialsDao dao) {
            asyncTaskDao = dao;
        }

        @Override
        protected Void doInBackground(final String... params) {
            asyncTaskDao.deleteMaterial(params[0]);
            return null;
        }
    }

    //CostPerGmAsyncTask for dividing the  materialCost on the materialWeight
     private static class CostPerGmAsyncTask extends AsyncTask<Void, Void, Void> {

        private RawMaterialsDao asyncTaskDao;

        CostPerGmAsyncTask(RawMaterialsDao dao) {
            asyncTaskDao = dao;
        }

        @Override
        protected Void doInBackground(Void... voids) {
            asyncTaskDao.divide();
            return null;
        }
    }

    //TotalCostAsyncTask for dividing the  materialCost on the materialWeight
    private static class TotalCostAsyncTask extends AsyncTask<Void, Void, Void> {

        private RawMaterialsDao asyncTaskDao;

        TotalCostAsyncTask(RawMaterialsDao dao) {
            asyncTaskDao = dao;
        }

        @Override
        protected Void doInBackground(Void... voids) {
            asyncTaskDao.totalCost();
            return null;
        }
    }

}

 public LiveData<RawMaterialsEntity> findMaterialById(int id) {
        return rawMaterialDao.findMaterialById(id);
    }

公共类ChefsBoxRepository{
私有MutableLiveData searchResults=新的MutableLiveData（）；
私人生活资料；
私人原料道原料道；
//公共构造函数
公共ChefsBoxRepository（应用程序）{
chefsboxroomdb数据库；
db=ChefsBoxRoomDataBase.getDatabase（应用程序）；
rawMaterialDao=db.rawMaterialDao（）；
AllMaterialDao.getAllMaterials（）；
}
//由视图模型使用
公共LiveData getAllMaterials（）{
归还所有材料；
}
//由视图模型使用
公共可变LiveData getSearchResults（）{
返回搜索结果；
}
公共void insertMaterial（RawMaterialsEntity newMaterial）{
InsertAsyncTask任务=新的InsertAsyncTask（rawMaterialDao）；
任务。执行（新材料）；
}
公共空间成本管理（）{
CostPerGmAsyncTask任务=新的CostPerGmAsyncTask（rawMaterialDao）；
task.execute（）；
}
公共成本（）{
TotalCostAsyncTask任务=新的TotalCostAsyncTask（rawMaterialDao）；
task.execute（）；
}
公共void deleteMeterial（字符串名称）{
DeleteAsyncTask任务=新的DeleteAsyncTask（rawMaterialDao）；
task.execute（名称）；
}
公共void findMaterial（字符串名称）{
QueryAsyncTask任务=新的QueryAsyncTask（rawMaterialDao）；
task.delegate=this；
task.execute（名称）；
}
公共无效findMaterialById（int id）{
QueryAsyncTask2任务=新的QueryAsyncTask2（rawMaterialDao）；
task.delegate=this；
任务执行（id）；
}
私有void异步完成（列出结果）{
searchResults.setValue（结果）；
}
//用于从数据库调用项的QueryAsyncTask
私有静态类QueryAsyncTask扩展
异步任务{
私有原料道；
私有ChefsBoxRepository委托=null；
QueryAsyncTask（原料道）{
asyncTaskDao=dao；
}
@凌驾
受保护列表doInBackground（最终字符串…参数）{
返回asyncTaskDao.findMaterial（参数[0]）；
}
@凌驾
受保护的void onPostExecute（列表结果）{
delegate.asyncFinished（结果）；
}
}
//用于从数据库调用项的QueryAsyncTask
私有静态类QueryAsyncTask2扩展
异步任务{
私有原料道；
私有ChefsBoxRepository委托=null；
QueryAsyncTask2（原料道）{
asyncTaskDao=dao；
}
@凌驾
受保护列表doInBackground（最终整数…参数）{
返回asyncTaskDao.findMaterialById（参数[0]）；
}
@凌驾
受保护的void onPostExecute（列表结果）{
delegate.asyncFinished（结果）；
}
}
//用于将项目插入数据库的InsertAsyncTask
私有静态类InsertAsyncTask扩展了AsyncTask{
私有原料道；
InsertAsyncTask（RawMaterialsDao）{
asyncTaskDao=dao；
}
@凌驾
受保护的无效doInBackground（最终RawMaterialsEntity…参数）{
asyncTaskDao.insertMaterial（参数[0]）；
返回null；
}
}
//DeleteAsyncTask用于从数据库中删除项目
私有静态类DeleteAsyncTask扩展了AsyncTask{
私有原料道；
DeleteAsyncTask（RawMaterialsDao）{
asyncTaskDao=dao；
}
@凌驾
受保护的Void doInBackground（最终字符串…参数）{
asyncTaskDao.deleteM

@Query("SELECT * FROM raw_materials WHERE id = :id")
    LiveData<RawMaterialsEntity> findMaterialById(int id);



 public LiveData<RawMaterialsEntity> findMaterialById(int id) {
        return rawMaterialDao.findMaterialById(id);
    }



    public LiveData<RawMaterialsEntity> findMaterialById(int id) {
        return repository.findMaterialById(id);
    }



   RawMaterialViewModel materialViewModel = new ViewModelProvider(this).get(RawMaterialViewModel.class);
        // Update the cached copy of the words in the adapter.

        Intent intent = getIntent();
        if (intent != null && intent.hasExtra("ID")) {

            id = intent.getIntExtra("ID", -1);
            // TODO: get material details based on material id

            // Set up the materialViewModel
           materialViewModel = new ViewModelProvider(this).get(RawMaterialViewModel.class);
           materialViewModel.findMaterialById(id).observe(this, new Observer<RawMaterialsEntity>() {
               @Override
               public void onChanged(RawMaterialsEntity rawMaterialsEntity) {
                   mMaterialName.setText(rawMaterialsEntity.getRawMaterialName());
                   mMaterialBrand.setText(rawMaterialsEntity.getRawMaterialBrand());
               }
           });