Android 可以'；t将数据插入房间数据库

嗨，伙计们，我有一个关于使用房间向数据库插入数据的问题 5.我试了很多方法，但都不管用，也许你能帮我解决这个问题

问题是，当我使用setOnClickListener点击FAB按钮时，我想插入数据

binding.favoriteButton.setOnClickListener {
            val userId = item
            if (userId != null) {
                viewModel.viewModelScope.launch {
                    if (viewModel.isFavorite.value == true) {
                        viewModel.delete(userId)
                        Log.d("DetailUserActivity", "User dengan ID $userId dihapus dari favorit.")
                    } else {
                        viewModel.insert(userId)
                        Log.d("DetailUserActivity", "User dengan ID $userId ditambah ke favorit.")
                    }
                }
            }
        }

在setOnClickListener中我判断用户ID，如果ID不在数据库中，我会使用INSERT函数发送数据，如果数据在数据库中，我会使用DELETE函数删除数据，但问题是数据不能在数据库中插入或删除，我已经判断了应用程序判断器，但数据没有显示，在Log Cat中有一个错误，我不明白这是什么意思，这里是错误:

 E  Failed to open QEMU pipe 'qemud:network': Invalid argument
 E  RemoteConnection failed to initialize: RemoteConnection failed to open pipe
E Couldn't load memtrack module

注意:我的连接正常，所以我认为错误不是来self 的连接

以下是我的代码:

//DetailUserActivit.kt

    package com.example.projectone.userdetail

    import androidx.appcompat.app.AppCompatActivity
    import android.os.Bundle
    import android.util.Log
    import android.view.MenuItem
    import android.widget.Toast
    import androidx.activity.viewModels
    import androidx.core.content.ContextCompat
    import androidx.core.view.isVisible
    import androidx.fragment.app.Fragment
    import androidx.lifecycle.viewModelScope
    import coil.load
    import coil.transform.CircleCropTransformation
    import com.example.project_one.R
    import com.example.project_one.databinding.ActivityDetailUserBinding
    import com.example.projectone.data.model.ResponseDetailUserGithub
    import com.example.projectone.data.model.ResponseUserGithub
    import com.example.projectone.userdetail.fragment.UserFollower
    import com.example.projectone.utils.ResultViewModel
    import com.google.android.material.tabs.TabLayout
    import com.google.android.material.tabs.TabLayoutMediator
    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.launch
    import kotlinx.coroutines.withContext


    class DetailUserActivity : AppCompatActivity() {
        private lateinit var binding: ActivityDetailUserBinding
        private val viewModel by viewModels<DetailUserViewModel>{
            DetailViewModelFactory(application)
        }

        private var isFavorite = false


        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            binding = ActivityDetailUserBinding.inflate(layoutInflater)
            setContentView(binding.root)
            supportActionBar?.setDisplayHomeAsUpEnabled(true)

            val item = intent.getParcelableExtra<ResponseUserGithub.Item>("userItems")
            val username = item?.login ?: "User Not Found"

            viewModel.resultDetailUser.observe(this) {
                when(it) {
                    is ResultViewModel.Success<*> -> {
                        val user = it.data as ResponseDetailUserGithub
                        binding.imageUser.load(user.avatar_url) {
                            transformations(CircleCropTransformation())
                        }

                        binding.fullNames.text = user.name
                        binding.username.text = user.login
                        binding.followerCount.text = user.followers.toString()
                        binding.followingCount.text = user.following.toString()
                        binding.repositoryCount.text = user.public_repos.toString()


                    }
                    is ResultViewModel.Error -> {
                        Toast.makeText(this, it.exception.message.toString(), Toast.LENGTH_SHORT).show()
                    }
                    is ResultViewModel.Loading -> {
                        binding.progressBar.isVisible = it.isLoading
                    }
                }
            }

            viewModel.getUser(username)
            val fragments = mutableListOf<Fragment>(
                UserFollower.newInstance(UserFollower.FOLLOWERS),
                UserFollower.newInstance(UserFollower.FOLLOWING)
            )
            val titleTabFragments = mutableListOf(
                getString(R.string.follower_tab), getString(R.string.following_tab)
            )
            val adapter = DetailUserAdapter(this, fragments)
            binding.viewPager.adapter = adapter

            TabLayoutMediator(binding.tabLayout, binding.viewPager) {tab, position ->
                tab.text = titleTabFragments[position]
            }.attach()

            binding.tabLayout.addOnTabSelectedListener(object: TabLayout.OnTabSelectedListener {
                override fun onTabSelected(tab: TabLayout.Tab?) {
                    if (tab?.position == 0) {
                        viewModel.getFollowerUser(username)
                    } else {
                        viewModel.getFollowingUser(username)
                    }
                }

                override fun onTabUnselected(tab: TabLayout.Tab?) {
                }

                override fun onTabReselected(tab: TabLayout.Tab?) {
                }

            })
            viewModel.getFollowerUser(username)

            viewModel.resultFavoriteAdd.observe(this) {
                updateFavoriteButtonColor(true)
            }
            viewModel.resultFavoriteDelete.observe(this) {
                updateFavoriteButtonColor(false)
            }

            viewModel.isFavorite.observe(this) { isFavoriteValue ->
                updateFavoriteButtonColor(isFavoriteValue)
            }


            binding.favoriteButton.setOnClickListener {
                val userId = item
                if (userId != null) {
                    viewModel.viewModelScope.launch {
                        // Cek status isFavorite berdasarkan status saat ini
                        if (isFavorite) {
                            // Jika sebelumnya adalah favorit, hapus dari database

                                viewModel.delete(userId)

                            // Perbarui status isFavorite dan tombol favorit
                            isFavorite = false
                            updateFavoriteButtonColor(false)
                            Log.d("DetailUserActivity", "User dengan ID $userId dihapus dari favorit.")
                        } else {
                            // Jika sebelumnya tidak favorit, tambahkan ke database

                                viewModel.insert(userId)

                            // Perbarui status isFavorite dan tombol favorit
                            isFavorite = true
                            updateFavoriteButtonColor(true)
                            Log.d("DetailUserActivity", "User dengan ID $userId ditambahkan ke favorit.")
                        }
                    }
                }
            }



        }



        private fun updateFavoriteButtonColor(isFavorite: Boolean) {
            val colorRes = if (isFavorite) R.color.lavender else android.R.color.white
            val color = ContextCompat.getColor(this, colorRes)
            binding.favoriteButton.setColorFilter(color)
        }


        override fun onOptionsItemSelected(item: MenuItem): Boolean {
            when(item.itemId) {
                android.R.id.home -> {
                    finish()
                }
            }

            return super.onOptionsItemSelected(item)
        }
    }

