경북대 Android_권성찬 2주차 과제 Step2

README.md

@@ -1 +1,23 @@
 # android-map-keyword
+
+## 구현 기능 목록
+1. MVVM 아키텍처 구조 설립
+2. 기본 레이아웃 구현
+3. SQLite 활용하여 데이터베이스 구축
+4. 로컬 데이터베이스에 데이터 생성
+
+## Step 2 구현 기능 목록
+- [x]  SQLiteOpenHelper을 통해 DB를 업데이트 하거나 요청받은 LiveData 데이터를 가져오는 Repository 클래스 구현
+- [x]  유저 입력에 따라 Repository로 검색 결과 데이터 조회를 요청하는 ViewModel 클래스 구현
+- [x]  검색 결과 Fragment에 리스트를 출력하는 RecyclerView 추가
+- [x]  RecyclerView Adapter에서 ViewModel의 데이터를 Observe하여 ViewModel의 검색 결과 데이터의 변화에 따라 리스트의 값을 갱신하도록 구현
+- [x]  SearchInput 에서 텍스트가 변화할 때마다 ViewModel에서 검색 결과를 갱신하도록 구현
+- [ ]  SearchKeyword 테이블 스키마 및 Contract 생성
+- [ ]  SearchKeyword 테이블 관련 헬퍼 메소드 작성
+- [ ]  Keyword를 저장하는 레포지토리 클래스 생성
+- [ ]  검색 바 아래 KeywordList 생성
+- [ ]  검색 바 Text값을 ViewModel에 바인딩
+- [ ]  ViewModel에 Keyword 클릭 시 해당 검색어 검색하는 메소드 생성
+- [ ]  ViewModel에 Keyword 제거하는 메소드 생성
+- [ ]  ViewModel의 검색 메소드에 KeywordRepository로 새로운 Keyword 저장하는 기능 추가
+- [ ]  MainActivity에서 Keyword 목록을 Observe하여 자동으로 갱신되는 KeywordList Layout 추가 (ListView 활용)

app/build.gradle.kts

