Room + ViewModelScope

build.gradle

plugins {
    id 'kotlin-kapt'
}




// ROOM
    def roomVersion = "2.4.0"

    implementation("androidx.room:room-runtime:$roomVersion")
    annotationProcessor("androidx.room:room-compiler:$roomVersion")

// To use Kotlin annotation processing tool (kapt)
    kapt("androidx.room:room-compiler:$roomVersion")

// Coroutine
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0")


    // ViewModelScope
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.1")

}

MainViewModel.kt

class MainViewModel(application: Application) : AndroidViewModel(application) {


    val context = getApplication<Application>().applicationContext
    val db = TextDataBase.getDatabase(context)

    fun getDate() = viewModelScope.launch(Dispatchers.IO) {

        Log.d("MainViewModel",db.textDao().getAllData().toString())
        Log.d("MainViewModel",db.wordDao().getAllData().toString())

    }

    fun insertData(text : String) = viewModelScope.launch(Dispatchers.IO) {
        db.textDao().insert(TextEntity(0,text))
        db.wordDao().insert(WordEntity(0, text))

    }

    fun removeData() = viewModelScope.launch (Dispatchers.IO){
        db.textDao().deleteAllData()
        db.wordDao().deleteAllData()
    }


}

 

MainActivity.kt

class MainActivity : AppCompatActivity() {

    lateinit var viewModel : MainViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)


        viewModel = ViewModelProvider(this).get(MainViewModel::class.java)
        viewModel.getDate()


        val db = TextDataBase.getDatabase(this)

        val inputArea = findViewById<EditText>(R.id.textInputArea)
        val insertBtn = findViewById<Button>(R.id.insert)
        val getAllBtn = findViewById<Button>(R.id.getData)
        val deleteBtn = findViewById<Button>(R.id.delete)

        insertBtn.setOnClickListener {

            viewModel.insertData(inputArea.text.toString())
            inputArea.setText("")



        }

        getAllBtn.setOnClickListener {
           viewModel.getDate()
        }

        deleteBtn.setOnClickListener {
           viewModel.removeData()
        }


    }
}

 

TextEntity.kt

@Entity(tableName = "text_table")
data class TextEntity (

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id : Int,
    @ColumnInfo(name = "text")
    var text: String

)

 

WordEntity.kt

@Entity(tableName = "word_table")
data class WordEntity (

    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id : Int,
    @ColumnInfo(name = "text")
    var text: String

)

 

TextDataBase.kt

@Database(entities = [TextEntity::class, WordEntity::class], version = 2)
abstract class TextDataBase : RoomDatabase(){

    abstract fun textDao() : TextDao
    abstract fun wordDao() : WordDao

    companion object {
        @Volatile
        private var INSTANCE : TextDataBase? = null

        fun getDatabase(
            context : Context
        ) : TextDataBase {


            return INSTANCE ?: synchronized(this){
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    TextDataBase::class.java,
                    "text_database"
                )
                    .fallbackToDestructiveMigration()
                    .build()
                INSTANCE = instance
                instance


            }

        }


    }

}

 

WordDao.kt

@Dao
interface WordDao {

    @Query("SELECT * FROM text_table")
    fun getAllData() : List<WordEntity>

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(text : WordEntity)

    @Query("DELETE FROM word_table")
    fun deleteAllData()


}

 

TextDao.kt

@Dao
interface TextDao {

    @Query("SELECT * FROM text_table")
    fun getAllData() : List<TextEntity>

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    fun insert(text : TextEntity)

    @Query("DELETE FROM text_table")
    fun deleteAllData()


}

 

실행결과 :