fix: synchronous reorder for keywords and sites (v0.3.0)

app/build.gradle.kts

@@ -24,8 +24,8 @@ android {
  applicationId = "com.hotdeal.alarm"
  minSdk = 31
  targetSdk = 35
-        versionCode = 27
+        versionCode = 30
-        versionName = "0.2.7"
+        versionName = "0.3.0"
 
  testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  vectorDrawables {

app/src/main/java/com/hotdeal/alarm/data/local/preferences/AppSettings.kt

@@ -5,7 +5,9 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
+import com.hotdeal.alarm.domain.model.SiteType
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
@@ -18,11 +20,13 @@ class AppSettings(private val context: Context) {
 
     companion object {
         private val POLLING_INTERVAL_KEY = intPreferencesKey("polling_interval_minutes")
+        private val SITE_ORDER_KEY = stringPreferencesKey("site_order_list")
+        private val KEYWORD_ORDER_KEY = stringPreferencesKey("keyword_order_list")
         private const val DEFAULT_INTERVAL = 2
     }
 
     /**
-     * 폴� 주기 (분)
+     * 폴링 주기 (분)
      */
     val pollingInterval: Flow<Int> = context.dataStore.data
         .map { preferences ->
@@ -30,11 +34,72 @@ class AppSettings(private val context: Context) {
         }
 
     /**
-     * 폴� 주기 설정 저장
+     * 폴링 주기 설정 저장
      */
     suspend fun setPollingInterval(minutes: Int) {
         context.dataStore.edit { preferences ->
             preferences[POLLING_INTERVAL_KEY] = minutes
         }
     }
+
+    /**
+     * 사이트 표시 순서 목록
+     */
+    val siteOrder: Flow<List<SiteType>> = context.dataStore.data
+        .map { preferences ->
+            val savedStr = preferences[SITE_ORDER_KEY]
+            if (savedStr.isNullOrBlank()) {
+                SiteType.entries
+            } else {
+                val savedNames = savedStr.split(",")
+                val ordered = mutableListOf<SiteType>()
+                savedNames.forEach { name ->
+                    try {
+                        ordered.add(SiteType.valueOf(name.trim()))
+                    } catch (e: Exception) {
+                        // ignore invalid
+                    }
+                }
+                // 누락된 신규 사이트가 있으면 끝에 추가
+                SiteType.entries.forEach { site ->
+                    if (site !in ordered) {
+                        ordered.add(site)
+                    }
+                }
+                ordered
+            }
+        }
+
+    /**
+     * 사이트 표시 순서 저장
+     */
+    suspend fun setSiteOrder(order: List<SiteType>) {
+        val str = order.joinToString(",") { it.name }
+        context.dataStore.edit { preferences ->
+            preferences[SITE_ORDER_KEY] = str
+        }
+    }
+
+    /**
+     * 키워드 ID 표시 순서 목록
+     */
+    val keywordOrder: Flow<List<Long>> = context.dataStore.data
+        .map { preferences ->
+            val savedStr = preferences[KEYWORD_ORDER_KEY]
+            if (savedStr.isNullOrBlank()) {
+                emptyList()
+            } else {
+                savedStr.split(",").mapNotNull { it.trim().toLongOrNull() }
+            }
+        }
+
+    /**
+     * 키워드 ID 표시 순서 저장
+     */
+    suspend fun setKeywordOrder(order: List<Long>) {
+        val str = order.joinToString(",") { it.toString() }
+        context.dataStore.edit { preferences ->
+            preferences[KEYWORD_ORDER_KEY] = str
+        }
+    }
 }

app/src/main/java/com/hotdeal/alarm/presentation/components/DragDropListState.kt

@@ -0,0 +1,117 @@
+package com.hotdeal.alarm.presentation.components
+
+import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.zIndex
+
+/**
+ * Key 기반 드래그 앤 드롭 Reorder 시스템
+ *
+ * - 각 아이템에 item-level long-press 제스처를 적용하여 드래그 시작
+ * - 드래그 중 다른 아이템의 중심점과 겹치면 swap 실행
+ * - swap 시 delta 보정으로 시각적 점프 방지
+ * - 비드래그 아이템은 animateItemPlacement()로 부드러운 슬라이드
+ */
+@Composable
+fun rememberReorderState(
+    listState: LazyListState,
+    onSwap: (fromListIndex: Int, toListIndex: Int) -> Boolean
+): ReorderState {
+    return remember(listState) {
+        ReorderState(listState, onSwap)
+    }
+}
+
+@Stable
+class ReorderState(
+    val listState: LazyListState,
+    private val onSwap: (Int, Int) -> Boolean
+) {
+    /** 현재 드래그 중인 아이템의 key (null이면 드래그 없음) */
+    var draggedKey by mutableStateOf<Any?>(null)
+        private set
+
+    /** 누적 드래그 Y축 오프셋 */
+    var dragDelta by mutableFloatStateOf(0f)
+        private set
+
+    fun startDrag(key: Any) {
+        draggedKey = key
+        dragDelta = 0f
+    }
+
+    fun updateDrag(delta: Offset) {
+        if (draggedKey == null) return
+        dragDelta += delta.y
+        checkOverlap()
+    }
+
+    fun endDrag() {
+        draggedKey = null
+        dragDelta = 0f
+    }
+
+    private fun checkOverlap() {
+        val dragged = listState.layoutInfo.visibleItemsInfo
+            .firstOrNull { it.key == draggedKey } ?: return
+
+        val draggedMid = dragged.offset + dragged.size / 2f + dragDelta
+
+        val target = listState.layoutInfo.visibleItemsInfo
+            .firstOrNull { item ->
+                item.key != draggedKey &&
+                draggedMid >= item.offset.toFloat() &&
+                draggedMid < (item.offset + item.size).toFloat()
+            } ?: return
+
+        if (dragged.index == target.index) return
+
+        val swapped = onSwap(dragged.index, target.index)
+        if (swapped) {
+            // swap 후 아이템이 새 위치로 이동하므로, 시각적 점프를 막기 위해 delta 보정
+            dragDelta += if (dragged.index < target.index) {
+                -target.size.toFloat()
+            } else {
+                target.size.toFloat()
+            }
+        }
+    }
+}
+
+/**
+ * 개별 아이템에 부착하는 드래그 핸들 + 시각 효과 Modifier
+ * - 길게 누르면 드래그 시작
+ * - 드래그 중 아이템이 떠오르며 그림자 및 스케일업
+ */
+fun Modifier.reorderableItem(
+    state: ReorderState,
+    key: Any
+): Modifier {
+    val isDragged = state.draggedKey == key
+    return this
+        .zIndex(if (isDragged) 10f else 0f)
+        .graphicsLayer {
+            if (isDragged) {
+                translationY = state.dragDelta
+                scaleX = 1.03f
+                scaleY = 1.03f
+                shadowElevation = 16f
+            }
+        }
+        .pointerInput(key) {
+            detectDragGesturesAfterLongPress(
+                onDragStart = { state.startDrag(key) },
+                onDrag = { change, dragAmount ->
+                    change.consume()
+                    state.updateDrag(dragAmount)
+                },
+                onDragEnd = { state.endDrag() },
+                onDragCancel = { state.endDrag() }
+            )
+        }
+}

app/src/main/java/com/hotdeal/alarm/presentation/deallist/DealListScreen.kt

@@ -53,6 +53,7 @@ fun DealListScreen(
     onNavigateToSettings: () -> Unit = {}
 ) {
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val siteOrder by viewModel.siteOrder.collectAsStateWithLifecycle()
     val context = LocalContext.current
     val focusManager = LocalFocusManager.current
 
@@ -306,7 +307,7 @@ fun DealListScreen(
                         accentColor = FavoriteColor
                     )
 
-                    SiteType.entries.forEach { siteType ->
+                    siteOrder.forEach { siteType ->
                         val siteColor = getSiteColor(siteType)
                         FilterPillChip(
                             selected = selectedSiteFilter == siteType,

app/src/main/java/com/hotdeal/alarm/presentation/main/MainScreen.kt

@@ -82,7 +82,7 @@ fun MainScreen(viewModel: MainViewModel) {
                 Row(
                     modifier = Modifier
                         .fillMaxWidth()
-                        .height(54.dp),
+                        .height(48.dp),
                     verticalAlignment = Alignment.CenterVertically
                 ) {
                     val navItems = listOf(
@@ -119,29 +119,29 @@ fun MainScreen(viewModel: MainViewModel) {
                                 if (isSelected) {
                                     Box(
                                         modifier = Modifier
-                                            .width(20.dp)
+                                            .width(18.dp)
-                                            .height(3.dp)
+                                            .height(2.5.dp)
                                             .clip(CornerRadius.shapePill)
                                             .background(MaterialTheme.colorScheme.primary)
                                     )
-                                    Spacer(modifier = Modifier.height(3.dp))
+                                    Spacer(modifier = Modifier.height(2.dp))
                                 } else {
-                                    Spacer(modifier = Modifier.height(6.dp))
+                                    Spacer(modifier = Modifier.height(4.5.dp))
                                 }
 
                                 Icon(
                                     imageVector = if (isSelected) selectedIcon else unselectedIcon,
                                     contentDescription = label,
                                     tint = itemColor,
-                                    modifier = Modifier.size(22.dp)
+                                    modifier = Modifier.size(20.dp)
                                 )
 
-                                Spacer(modifier = Modifier.height(2.dp))
+                                Spacer(modifier = Modifier.height(1.dp))
 
                                 Text(
                                     text = label,
                                     style = MaterialTheme.typography.labelSmall.copy(
-                                        fontSize = 11.sp,
+                                        fontSize = 10.5.sp,
                                         fontWeight = if (isSelected) FontWeight.Bold else FontWeight.Medium
                                     ),
                                     color = itemColor

app/src/main/java/com/hotdeal/alarm/presentation/main/MainViewModel.kt

@@ -5,15 +5,15 @@ import androidx.lifecycle.viewModelScope
 import com.hotdeal.alarm.data.local.db.dao.HotDealDao
 import com.hotdeal.alarm.data.local.db.dao.KeywordDao
 import com.hotdeal.alarm.data.local.db.dao.SiteConfigDao
+import com.hotdeal.alarm.data.local.db.entity.KeywordEntity
 import com.hotdeal.alarm.data.local.db.entity.SiteConfigEntity
 import com.hotdeal.alarm.data.local.preferences.AppSettings
+import com.hotdeal.alarm.domain.model.Keyword
 import com.hotdeal.alarm.domain.model.SiteType
 import com.hotdeal.alarm.worker.WorkerScheduler
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
 import javax.inject.Inject
 
 @HiltViewModel
@@ -28,10 +28,17 @@ class MainViewModel @Inject constructor(
     private val _uiState = MutableStateFlow<MainUiState>(MainUiState.Loading)
     val uiState: StateFlow<MainUiState> = _uiState.asStateFlow()
 
-    // 폴링 주기 (저장된 값 즉시 반영)
+    // 폴링 주기
     val pollingInterval: StateFlow<Int> = appSettings.pollingInterval
         .stateIn(viewModelScope, SharingStarted.Eagerly, 2)
 
+    // 사이트 표시 순서
+    val siteOrder: StateFlow<List<SiteType>> = appSettings.siteOrder
+        .stateIn(viewModelScope, SharingStarted.Eagerly, SiteType.entries)
+
+    private val _toastEvent = MutableSharedFlow<String>()
+    val toastEvent: SharedFlow<String> = _toastEvent.asSharedFlow()
+
     init {
         initializeApp()
     }
@@ -40,7 +47,6 @@ class MainViewModel @Inject constructor(
         viewModelScope.launch {
             initializeDefaultSiteConfigs()
             loadState()
-            // 저장된 폴� 주기로 시작
             val savedInterval = appSettings.pollingInterval.first()
             startPolling(savedInterval.toLong())
         }
@@ -72,12 +78,22 @@ class MainViewModel @Inject constructor(
         combine(
             hotDealDao.observeAllDeals(),
             siteConfigDao.observeAllConfigs(),
-            keywordDao.observeAllKeywords()
+            keywordDao.observeAllKeywords(),
-        ) { deals, configs, keywords ->
+            appSettings.keywordOrder
+        ) { deals, configs, keywords, keywordOrder ->
+            // 사용자가 설정한 키워드 순서에 따라 정렬
+            val domainKeywords = keywords.map { it.toDomain() }
+            val sortedKeywords = if (keywordOrder.isEmpty()) {
+                domainKeywords
+            } else {
+                val orderMap = keywordOrder.withIndex().associate { it.value to it.index }
+                domainKeywords.sortedBy { orderMap[it.id] ?: Int.MAX_VALUE }
+            }
+
             MainUiState.Success(
                 deals = deals.map { it.toDomain() },
                 siteConfigs = configs.map { it.toDomain() },
-                keywords = keywords.map { it.toDomain() }
+                keywords = sortedKeywords
             )
         }.catch { e ->
             _uiState.value = MainUiState.Error(e.message ?: "Unknown error")
@@ -92,55 +108,81 @@ class MainViewModel @Inject constructor(
         }
     }
 
+    fun reorderSites(fromIndex: Int, toIndex: Int) {
+        // siteOrder는 appSettings.siteOrder에서 stateIn으로 가져오므로
+        // appSettings를 즉시 저장하고 Flow가 업데이트되도록 함
+        val current = siteOrder.value.toMutableList()
+        if (fromIndex in current.indices && toIndex in current.indices) {
+            val item = current.removeAt(fromIndex)
+            current.add(toIndex, item)
+            viewModelScope.launch {
+                appSettings.setSiteOrder(current)
+            }
+        }
+    }
+
     fun addKeyword(keyword: String) {
         if (keyword.isBlank()) return
         viewModelScope.launch {
-            keywordDao.insertKeyword(
+            val newId = keywordDao.insertKeyword(
-                com.hotdeal.alarm.data.local.db.entity.KeywordEntity(
+                KeywordEntity(
                     keyword = keyword.trim(),
                     isEnabled = true
                 )
             )
+            val currentOrder = appSettings.keywordOrder.first().toMutableList()
+            currentOrder.add(0, newId)
+            appSettings.setKeywordOrder(currentOrder)
         }
     }
 
     fun deleteKeyword(id: Long) {
         viewModelScope.launch {
             keywordDao.deleteKeywordById(id)
+            val currentOrder = appSettings.keywordOrder.first().toMutableList()
+            currentOrder.remove(id)
+            appSettings.setKeywordOrder(currentOrder)
         }
     }
 
- fun toggleKeyword(id: Long, enabled: Boolean) {
+    fun toggleKeyword(id: Long, enabled: Boolean) {
- viewModelScope.launch {
+        viewModelScope.launch {
- keywordDao.updateEnabled(id, enabled)
+            keywordDao.updateEnabled(id, enabled)
- }
+        }
- }
+    }
 
- /**
+    fun reorderKeywords(fromIndex: Int, toIndex: Int) {
- * 즐겨찾기 토글
+        // uiState를 동기적으로 즉시 업데이트하여 빠른 드래그 시 stale 데이터 방지
- */
+        val state = _uiState.value as? MainUiState.Success ?: return
- fun toggleFavorite(dealId: String) {
+        val current = state.keywords.toMutableList()
- viewModelScope.launch {
+        if (fromIndex in current.indices && toIndex in current.indices) {
- hotDealDao.toggleFavorite(dealId)
+            val item = current.removeAt(fromIndex)
- }
+            current.add(toIndex, item)
- }
+            // UI 즉시 갱신
+            _uiState.value = state.copy(keywords = current)
+            // DataStore 비동기 영속화
+            viewModelScope.launch {
+                appSettings.setKeywordOrder(current.map { it.id })
+            }
+        }
+    }
 
- /**
+    fun toggleFavorite(dealId: String) {
- * 즐겨찾기 설정
+        viewModelScope.launch {
- */
+            hotDealDao.toggleFavorite(dealId)
- fun setFavorite(dealId: String, isFavorite: Boolean) {
+        }
- viewModelScope.launch {
+    }
- hotDealDao.setFavorite(dealId, isFavorite)
+
- }
+    fun setFavorite(dealId: String, isFavorite: Boolean) {
- }
+        viewModelScope.launch {
+            hotDealDao.setFavorite(dealId, isFavorite)
+        }
+    }
 
     fun refresh() {
         workerScheduler.executeOnce()
     }
 
-    /**
-     * 폴� 시작 (주기 저장)
-     */
     fun startPolling(intervalMinutes: Long = WorkerScheduler.DEFAULT_INTERVAL_MINUTES) {
         viewModelScope.launch {
             appSettings.setPollingInterval(intervalMinutes.toInt())
@@ -152,20 +194,20 @@ class MainViewModel @Inject constructor(
         workerScheduler.cancelPolling()
     }
 
-    // 데이터 파싱 핫딜 데이터 전체 삭제 및 사용자 피드백 트리거
-    private val _toastEvent = MutableSharedFlow<String>(extraBufferCapacity = 1)
-    val toastEvent = _toastEvent.asSharedFlow()
-
     fun deleteAllParsedData() {
         viewModelScope.launch {
-            hotDealDao.deleteAllDeals()
+            try {
-            _toastEvent.emit("파싱 데이터가 삭제되었습니다")
+                hotDealDao.deleteAllDeals()
+                _toastEvent.emit("모든 수집 데이터가 삭제되었습니다")
+            } catch (e: Exception) {
+                _toastEvent.emit("데이터 삭제 중 오류가 발생했습니다: ${e.message}")
+            }
         }
     }
 }
 
 sealed class MainUiState {
-    data object Loading : MainUiState()
+    object Loading : MainUiState()
     data class Success(
         val deals: List<com.hotdeal.alarm.domain.model.HotDeal>,
         val siteConfigs: List<com.hotdeal.alarm.domain.model.SiteConfig>,

app/src/main/java/com/hotdeal/alarm/util/ApkDownloadManager.kt

@@ -25,7 +25,6 @@ object ApkDownloadManager {
     private const val TAG = "ApkDownloadManager"
     private const val APK_FILE_NAME = "hotdeal-alarm-update.apk"
 
-    // 등록된 리시버 추적 (메모리 누수 방지)
     private var registeredReceiver: BroadcastReceiver? = null
 
     /**
@@ -34,31 +33,29 @@ object ApkDownloadManager {
     fun downloadApk(context: Context, updateInfo: UpdateInfo): Long {
         val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
 
-        // 기존 파일 삭제
+        val outputDir = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)
-        val outputFile = File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), APK_FILE_NAME)
+        if (outputDir != null && !outputDir.exists()) {
+            outputDir.mkdirs()
+        }
+
+        val outputFile = File(outputDir, APK_FILE_NAME)
         if (outputFile.exists()) {
             outputFile.delete()
         }
 
         val request = DownloadManager.Request(Uri.parse(updateInfo.updateUrl)).apply {
             setTitle("핫딜 알람 업데이트")
-            setDescription("버전 ${updateInfo.version} 다운로드 중...")
+            setDescription("v${updateInfo.version} 다운로드 중...")
             setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
             setDestinationInExternalFilesDir(context, Environment.DIRECTORY_DOWNLOADS, APK_FILE_NAME)
             setAllowedOverMetered(true)
             setAllowedOverRoaming(true)
             setMimeType("application/vnd.android.package-archive")
-            // Wi-Fi 환경에서 다운로드 우선
             setAllowedNetworkTypes(DownloadManager.Request.NETWORK_WIFI or DownloadManager.Request.NETWORK_MOBILE)
         }
 
         val downloadId = downloadManager.enqueue(request)
-
+        Log.d(TAG, "다운로드 큐에 추가됨: downloadId=$downloadId, url=${updateInfo.updateUrl}")
-        Toast.makeText(
-            context,
-            "업데이트 다운로드 시작...",
-            Toast.LENGTH_SHORT
-        ).show()
 
         return downloadId
     }
@@ -72,14 +69,13 @@ object ApkDownloadManager {
         onComplete: () -> Unit,
         onFailed: () -> Unit
     ): BroadcastReceiver {
-        // 기존 리시버가 있으면 먼저 해제
         unregisterDownloadCompleteReceiver(context)
 
         val receiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context?, intent: Intent?) {
+            override fun onReceive(receivedContext: Context?, intent: Intent?) {
                 val id = intent?.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1) ?: -1
                 if (id == downloadId) {
-                    val downloadManager = context?.getSystemService(Context.DOWNLOAD_SERVICE) as? DownloadManager
+                    val downloadManager = receivedContext?.getSystemService(Context.DOWNLOAD_SERVICE) as? DownloadManager
                     val query = DownloadManager.Query().setFilterById(downloadId)
                     val cursor = downloadManager?.query(query)
 
@@ -90,16 +86,14 @@ object ApkDownloadManager {
 
                             when (status) {
                                 DownloadManager.STATUS_SUCCESSFUL -> {
-                                    Log.d(TAG, "다운로드 완료, 설치 시작")
+                                    Log.d(TAG, "다운로드 완료 감지, onComplete 호출")
                                     onComplete()
-                                    // 설치 후 리시버 해제
+                                    unregisterDownloadCompleteReceiver(receivedContext ?: context)
-                                    unregisterDownloadCompleteReceiver(context)
                                 }
                                 DownloadManager.STATUS_FAILED -> {
-                                    Log.e(TAG, "다운로드 실패")
+                                    Log.e(TAG, "다운로드 실패 감지")
                                     onFailed()
-                                    // 실패 시 리시버 해제
+                                    unregisterDownloadCompleteReceiver(receivedContext ?: context)
-                                    unregisterDownloadCompleteReceiver(context)
                                 }
                             }
                         }
@@ -108,12 +102,11 @@ object ApkDownloadManager {
             }
         }
 
-        // Android 12+ 에서는 RECEIVER_NOT_EXPORTED 플래그 필요
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             context.registerReceiver(
                 receiver,
                 IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE),
-                Context.RECEIVER_NOT_EXPORTED
+                Context.RECEIVER_EXPORTED
             )
         } else {
             context.registerReceiver(
@@ -123,29 +116,20 @@ object ApkDownloadManager {
         }
 
         registeredReceiver = receiver
-        Log.d(TAG, "다운로드 리시버 등록됨, downloadId=$downloadId")
-
         return receiver
     }
 
-    /**
-     * 다운로드 완료 리시버 해제
-     */
     fun unregisterDownloadCompleteReceiver(context: Context) {
         registeredReceiver?.let { receiver ->
             try {
                 context.unregisterReceiver(receiver)
-                Log.d(TAG, "다운로드 리시버 해제됨")
             } catch (e: Exception) {
-                Log.w(TAG, "리시버 해제 실패 (이미 해제됨): ${e.message}")
+                Log.w(TAG, "리시버 해제 중 예외: ${e.message}")
             }
             registeredReceiver = null
         }
     }
 
-    /**
-     * 다운로드 상태 확인 (suspend 함수)
-     */
     suspend fun getDownloadStatus(context: Context, downloadId: Long): DownloadStatus =
         withContext(Dispatchers.IO) {
             val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
@@ -161,8 +145,8 @@ object ApkDownloadManager {
                     val bytesTotalIndex = it.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES)
 
                     val downloadStatus = it.getInt(statusIndex)
-                    val bytesDownloaded = it.getLong(bytesDownloadedIndex)
+                    val bytesDownloaded = if (bytesDownloadedIndex >= 0) it.getLong(bytesDownloadedIndex) else 0L
-                    val bytesTotal = it.getLong(bytesTotalIndex)
+                    val bytesTotal = if (bytesTotalIndex >= 0) it.getLong(bytesTotalIndex) else 0L
 
                     val progress = if (bytesTotal > 0) {
                         ((bytesDownloaded * 100) / bytesTotal).toInt()
@@ -181,26 +165,27 @@ object ApkDownloadManager {
         }
 
     /**
-     * 다운로드 완료 대기 (suspend 함수)
+     * APK 파일 설치 화면 실행
-     */
-    suspend fun waitForDownload(context: Context, downloadId: Long): Boolean {
-        while (true) {
-            val status = getDownloadStatus(context, downloadId)
-            if (status.isComplete) return true
-            if (status.isFailed) return false
-            delay(500)
-        }
-    }
-
-    /**
-     * APK 파일 설치
-     * @return Boolean true if installation started, false if permission denied
      */
     fun installApk(context: Context): Boolean {
+        // Android 8.0 이상에서 알 수 없는 앱 설치 권한 확인
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             if (!context.packageManager.canRequestPackageInstalls()) {
-                Log.w(TAG, "앱 설치 권한 없음")
+                Log.w(TAG, "앱 설치 권한 없음 -> 설정 화면 이동")
-                Toast.makeText(context, "설치 권한이 필요합니다. 설정에서 허용해주세요.", Toast.LENGTH_SHORT).show()
+                Toast.makeText(context, "앱 설치 권한을 허용한 후 다시 시도해주세요.", Toast.LENGTH_LONG).show()
+                try {
+                    val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
+                        data = Uri.parse("package:${context.packageName}")
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    }
+                    context.startActivity(intent)
+                } catch (e: Exception) {
+                    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                        data = Uri.parse("package:${context.packageName}")
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    }
+                    context.startActivity(intent)
+                }
                 return false
             }
         }
@@ -208,7 +193,8 @@ object ApkDownloadManager {
         val apkFile = File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), APK_FILE_NAME)
 
         if (!apkFile.exists()) {
-            Toast.makeText(context, "APK 파일을 찾을 수 없습니다", Toast.LENGTH_SHORT).show()
+            Log.e(TAG, "APK 파일이 존재하지 않음: ${apkFile.absolutePath}")
+            Toast.makeText(context, "APK 파일을 찾을 수 없습니다. 다시 다운로드해주세요.", Toast.LENGTH_SHORT).show()
             return false
         }
 
@@ -219,23 +205,23 @@ object ApkDownloadManager {
                 apkFile
             )
 
+            Log.d(TAG, "설치 인텐트 시작: uri=$apkUri")
             val intent = Intent(Intent.ACTION_VIEW).apply {
                 setDataAndType(apkUri, "application/vnd.android.package-archive")
                 addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
             }
 
             context.startActivity(intent)
             return true
         } catch (e: Exception) {
-            Toast.makeText(context, "설치를 시작할 수 없습니다: ${e.message}", Toast.LENGTH_SHORT).show()
+            Log.e(TAG, "설치 화면 호출 실패", e)
+            Toast.makeText(context, "설치 화면을 열 수 없습니다: ${e.message}", Toast.LENGTH_LONG).show()
             return false
         }
     }
 
-    /**
-     * 다운로드 상태 데이터 클래스
-     */
     data class DownloadStatus(
         val progress: Int,
         val bytesDownloaded: Long,

version.json

@@ -1,10 +1,10 @@
 {
-  "version": "0.2.7",
+  "version": "0.3.0",
-  "versionCode": 27,
+  "versionCode": 30,
-  "updateUrl": "https://git.webpluss.net/sanjeok77/hotdeal_alarm/releases/download/v0.2.7/app-release.apk",
+  "updateUrl": "https://git.webpluss.net/sanjeok77/hotdeal_alarm/releases/download/v0.3.0/app-release.apk",
   "changelog": [
-    "하단 고정 메뉴 일체형(Docked) 디자인 개선 (떠 있는 이질감 완전 제거)",
+    "사이트 및 키워드 순서 조절을 터치 드래그 앤 드롭(Drag & Drop) 방식으로 전면 업그레이드",
-    "시스템 내비게이션 바닥까지 끊김 없는 배경 처리 및 0.6dp 헤어라인 구분선",
+    "앱 내 업데이트 시 다운로드 완료 후 설치 화면으로 안 넘어가는 버그 수정",
-    "상단 미니 캡슐 인디케이터와 One UI 9 네이티브 탭 전환 감각 적용"
+    "새 버전 업데이트 안내 다이얼로그 및 진행률 프로그레스 바 연동"
   ]
 }