[Android] MVVM+Room Code

🌞MVVM패턴과 Room 사용하여 주소록 만들기 (Kotlin)

1. 우선 ViewModel과 Room을 사용하기 위해 종속성 추가

// ViewModel
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.0'
implementation 'androidx.activity:activity-ktx:1.4.0'
implementation 'androidx.fragment:fragment-ktx:1.4.1'


//Room
implementation 'androidx.room:room-runtime:2.4.1'
kapt 'androidx.room:room-compiler:2.4.1'
implementation "androidx.room:room-ktx:2.4.1"

---

2. Room을 이용해 DB 생성 및 삽입, 삭제

Entity : Contact.kt

Entity(개체)는 관련이 있는 속성들이 모여 하나의 정보 단위를 이룬 것으로 Database내에 테이블을 클래스로 나타내주는 것이다.
@Entity를 통해 생성해주고 기본적으로 클래스 이름이 테이블 이름이 되지만 별도로 설정을 해주고 싶다면
@Entity옆에 (tableName = "테이블 이름")을 통해 정해주면 된다.
@PrimaryKey는 키 값이기 때문에 유일한(Unique) 값이어야 한다. 직접 지정해도 되지만 autoGenerate를 true로 주면 자동으로 값을 생성한다.
그리고 따로 칼럼명을 지정하고 싶다면 @ColumnInfo(name="칼럼명")을 사용하면 된다.

@Entity(tableName = "contact")
data class Contact(
    @PrimaryKey(autoGenerate = true) // 기본키로 지정 , null일 경우 자동으로 생성되도록 autoGenerate 속성
    var id:Int?,
    var name:String,
    var number:String,
    var initial :Char,
    
    @ColumnInfo(name="cate")
    var category : Int? =0

){
    constructor() : this(null,"","",'\u0000',0)
}

DAO : ContactDao.kt

DAO는 Data Access Object의 줄임말로, 데이터에 접근할 수 있는 메서드를 정의해놓은 인터페이스이다.
@Dao 어노테이션을 붙이고 그 안에 메서드를 만들면 된다.

DAO 속성	설명
@Insert	데이터 삽입
@Delete	데이터 삭제
@Update	데이터 수정

이 외에 원하는 명령을 하고싶다면 @Query("원하는 Sql문")을 사용하면 된다.

@Insert로 데이터를 추가 할 때 같은 primary key 값을 가진 객체를 추가하면 에러가 발생하기 때문에 충돌처리방식을 통해 에러가 나는 것을 방지할 수 있다.

충돌처리방식	설명
OnConflictStrategy.ABORT	충돌이 발생할 경우 처리 중단
OnConflictStrategy.FAIL	충돌이 발생할 경우 실패 처리
OnConflictStrategy.IGNORE	충돌이 발생할 경우 무시
OnConflictStrategy.REPLACE	충돌이 발생할 경우 덮어쓰기
OnConflictStrategy.ROLLBACK	충돌이 발생할 경우 이전으로 되돌리기

@Dao
interface ContactDao {
    @Query("SELECT * FROM contact ORDER BY name ASC")
    fun getAll() : LiveData<List<Contact>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insert(contact: Contact)

    @Delete
    fun delete(contact: Contact)
}

Database : ContactDatabase.kt

@Database 어노테이션으로 데이터베이스임을 표시한다.
RoomDatabase 클래스를 상속받고, 데이터베이스를 생성하고 관리하는 데이터베이스 객체 만들기 위해서 추상 클래스를 만들어 줘야 한다.

@Database(entities=[Entity 명::class], version=버전정보)

version은 Entity의 구조를 변경해야 하는 일이 생겼을 때 이전 구조와 현재 구조를 구분해주는 역할을 한다. 처음 데이터베이스를 생성하는 상황이라면 그냥 1을 넣어주면 된다. 만약 구조가 바뀌었는데 버전이 같다면 에러가 뜨며 디버깅이 되지 않는다.

@Database(entities=arrayOf(Entity 명::class, Entity 명::class...), version=버전정보)

여러개의 Entity를 사용하고 싶다면 위와 같이 배열 형식으로 작성해주면 된다.