//DetailViewModel.kt

    import android.app.Application
    import android.util.Log
    import androidx.lifecycle.LiveData
    import androidx.lifecycle.MutableLiveData
    import androidx.lifecycle.ViewModel
    import androidx.lifecycle.ViewModelProvider
    import androidx.lifecycle.viewModelScope
    import com.example.projectone.data.db.FavDao
    import com.example.projectone.data.model.ResponseUserGithub
    import com.example.projectone.data.repo.FavoriteRepository
    import com.example.projectone.data.service.ApiClient
    import com.example.projectone.utils.ResultViewModel
    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.flow.catch
    import kotlinx.coroutines.flow.flow
    import kotlinx.coroutines.flow.onCompletion
    import kotlinx.coroutines.flow.onStart
    import kotlinx.coroutines.launch

    class DetailUserViewModel(application: Application) : ViewModel() {
        val resultDetailUser = MutableLiveData<ResultViewModel>()
        val resultFollowersUser = MutableLiveData<ResultViewModel>()
        val resultFollowingUser = MutableLiveData<ResultViewModel>()
        val resultFavoriteAdd = MutableLiveData<ResultViewModel>()
        val resultFavoriteDelete = MutableLiveData<ResultViewModel>()
        val resultFavoriteCheck = MutableLiveData<ResultViewModel>()

        val myGithubDetail = MutableLiveData<ResultViewModel>()
        val myFollowerUser = MutableLiveData<ResultViewModel>()
        val myFollowingUser = MutableLiveData<ResultViewModel>()


        private val mFavRepo: FavoriteRepository = FavoriteRepository(application)

        private val _isFavorite = MutableLiveData<Boolean>()
        val isFavorite: LiveData<Boolean> = _isFavorite
        
        suspend fun insert(fav: ResponseUserGithub.Item) {
                if (_isFavorite.value != null) {
                    if (_isFavorite.value == true) {
                            mFavRepo.insert(fav)
                            resultFavoriteAdd.value = ResultViewModel.Success(true)
                    }
                }

            _isFavorite.value = _isFavorite.value != true
        }

        suspend fun delete(fav: ResponseUserGithub.Item) {
                if (_isFavorite.value != null) {
                    if (_isFavorite.value == true) {
                        mFavRepo.delete(fav)
                        resultFavoriteDelete.value = ResultViewModel.Success(true)
                    }
                }

            _isFavorite.value = _isFavorite.value != true
        }

        fun findById(id: Int) {
            viewModelScope.launch {
                val isFavoriteValue = mFavRepo.findById(id) != null
                _isFavorite.postValue(isFavoriteValue)
            }
        }


        fun getUser(username: String) {
            viewModelScope.launch {
                flow {
                    val response = ApiClient
                        .githubService
                        .getDetailUserFromGithub(username)
                    emit(response)
                } .onStart {
                    resultDetailUser.value = ResultViewModel.Loading(true)
                } .onCompletion {
                    resultDetailUser.value = ResultViewModel.Loading(false)
                } .catch {
                    Log.e("Error ", it.message.toString())
                    it.printStackTrace()
                    resultDetailUser.value = ResultViewModel.Error(it)
                } .collect {
                    // Ubah tipe data yang dikirimkan ke resultSuccess.value
                    resultDetailUser.value = ResultViewModel.Success(it)
                }
            }
        }

        fun getFollowerUser(username: String) {
            viewModelScope.launch {
                flow {
                    val response = ApiClient
                        .githubService
                        .getFollowerUserFromGithub(username)
                    emit(response)
                } .onStart {
                    resultFollowersUser.value = ResultViewModel.Loading(true)
                } .onCompletion {
                    resultFollowersUser.value = ResultViewModel.Loading(false)
                } .catch {
                    Log.e("Error ", it.message.toString())
                    it.printStackTrace()
                    resultFollowersUser.value = ResultViewModel.Error(it)
                } .collect {
                    // Ubah tipe data yang dikirimkan ke resultSuccess.value
                    resultFollowersUser.value = ResultViewModel.Success(it)
                }
            }
        }

        fun getFollowingUser(username: String) {
            viewModelScope.launch {
                flow {
                    val response = ApiClient
                        .githubService
                        .getFollowingUserFromGithub(username)
                    emit(response)
                } .onStart {
                    resultFollowingUser.value = ResultViewModel.Loading(true)
                } .onCompletion {
                    resultFollowingUser.value = ResultViewModel.Loading(false)
                } .catch {
                    Log.e("Error ", it.message.toString())
                    it.printStackTrace()
                    resultFollowingUser.value = ResultViewModel.Error(it)
                } .collect {
                    // Ubah tipe data yang dikirimkan ke resultSuccess.value
                    resultFollowingUser.value = ResultViewModel.Success(it)
                }
            }
        }

        fun getMyGithub(username: String) {
            viewModelScope.launch {
                flow {
                    val response = ApiClient
                        .githubService
                        .getMyGithub(username)
                    emit(response)
                } .onStart {
                    myGithubDetail.value = ResultViewModel.Loading(true)
                } .onCompletion {
                    myGithubDetail.value = ResultViewModel.Loading(false)
                } .catch {
                    Log.e("Error ", it.message.toString())
                    it.printStackTrace()
                    myGithubDetail.value = ResultViewModel.Error(it)
                } .collect {
                    // Ubah tipe data yang dikirimkan ke resultSuccess.value
                    myGithubDetail.value = ResultViewModel.Success(it)
                }
            }
        }

        fun getMyFollower(username: String) {
            viewModelScope.launch {
                flow {
                    val response = ApiClient
                        .githubService
                        .getMyFollowerGithub(username)
                    emit(response)
                } .onStart {
                    myFollowerUser.value = ResultViewModel.Loading(true)
                } .onCompletion {
                    myFollowerUser.value = ResultViewModel.Loading(false)
                } .catch {
                    Log.e("Error ", it.message.toString())
                    it.printStackTrace()
                    myFollowerUser.value = ResultViewModel.Error(it)
                } .collect {
                    // Ubah tipe data yang dikirimkan ke resultSuccess.value
                    myFollowerUser.value = ResultViewModel.Success(it)
                }
            }
        }

        fun getMyFollowing(username: String) {
            viewModelScope.launch {
                flow {
                    val response = ApiClient
                        .githubService
                        .getMyFollowingGithub(username)
                    emit(response)
                } .onStart {
                    myFollowingUser.value = ResultViewModel.Loading(true)
                } .onCompletion {
                    myFollowingUser.value = ResultViewModel.Loading(false)
                } .catch {
                    Log.e("Error ", it.message.toString())
                    it.printStackTrace()
                    myFollowingUser.value = ResultViewModel.Error(it)
                } .collect {
                    // Ubah tipe data yang dikirimkan ke resultSuccess.value
                    myFollowingUser.value = ResultViewModel.Success(it)
                }
            }
        }
    }

    class DetailViewModelFactory(private val application: Application) : ViewModelProvider.NewInstanceFactory() {
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            if (modelClass.isAssignableFrom(DetailUserViewModel::class.java)) {
                @Suppress("UNCHECKED_CAST")
                return DetailUserViewModel(application) as T
            }
            throw IllegalAccessException("Unkwon ViewModel :" + modelClass.name)
        }
    }