@@ -41,6 +41,8 @@ android {
 
 dependencies {
 
+    implementation ("androidx.activity:activity-ktx:1.2.2")
+    implementation ("androidx.fragment:fragment-ktx:1.3.3")
     implementation("androidx.core:core-ktx:1.12.0")
     implementation("androidx.appcompat:appcompat:1.6.1")
     implementation("com.google.android.material:material:1.11.0")

app/src/main/AndroidManifest.xml

@@ -13,7 +13,7 @@
         android:theme="@style/Theme.Map"
         tools:targetApi="31">
         <activity
-            android:name=".MainActivity"
+            android:name=".views.MainActivity"
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

app/src/main/java/campus/tech/kakao/map/models/InitialDataset.kt

@@ -0,0 +1,27 @@
+package campus.tech.kakao.map.models
+
+object InitialDataset {
+    val initialData:List<SearchResult> = listOf(
+        SearchResult("카페1", "대구 달서구 복현동 1", "카페"),
+        SearchResult("카페2", "대구 달서구 복현동 2", "카페"),
+        SearchResult("카페3", "대구 달서구 복현동 3", "카페"),
+        SearchResult("카페4", "대구 달서구 복현동 4", "카페"),
+        SearchResult("카페5", "대구 달서구 복현동 5", "카페"),
+        SearchResult("카페6", "대구 달서구 복현동 6", "카페"),
+        SearchResult("카페7", "대구 달서구 복현동 7", "카페"),
+        SearchResult("음식점1", "대구 달서구 송현동 1", "음식점"),
+        SearchResult("음식점2", "대구 달서구 송현동 2", "음식점"),
+        SearchResult("음식점3", "대구 달서구 송현동 3", "음식점"),
+        SearchResult("음식점4", "대구 달서구 송현동 4", "음식점"),
+        SearchResult("음식점5", "대구 달서구 송현동 5", "음식점"),
+        SearchResult("음식점6", "대구 달서구 송현동 6", "음식점"),
+        SearchResult("음식점7", "대구 달서구 송현동 7", "음식점"),
+        SearchResult("음식점8", "대구 달서구 송현동 8", "음식점"),
+        SearchResult("음식점9", "대구 달서구 송현동 9", "음식점"),
+        SearchResult("음식점10", "대구 달서구 송현동 10", "음식점"),
+        SearchResult("음식점11", "대구 달서구 송현동 11", "음식점"),
+        SearchResult("음식점12", "대구 달서구 송현동 12", "음식점"),
+        SearchResult("음식점13", "대구 달서구 송현동 13", "음식점"),
+        SearchResult("음식점14", "대구 달서구 송현동 14", "음식점")
+    )
+}

app/src/main/java/campus/tech/kakao/map/models/SearchDbHelper.kt

@@ -0,0 +1,181 @@
+package campus.tech.kakao.map.models
+
+import android.content.ContentValues
+import android.content.Context
+import android.database.Cursor
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteOpenHelper
+import android.provider.BaseColumns
+import campus.tech.kakao.map.models.contracts.SearchKeywordContract
+import campus.tech.kakao.map.models.contracts.SearchResultContract
+
+data class SearchResult(val name: String, val address: String, val type: String)
+
+class SearchDbHelper(context: Context) :
+    SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
+    override fun onCreate(db: SQLiteDatabase?) {
+        db?.execSQL(SearchResultContract.CREATE_QUERY)
+
+        if (db != null) {
+            insertInitialData(db)
+        }
+    }
+
+    override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {
+        if (oldVersion <= 1) {
+            db?.execSQL(SearchKeywordContract.CREATE_QUERY)
+        }
+        if (oldVersion in 2..2) {
+            db?.execSQL(SearchKeywordContract.DROP_QUERY)
+            db?.execSQL(SearchKeywordContract.CREATE_QUERY)
+        }
+    }
+
+    private fun insertInitialData(db: SQLiteDatabase) {
+        val dataList = InitialDataset.initialData
+        for (data in dataList) {
+            val contentValues = ContentValues().apply {
+                put(SearchResultContract.COLUMN_NAME, data.name)
+                put(SearchResultContract.COLUMN_ADDRESS, data.address)
+                put(SearchResultContract.COLUMN_TYPE, data.type)
+            }
+            db.insert(SearchResultContract.TABLE_NAME, null, contentValues)
+        }
+    }
+
+    fun insertSearchResult(name: String, address: String, type: String) {
+        val db = writableDatabase
+        val contentValues = ContentValues().apply {
+            put(SearchResultContract.COLUMN_NAME, name)
+            put(SearchResultContract.COLUMN_ADDRESS, address)
+            put(SearchResultContract.COLUMN_TYPE, type)
+        }
+        db.insert(SearchResultContract.TABLE_NAME, null, contentValues)
+    }
+
+    fun insertSearchResult(searchResult: SearchResult) {
+        insertSearchResult(searchResult.name, searchResult.address, searchResult.type)
+    }
+
+    fun insertOrReplaceKeyword(keyword: String) {
+        val db = writableDatabase
+        val contentValues = ContentValues().apply {
+            put(SearchKeywordContract.COLUMN_KEYWORD, keyword)
+        }
+
+        db.replace(SearchKeywordContract.TABLE_NAME, null, contentValues)
+    }
+
+    fun updateSearchResult(id: String, name: String, address: String, type: String) {
+        val db = writableDatabase
+        val contentValues = ContentValues().apply {
+            put(BaseColumns._ID, id)
+            put(SearchResultContract.COLUMN_NAME, name)
+            put(SearchResultContract.COLUMN_ADDRESS, address)
+            put(SearchResultContract.COLUMN_TYPE, type)
+        }
+        db.update(
+            SearchResultContract.TABLE_NAME,
+            contentValues,
+            "${BaseColumns._ID} = ?",
+            arrayOf(id)
+        )
+    }
+
+    fun updateSearchResult(id: String, searchResult: SearchResult) {
+        updateSearchResult(id, searchResult.name, searchResult.address, searchResult.type)
+    }
+
+    fun deleteSearchResult(id: String) {
+        val db = writableDatabase
+        db.delete(SearchResultContract.TABLE_NAME, "${BaseColumns._ID} = ?", arrayOf(id))
+    }
+
+    fun deleteKeyword(keyword: String) {
+        val db = writableDatabase
+        db.delete(
+            SearchKeywordContract.TABLE_NAME,
+            "${SearchKeywordContract.COLUMN_KEYWORD} = ?",
+            arrayOf(keyword)
+        )
+    }
+
+    private fun getAllSearchResultFromCursor(cursor: Cursor?): List<SearchResult> {
+        val result = mutableListOf<SearchResult>()
+
+        try {
+            while (cursor?.moveToNext() == true) {
+                result.add(
+                    SearchResult(
+                        cursor.getString(1),
+                        cursor.getString(2),
+                        cursor.getString(3)
+                    )
+                )
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        } finally {
+            if (cursor != null && !cursor.isClosed) {
+                cursor.close()
+            }
+        }
+
+        return result
+    }
+
+    private fun getAllSearchKeywordFromCursor(cursor: Cursor?): List<String> {
+        val result = mutableListOf<String>()
+
+        try {
+            while (cursor?.moveToNext() == true) {
+                result.add(cursor.getString(1))
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        } finally {
+            if (cursor != null && !cursor.isClosed) {
+                cursor.close()
+            }
+        }
+
+        return result
+    }
+
+    fun queryAllSearchResults(): List<SearchResult> {
+        val db = readableDatabase
+        val cursor = db.rawQuery("SELECT * FROM ${SearchResultContract.TABLE_NAME}", null)
+
+        return getAllSearchResultFromCursor(cursor)
+    }
+
+    fun querySearchResultsByName(name: String): List<SearchResult> {
+        val db = readableDatabase
+        val cursor = db.rawQuery(
+            "SELECT * FROM ${SearchResultContract.TABLE_NAME} WHERE ${SearchResultContract.COLUMN_NAME} LIKE \"%$name%\"",
+            null
+        )
+
+        return getAllSearchResultFromCursor(cursor)
+    }
+
+    fun queryAllSearchKeywords(): List<String> {
+        val db = readableDatabase
+        val cursor = db.rawQuery("SELECT * FROM ${SearchKeywordContract.TABLE_NAME}", null)
+
+        return getAllSearchKeywordFromCursor(cursor)
+    }
+
+    companion object {
+        private var instance: SearchDbHelper? = null
+        const val DATABASE_VERSION = 3
+        const val DATABASE_NAME = "MapSearch"
+
+        fun getInstance(context: Context): SearchDbHelper {
+            if (instance == null) {
+                instance = SearchDbHelper(context)
+            }
+            return instance as SearchDbHelper
+        }
+    }
+}

app/src/main/java/campus/tech/kakao/map/models/SearchKeywordRepository.kt

@@ -0,0 +1,53 @@
+package campus.tech.kakao.map.models
+
+import android.content.Context
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class SearchKeywordRepository(context: Context) {
+    private val _keywords: MutableLiveData<List<String>> = MutableLiveData(listOf())
+    val keywords: LiveData<List<String>>
+        get() = _keywords
+
+    private lateinit var searchDb: SearchDbHelper
+    init {
+        searchDb = SearchDbHelper(context)
+    }
+
+    fun addKeyword(keyword: String) {
+        CoroutineScope(Dispatchers.IO).launch {
+            searchDb.insertOrReplaceKeyword(keyword)
+            val newData = searchDb.queryAllSearchKeywords()
+            _keywords.postValue(newData)
+        }
+    }
+
+    fun deleteKeyword(keyword: String) {
+        CoroutineScope(Dispatchers.IO).launch {
+            searchDb.deleteKeyword(keyword)
+            val newData = searchDb.queryAllSearchKeywords()
+            _keywords.postValue(newData)
+        }
+    }
+
+    fun getKeywords() {
+        CoroutineScope(Dispatchers.IO).launch {
+            val newData = searchDb.queryAllSearchKeywords()
+            _keywords.postValue(newData)
+        }
+    }
+
+    companion object {
+        private var instance: SearchKeywordRepository? = null
+
+        fun getInstance(context: Context): SearchKeywordRepository {
+            if (instance == null) {
+                instance = SearchKeywordRepository(context)
+            }
+            return instance as SearchKeywordRepository
+        }
+    }
+}

app/src/main/java/campus/tech/kakao/map/models/SearchResultRepository.kt

@@ -0,0 +1,38 @@
+package campus.tech.kakao.map.models
+
+import android.content.Context
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class SearchResultRepository(context: Context) {
+    private val _searchResult: MutableLiveData<List<SearchResult>> = MutableLiveData(listOf())
+    val searchResult: LiveData<List<SearchResult>>
+        get() = _searchResult
+
+    private lateinit var searchDb: SearchDbHelper
+
+    init {
+        searchDb = SearchDbHelper(context)
+    }
+
+    fun search(text: String) {
+        CoroutineScope(Dispatchers.IO).launch {
+            val result = searchDb.querySearchResultsByName(text)
+            _searchResult.postValue(result)
+        }
+    }
+
+    companion object {
+        private var instance: SearchResultRepository? = null
+
+        fun getInstance(context: Context): SearchResultRepository {
+            if (instance == null) {
+                instance = SearchResultRepository(context)
+            }
+            return instance as SearchResultRepository
+        }
+    }
+}

app/src/main/java/campus/tech/kakao/map/models/contracts/SearchKeywordContract.kt

@@ -0,0 +1,15 @@
+package campus.tech.kakao.map.models.contracts
+
+import android.provider.BaseColumns
+
+object SearchKeywordContract : BaseColumns {
+    const val TABLE_NAME = "SEARCH_KEYWORD"
+    const val COLUMN_KEYWORD = "keyword"
+
+    const val CREATE_QUERY = "CREATE TABLE IF NOT EXISTS $TABLE_NAME (" +
+            "${BaseColumns._ID} INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "$COLUMN_KEYWORD TEXT," +
+            "UNIQUE($COLUMN_KEYWORD))"
+
+    const val DROP_QUERY = "DROP TABLE IF EXISTS $TABLE_NAME"
+}

app/src/main/java/campus/tech/kakao/map/models/contracts/SearchResultContract.kt

@@ -0,0 +1,18 @@
+package campus.tech.kakao.map.models.contracts
+
+import android.provider.BaseColumns._ID
+
+object SearchResultContract {
+    const val TABLE_NAME = "SEARCH_RESULT"
+    const val COLUMN_NAME = "name"
+    const val COLUMN_ADDRESS = "address"
+    const val COLUMN_TYPE = "type"
+
+    const val CREATE_QUERY = "CREATE TABLE IF NOT EXISTS $TABLE_NAME (" +
+            "$_ID INTEGER PRIMARY KEY AUTOINCREMENT, " +
+            "$COLUMN_NAME TEXT, " +
+            "$COLUMN_ADDRESS TEXT, " +
+            "$COLUMN_TYPE TEXT)"
+
+    const val DROP_QUERY = "DROP TABLE IF EXISTS $TABLE_NAME"
+}