@Database(entities = [Contact::class],version = 1)
abstract class ContactDatabase : RoomDatabase() {
    abstract fun contactDao(): ContactDao
    companion object{
        private var INSTANCE : ContactDatabase? = null

        fun getInstance(context: Context): ContactDatabase?{
            if(INSTANCE == null){
                synchronized(ContactDatabase::class){
                    INSTANCE = Room.databaseBuilder(context.applicationContext,
                    ContactDatabase::class.java,"contact.db")
                        .fallbackToDestructiveMigration()
                        .allowMainThreadQueries()
                        .build()
                }
            }
            return INSTANCE
        }
    }
}

싱글톤으로 DB를 생성해주고 Room이 기기의 기존 DB를 현재 버전으로 업그레이드하기위한 이전 경로를 찾지 못한다면 IllegalStateException이 발생하는데 이전 경로가 누락되었을 때 기존 데이터를 잃어도 괜찬다면 DB 생성시 다음과 같이 fallbackToDestructiveMigration()빌더 메서드를 호출해준다.

Room에서 기본적으로 Main Thread에서 접근할 수 없지만, allowMainThreadQueries를 사용하여만든 Instance에서는 Main Thread에서도 접근할 수 있다.
-> Database를 접근하는 작업은 무거운 작업이고 UI를 오랫동안 잠글 수 있기 때문에 Main Thread에서 접근하는 것은 좋지 않다.

---

3. MVVM패턴을 사용해 주소록 만들고 Room사용하여 DB 저장 및 삭제

Model : ContactRepository.kt

Model은 데이터에 대한 작업을 마치면 ViewModel에게 결과를 알려준다.
여기서는 LiveData를 통해 값이 변화하는지 알려주게 된다.

class ContactRepository(application: Application) {
    private val contactDatabase = ContactDatabase.getInstance(application)!!
    private val contactDao: ContactDao = contactDatabase.contactDao()
    private val contacts: LiveData<List<Contact>> = contactDao.getAll()

    fun getAll(): LiveData<List<Contact>> {
        return contacts
    }

    fun insert(contact: Contact) {
        try {
            val thread = Thread {
                contactDao.insert(contact)
            }
            thread.start()
        } catch (e: Exception) {
        }
    }

    fun delete(contact: Contact) {
        try {
            val thread = Thread {
                contactDao.delete(contact)
            }
            thread.start()
        } catch (e: Exception) {
        }
    }
}

ViewModel : ContactViewModel.kt

ViewModel은 Model에서 가져온 데이터를 UI에 필요한 정보로 가공하고, View가 가져갈 수 있도록 해당 데이터 변경에 대한 "notify" 를 보낸다.
onCleared는 ViewModel을 더 이상 사용하지 않거나, ViewModel이 관찰하고 있는 데이터를 초기화해야 할 때 사용한다.

 class ContactViewModel(application: Application) : ViewModel(){

    private val repository = ContactRepository(application)

    fun getAll(): LiveData<List<Contact>> {
        return repository.getAll()
    }

    fun insert(contact: Contact){
        repository.insert(contact)
    }

    fun delete(contact: Contact){
        repository.delete(contact)
    }

     override fun onCleared() {
         super.onCleared()
     }
}

View : ContactActivity.kt , AddActivity.kt

AddActivity.kt : 주소록 추가 화면
이름과 번호 값을 입력하고 저장버튼을 눌렀을 때 값이 비어있지 않다면 Viewmodel의 insert를 통해 값들을 넣어준다. 이를 통해 View에서 ViewModel에게 Action을 전달하게 된 것이다.

class AddActivity : AppCompatActivity() {
    private val contactViewModel : ContactViewModel by viewModels{
        object : ViewModelProvider.Factory{
            override fun <T : ViewModel> create(modelClass: Class<T>): T =
                ContactViewModel(application) as T

        }
    }
    private var id : Int? = null