//FavoritRepository.kt

    import android.app.Application
    import androidx.lifecycle.LiveData
    import com.example.projectone.data.db.FavDao
    import com.example.projectone.data.db.FavDb
    import com.example.projectone.data.model.ResponseUserGithub
    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.withContext
    import java.util.concurrent.ExecutorService
    import java.util.concurrent.Executors

    class FavoriteRepository( application: Application) {


        private val mFavDao: FavDao
        private val executorService: ExecutorService = Executors.newFixedThreadPool(4)
        init {
            val db = FavDb.getDatabase(application)
            mFavDao = db.FavDao()
        }
        fun getAllFavUser(): LiveData<MutableList<ResponseUserGithub.Item>> = mFavDao.loadAll()
        fun insert(fav: ResponseUserGithub.Item) {
            executorService.execute { mFavDao.insertFav(fav) }
        }
        fun delete(fav: ResponseUserGithub.Item) {
            executorService.execute { mFavDao.deleteFav(fav) }
        }

        fun findById(id: Int): LiveData<ResponseUserGithub.Item?> {
            return mFavDao.findByid(id)
        }


    }

~FavDao.kt

    import androidx.lifecycle.LiveData
    import androidx.room.Dao
    import androidx.room.Delete
    import androidx.room.Insert
    import androidx.room.OnConflictStrategy
    import androidx.room.Query
    import com.example.projectone.data.model.ResponseUserGithub

    @Dao
    interface FavDao {
        @Insert(onConflict = OnConflictStrategy.REPLACE)
        fun insertFav(user: ResponseUserGithub.Item)

        @Query("SELECT * FROM user")
        fun loadAll(): LiveData<MutableList<ResponseUserGithub.Item>>

        @Query("SELECT * FROM user WHERE id LIKE :id LIMIT 1")
        fun findByid(id: Int): LiveData<ResponseUserGithub.Item?>

        @Delete
        fun deleteFav(user: ResponseUserGithub.Item)=
    }