    private lateinit var binding: ActivityAddBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_add)

        if (intent != null && intent.hasExtra(EXTRA_CONTACT_NAME) && intent.hasExtra(EXTRA_CONTACT_NUMBER)
            && intent.hasExtra(EXTRA_CONTACT_ID)) {
            binding.addEdittextName.setText(intent.getStringExtra(EXTRA_CONTACT_NAME))
            binding.addEdittextNumber.setText(intent.getStringExtra(EXTRA_CONTACT_NUMBER))
            id = intent.getIntExtra(EXTRA_CONTACT_ID, -1)
        }

        binding.addButton.setOnClickListener {
            val name = binding.addEdittextName.text.toString()
            val number = binding.addEdittextNumber.text.toString()

            if (name.isEmpty() || number.isEmpty()) {
                Toast.makeText(this, "Please enter name and number.", Toast.LENGTH_SHORT).show()
            } else {
                val initial = name[0].uppercaseChar()
                val contact = Contact(id, name, number, initial,0)
                contactViewModel.insert(contact)
                finish()
            }
        }
    }

    companion object {
        const val EXTRA_CONTACT_NAME = "EXTRA_CONTACT_NAME"
        const val EXTRA_CONTACT_NUMBER = "EXTRA_CONTACT_NUMBER"
        const val EXTRA_CONTACT_ID = "EXTRA_CONTACT_ID"
    }
}

ContactActivity.kt : 주소록 화면
observe를 통해서 ViewModel의 getAll(조회)에 변화가 생기면 감지해준다.

class ContactActivity : AppCompatActivity() {

    private val contactViewModel : ContactViewModel by viewModels{
        object : ViewModelProvider.Factory{
            override fun <T : ViewModel> create(modelClass: Class<T>): T =
                ContactViewModel(application) as T
        }
    }

    private lateinit var binding: ActivityContactBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_contact)

        val aContactAdapter = ContactAdapter({ contact ->
            val intent = Intent(this, AddActivity::class.java)
            intent.putExtra(AddActivity.EXTRA_CONTACT_NAME, contact.name)
            intent.putExtra(AddActivity.EXTRA_CONTACT_NUMBER, contact.number)
            intent.putExtra(AddActivity.EXTRA_CONTACT_ID, contact.id)
            startActivity(intent)
        }, { contact ->
            deleteDialog(contact)
        })

        val layoutManger = LinearLayoutManager(this)
        binding.mainRecyclerview.adapter = aContactAdapter
        binding.mainRecyclerview.layoutManager = layoutManger
        binding.mainRecyclerview.setHasFixedSize(true)

        binding.mainButton.setOnClickListener {
            startActivity(Intent(this,AddActivity::class.java))
        }

        contactViewModel.getAll().observe(this, { contacts ->
            aContactAdapter.setContacts(contacts!!)
        })
    }

    private fun deleteDialog(contact: Contact) {
        val builder = AlertDialog.Builder(this)
        builder.setMessage("Delete selected contact?")
            .setNegativeButton("NO") { _, _ -> }
            .setPositiveButton("YES") { _, _ ->
                contactViewModel.delete(contact)
            }
        builder.show()
    }
}

ContactAdapter.kt : Recyclerview Adapter

class ContactAdapter(val contactItemClick:(Contact)->Unit, val contactItemLongClick: (Contact) -> Unit)
    :RecyclerView.Adapter<ContactAdapter.ViewHolder>(){

    private var contacts:List<Contact> = listOf()

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ContactAdapter.ViewHolder {
        val view = LayoutInflater.from(parent.context).inflate(R.layout.item_contact,parent,false)
        return ViewHolder(view)
    }

    override fun onBindViewHolder(holder: ContactAdapter.ViewHolder, position: Int) {
        holder.bind(contacts[position])
    }

    override fun getItemCount(): Int {
        return contacts.size
    }

    inner class ViewHolder(itemView: View): RecyclerView.ViewHolder(itemView) {
        private val nameTv = itemView.findViewById<TextView>(R.id.item_tv_name)
        private val numberTv = itemView.findViewById<TextView>(R.id.item_tv_number)
        private val initialTv = itemView.findViewById<TextView>(R.id.item_tv_initial)

        fun bind(contact: Contact) {
            nameTv.text = contact.name
            numberTv.text = contact.number
            initialTv.text = contact.initial.toString()

            itemView.setOnClickListener {
                contactItemClick(contact)
            }

            itemView.setOnLongClickListener {
                contactItemLongClick(contact)
                true
            }
        }
    }

    fun setContacts(contacts: List<Contact>) {
        this.contacts = contacts
        notifyDataSetChanged()
    }

}

참고 : https://blog.yena.io/studynote/2019/03/27/Android-MVVM-AAC-2.html