//FavDb.kt

import android.content.Context
import android.provider.ContactsContract
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.example.projectone.data.model.ResponseUserGithub

@Database(entities = [ResponseUserGithub.Item::class], version = 1)
abstract class FavDb : RoomDatabase() {
    abstract fun FavDao(): FavDao
    companion object {
        @Volatile
        private var INSTANCE: FavDb? = null
        @JvmStatic
        fun getDatabase(context: Context): FavDb {
            if (INSTANCE == null) {
                synchronized(FavDb::class.java) {
                    INSTANCE = Room.databaseBuilder(context.applicationContext,
                        FavDb::class.java, "fav_database")
                        .build()
                }
            }
            return INSTANCE as FavDb
        }
    }
}

//ResponseUseGithub.kt

import android.os.Parcelable
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
import kotlinx.parcelize.Parcelize

data class ResponseUserGithub(
    val incomplete_results: Boolean,
    val items: List<Item>,
    val total_count: Int
) {
    @Parcelize
    @Entity(tableName = "user")
    data class Item(
        @ColumnInfo(name = "avatar_url")
        val avatar_url: String,
        @PrimaryKey
        val id: Int,
        @ColumnInfo(name = "login")
        val login: String
    ) : Parcelable

}

也许你能帮我，教我如何解决这个问题