v0.3.3: fix dead code in initializeApp - split coroutines

app/build.gradle.kts

@@ -24,8 +24,8 @@ android {
  applicationId = "com.hotdeal.alarm"
  minSdk = 31
  targetSdk = 35
-        versionCode = 29
-        versionName = "0.2.9"
+        versionCode = 33
+        versionName = "0.3.3"
 
  testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  vectorDrawables {

app/src/main/AndroidManifest.xml

@@ -65,9 +65,16 @@
             android:exported="false"
             android:foregroundServiceType="dataSync" />
 
-    <!-- Boot Receiver -->
-
-    <!-- Widget -->
+    <!-- Boot Receiver: 부팅/앱 업데이트 후 백그라운드 폴링 자동 재등록 -->
+    <receiver
+        android:name=".receiver.BootReceiver"
+        android:enabled="true"
+        android:exported="true">
+        <intent-filter>
+            <action android:name="android.intent.action.BOOT_COMPLETED" />
+            <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+        </intent-filter>
+    </receiver>
     <receiver
         android:name=".widget.HotDealWidget"
         android:exported="true">

app/src/main/java/com/hotdeal/alarm/HotDealApplication.kt

@@ -1,9 +1,17 @@
 package com.hotdeal.alarm
 
 import android.app.Application
+import android.util.Log
 import androidx.hilt.work.HiltWorkerFactory
 import androidx.work.Configuration
+import com.hotdeal.alarm.data.local.preferences.AppSettings
+import com.hotdeal.alarm.worker.WorkerScheduler
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @HiltAndroidApp
@@ -12,13 +20,41 @@ class HotDealApplication : Application(), Configuration.Provider {
     @Inject
     lateinit var workerFactory: HiltWorkerFactory
 
+    @Inject
+    lateinit var workerScheduler: WorkerScheduler
+
+    @Inject
+    lateinit var appSettings: AppSettings
+
+    private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
     override val workManagerConfiguration: Configuration
         get() = Configuration.Builder()
             .setWorkerFactory(workerFactory)
+            .setMinimumLoggingLevel(Log.DEBUG)
             .build()
 
     override fun onCreate() {
         super.onCreate()
-        // Application initialization
+        // 앱 시작 시 백그라운드 폴링 즉시 등록/갱신
+        ensurePollingScheduled()
+    }
+
+    /**
+     * 앱이 시작될 때마다 백그라운드 폴링이 등록되어 있는지 확인하고,
+     * 없으면 즉시 등록합니다. UPDATE 정책으로 항상 최신 Worker가 동작합니다.
+     */
+    private fun ensurePollingScheduled() {
+        applicationScope.launch {
+            try {
+                val interval = appSettings.pollingInterval.first()
+                Log.d("HotDealApp", "백그라운드 폴링 등록/갱신: ${interval}분 간격")
+                workerScheduler.schedulePeriodicPolling(interval.toLong())
+            } catch (e: Exception) {
+                Log.e("HotDealApp", "폴링 스케줄 등록 실패: ${e.message}", e)
+                // 기본값으로 폴백
+                workerScheduler.schedulePeriodicPolling(WorkerScheduler.DEFAULT_INTERVAL_MINUTES)
+            }
+        }
     }
 }

app/src/main/java/com/hotdeal/alarm/data/local/db/dao/HotDealDao.kt

@@ -121,4 +121,10 @@ interface HotDealDao {
  */
  @Query("UPDATE hot_deals SET isFavorite = :isFavorite WHERE id = :id")
  suspend fun setFavorite(id: String, isFavorite: Boolean)
+
+ /**
+  * 인기글 상태 업데이트 (기존 데이터도 HOT 마킹 가능하도록)
+  */
+ @Query("UPDATE hot_deals SET isPopular = 1 WHERE id IN (:ids)")
+ suspend fun markAsPopular(ids: List<String>)
 }

app/src/main/java/com/hotdeal/alarm/data/remote/scraper/PpomppuScraper.kt

@@ -13,6 +13,8 @@ import kotlin.random.Random
 
 /**
  * 뽐뿌 스크래퍼
+ * - hotlist_flag=999 페이지에서 인기글 ID를 수집하여 HOT 뱃지 표시
+ * - 기존 hotpop_bg_color CSS 클래스도 폴백으로 감지
  */
 class PpomppuScraper(client: OkHttpClient) : BaseScraper(client) {
     
@@ -25,18 +27,18 @@ class PpomppuScraper(client: OkHttpClient) : BaseScraper(client) {
     
     override suspend fun scrape(board: String): Result<List<HotDeal>> = withContext(Dispatchers.IO) {
         try {
+            // 1단계: 인기글(hotlist) 페이지에서 인기 게시물 ID 목록 수집
+            val hotPostIds = fetchHotPostIds(board)
+            Log.d("Ppomppu", "인기글 ID ${hotPostIds.size}개 수집됨: $hotPostIds")
+
+            // 2단계: 일반 게시판 페이지 스크래핑
             val url = getBoardUrl(board)
             Log.d("Ppomppu", "스크래핑 시작: $url")
             
-            // 요청 간격 랜덤화 (2~4초) - 차단 방지
             val delayTime = Random.nextLong(2000, 4000)
-            Log.d("Ppomppu", "요청 대기: ${delayTime}ms")
             delay(delayTime)
             
-            // Jsoup으로 직접 연결 (User-Agent 회전)
             val userAgent = getRandomUserAgent()
-            Log.d("Ppomppu", "User-Agent: $userAgent")
-            
             val doc: Document = Jsoup.connect(url)
                 .userAgent(userAgent)
                 .header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
@@ -47,70 +49,91 @@ class PpomppuScraper(client: OkHttpClient) : BaseScraper(client) {
                 .followRedirects(true)
                 .get()
             
-            Log.d("Ppomppu", "문서 파싱 성공, 길이: ${doc.html().length}")
-            
             val deals = mutableListOf<HotDeal>()
+            val rowElements: Elements = doc.select("tr.baseList")
+            Log.d("Ppomppu", "찾은 행 요소: ${rowElements.size}개")
 
- // 셀렉터로 요소 찾기 - 인기 게시물 감지를 위해 tr 요소 선택
- val rowElements: Elements = doc.select("tr.baseList")
- Log.d("Ppomppu", "찾은 행 요소: ${rowElements.size}개")
+            var count = 0
+            rowElements.forEach { row ->
+                if (count >= 20) return@forEach
 
- // 최대 20개까지만 처리
- var count = 0
- rowElements.forEach { row ->
- if (count >= 20) return@forEach
+                try {
+                    val titleElement = row.selectFirst("a.baseList-title") ?: return@forEach
+                    val title = titleElement.text().trim()
+                    if (title.isEmpty()) return@forEach
 
- try {
- // 인기 게시물 여부 확인 (hotpop_bg_color 클래스 존재 여부)
- val isPopular = row.hasClass("hotpop_bg_color")
+                    val href = titleElement.attr("href")
+                    if (href.contains("regulation") || href.contains("notice")) return@forEach
 
- // 제목 링크 찾기
- val titleElement = row.selectFirst("a.baseList-title")
- if (titleElement == null) return@forEach
+                    val postId = extractPostId(href)
+                    if (postId.isEmpty()) {
+                        Log.w("Ppomppu", "postId 추출 실패: href=$href")
+                        return@forEach
+                    }
 
- val title = titleElement.text().trim()
- if (title.isEmpty()) return@forEach
+                    // 인기글 판단: hotlist 페이지에 포함되어 있거나 CSS 클래스로 감지
+                    val isPopular = postId in hotPostIds || row.hasClass("hotpop_bg_color")
 
- val href = titleElement.attr("href")
+                    val deal = HotDeal(
+                        id = HotDeal.generateId(siteName, postId),
+                        siteName = siteName,
+                        boardName = board,
+                        title = title,
+                        url = resolveUrl(baseUrl, href),
+                        createdAt = System.currentTimeMillis(),
+                        isPopular = isPopular
+                    )
+                    deals.add(deal)
+                    count++
+                    val popularMark = if (isPopular) " [인기]" else ""
+                    Log.d("Ppomppu", "[$count]$popularMark $title")
+                } catch (e: Exception) {
+                    Log.e("Ppomppu", "파싱 에러: ${e.message}")
+                }
+            }
 
- // 공지사항 제외
- if (href.contains("regulation") || href.contains("notice")) return@forEach
-
- val dealUrl = resolveUrl(baseUrl, href)
-
- // postId 추출
- val postId = extractPostId(href)
- if (postId.isEmpty()) {
- Log.w("Ppomppu", "postId 추출 실패: href=$href")
- return@forEach
- }
-
- val deal = HotDeal(
- id = HotDeal.generateId(siteName, postId),
- siteName = siteName,
- boardName = board,
- title = title,
- url = dealUrl,
- createdAt = System.currentTimeMillis(),
- isPopular = isPopular
- )
- deals.add(deal)
- count++
- val popularMark = if (isPopular) " [인기]" else ""
- Log.d("Ppomppu", "[$count]$popularMark $title")
- } catch (e: Exception) {
- Log.e("Ppomppu", "파싱 에러: ${e.message}")
- }
- }
-
-            Log.d("Ppomppu", "파싱 완료: ${deals.size}개")
+            Log.d("Ppomppu", "파싱 완료: ${deals.size}개 (인기: ${deals.count { it.isPopular }}개)")
             Result.success(deals)
         } catch (e: Exception) {
             Log.e("Ppomppu", "스크래핑 실패: ${e.message}", e)
             Result.failure(e)
         }
     }
-    
+
+    /**
+     * hotlist_flag=999 페이지에서 인기 게시물의 postId 목록을 수집
+     */
+    private suspend fun fetchHotPostIds(board: String): Set<String> {
+        return try {
+            val hotUrl = "${baseUrl}zboard.php?id=$board&hotlist_flag=999"
+            Log.d("Ppomppu", "인기글 페이지 조회: $hotUrl")
+
+            delay(Random.nextLong(1000, 2000))
+
+            val doc = Jsoup.connect(hotUrl)
+                .userAgent(getRandomUserAgent())
+                .header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
+                .header("Accept-Language", "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7")
+                .header("Referer", "https://www.ppomppu.co.kr/")
+                .timeout(15000)
+                .followRedirects(true)
+                .get()
+
+            val ids = mutableSetOf<String>()
+            doc.select("tr.baseList a.baseList-title").forEach { link ->
+                val href = link.attr("href")
+                val postId = extractPostId(href)
+                if (postId.isNotEmpty()) {
+                    ids.add(postId)
+                }
+            }
+            ids
+        } catch (e: Exception) {
+            Log.w("Ppomppu", "인기글 목록 조회 실패 (폴백으로 계속): ${e.message}")
+            emptySet()
+        }
+    }
+
     private fun extractPostId(href: String): String {
         val afterNo = href.substringAfter("no=", "")
         if (afterNo.isEmpty()) return ""

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

@@ -1,11 +1,6 @@
 package com.hotdeal.alarm.presentation.components
 
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.spring
 import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
-import androidx.compose.foundation.gestures.scrollBy
-import androidx.compose.foundation.lazy.LazyListItemInfo
 import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
@@ -13,126 +8,110 @@ import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.zIndex
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
 
 /**
- * Compose LazyColumn Drag & Drop Reordering State
+ * Key 기반 드래그 앤 드롭 Reorder 시스템
+ *
+ * - 각 아이템에 item-level long-press 제스처를 적용하여 드래그 시작
+ * - 드래그 중 다른 아이템의 중심점과 겹치면 swap 실행
+ * - swap 시 delta 보정으로 시각적 점프 방지
+ * - 비드래그 아이템은 animateItemPlacement()로 부드러운 슬라이드
  */
 @Composable
-fun rememberDragDropListState(
-    lazyListState: LazyListState,
-    onMove: (Int, Int) -> Unit,
-    onDragEnd: () -> Unit = {}
-): DragDropListState {
-    val scope = rememberCoroutineScope()
-    val state = remember(lazyListState) {
-        DragDropListState(
-            lazyListState = lazyListState,
-            onMove = onMove,
-            onDragEnd = onDragEnd,
-            scope = scope
-        )
+fun rememberReorderState(
+    listState: LazyListState,
+    onSwap: (fromListIndex: Int, toListIndex: Int) -> Boolean
+): ReorderState {
+    return remember(listState) {
+        ReorderState(listState, onSwap)
     }
-    return state
 }
 
-class DragDropListState(
-    val lazyListState: LazyListState,
-    private val onMove: (Int, Int) -> Unit,
-    private val onDragEnd: () -> Unit,
-    private val scope: CoroutineScope
+@Stable
+class ReorderState(
+    val listState: LazyListState,
+    private val onSwap: (Int, Int) -> Boolean
 ) {
-    var initiallyDraggedElement by mutableStateOf<LazyListItemInfo?>(null)
+    /** 현재 드래그 중인 아이템의 key (null이면 드래그 없음) */
+    var draggedKey by mutableStateOf<Any?>(null)
         private set
 
-    var currentIndexOfDraggedItem by mutableStateOf<Int?>(null)
+    /** 누적 드래그 Y축 오프셋 */
+    var dragDelta by mutableFloatStateOf(0f)
         private set
 
-    private val dragOffset = Animatable(0f)
+    fun startDrag(key: Any) {
+        draggedKey = key
+        dragDelta = 0f
+    }
 
-    val elementOffset: Float
-        get() = dragOffset.value
+    fun updateDrag(delta: Offset) {
+        if (draggedKey == null) return
+        dragDelta += delta.y
+        checkOverlap()
+    }
 
-    fun onDragStart(offset: Offset) {
-        lazyListState.layoutInfo.visibleItemsInfo
-            .firstOrNull { item -> offset.y.toInt() in item.offset..(item.offset + item.size) }
-            ?.also { item ->
-                currentIndexOfDraggedItem = item.index
-                initiallyDraggedElement = item
+    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()
             }
-    }
-
-    fun onDragInterrupted() {
-        initiallyDraggedElement = null
-        currentIndexOfDraggedItem = null
-        scope.launch {
-            dragOffset.snapTo(0f)
-        }
-    }
-
-    fun onDrag(change: Offset) {
-        scope.launch {
-            dragOffset.snapTo(dragOffset.value + change.y)
-
-            val currentElement = initiallyDraggedElement ?: return@launch
-            val startOffset = currentElement.offset + dragOffset.value
-            val endOffset = startOffset + currentElement.size
-
-            val hoveredItem = lazyListState.layoutInfo.visibleItemsInfo
-                .firstOrNull { item ->
-                    val itemMid = item.offset + item.size / 2
-                    val isMidInRange = itemMid in startOffset.toInt()..endOffset.toInt()
-                    isMidInRange && item.index != currentIndexOfDraggedItem
-                }
-
-            if (hoveredItem != null) {
-                val currentIndex = currentIndexOfDraggedItem ?: return@launch
-                val targetIndex = hoveredItem.index
-                onMove(currentIndex, targetIndex)
-                currentIndexOfDraggedItem = targetIndex
-            }
-        }
-    }
-
-    fun onDragStop() {
-        onDragEnd()
-        scope.launch {
-            dragOffset.animateTo(0f, spring(stiffness = Spring.StiffnessMediumLow))
-            initiallyDraggedElement = null
-            currentIndexOfDraggedItem = null
         }
     }
 }
 
-fun Modifier.dragDropGesture(
-    dragDropState: DragDropListState
-): Modifier = this.pointerInput(dragDropState) {
-    detectDragGesturesAfterLongPress(
-        onDragStart = { offset -> dragDropState.onDragStart(offset) },
-        onDragEnd = { dragDropState.onDragStop() },
-        onDragCancel = { dragDropState.onDragInterrupted() },
-        onDrag = { change, dragAmount ->
-            change.consume()
-            dragDropState.onDrag(dragAmount)
-        }
-    )
-}
-
-fun Modifier.dragDropItem(
-    index: Int,
-    dragDropState: DragDropListState
-): Modifier = this.then(
-    if (index == dragDropState.currentIndexOfDraggedItem) {
-        Modifier
-            .zIndex(10f)
-            .graphicsLayer {
-                translationY = dragDropState.elementOffset
+/**
+ * 개별 아이템에 부착하는 드래그 핸들 + 시각 효과 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 = 8f
+                shadowElevation = 16f
             }
-    } else {
-        Modifier
-    }
-)
+        }
+        .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

@@ -407,20 +407,17 @@ fun DealListScreen(
             }
 
             // Pull to Refresh 인디케이터
-            val progress = pullToRefreshState.progress
-            val showIndicator = pullToRefreshState.isRefreshing || progress > 0
+            val topPadding = paddingValues.calculateTopPadding()
 
-            if (showIndicator) {
-                PullToRefreshContainer(
-                    state = pullToRefreshState,
-                    modifier = Modifier
-                        .align(Alignment.TopCenter)
-                        .padding(top = 50.dp)
-                        .zIndex(999f),
-                    containerColor = MaterialTheme.colorScheme.surfaceVariant,
-                    contentColor = MaterialTheme.colorScheme.primary
-                )
-            }
+            PullToRefreshContainer(
+                state = pullToRefreshState,
+                modifier = Modifier
+                    .align(Alignment.TopCenter)
+                    .padding(top = topPadding)
+                    .zIndex(999f),
+                containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                contentColor = MaterialTheme.colorScheme.primary
+            )
 
             LaunchedEffect(pullToRefreshState.isRefreshing) {
                 if (pullToRefreshState.isRefreshing) {

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

@@ -44,11 +44,18 @@ class MainViewModel @Inject constructor(
     }
 
     private fun initializeApp() {
+        // 1. 사이트 설정 초기화 후 DB Flow 구독 (별도 코루틴 — collect는 영원히 suspend)
         viewModelScope.launch {
             initializeDefaultSiteConfigs()
-            loadState()
+            loadState()  // combine().collect — 이 코루틴은 영원히 살아있음
+        }
+
+        // 2. 백그라운드 폴링 등록 + 즉시 1회 스크래핑 (별도 코루틴)
+        viewModelScope.launch {
             val savedInterval = appSettings.pollingInterval.first()
-            startPolling(savedInterval.toLong())
+            workerScheduler.schedulePeriodicPolling(savedInterval.toLong())
+            // 앱 시작 시 즉시 1회 실행하여 최신 데이터 갱신
+            workerScheduler.executeOnce()
         }
     }
 
@@ -109,11 +116,13 @@ class MainViewModel @Inject constructor(
     }
 
     fun reorderSites(fromIndex: Int, toIndex: Int) {
-        viewModelScope.launch {
-            val current = siteOrder.value.toMutableList()
-            if (fromIndex in current.indices && toIndex in current.indices) {
-                val item = current.removeAt(fromIndex)
-                current.add(toIndex, item)
+        // 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)
             }
         }
@@ -128,7 +137,6 @@ class MainViewModel @Inject constructor(
                     isEnabled = true
                 )
             )
-            // 키워드 순서 맨 앞에 추가
             val currentOrder = appSettings.keywordOrder.first().toMutableList()
             currentOrder.add(0, newId)
             appSettings.setKeywordOrder(currentOrder)
@@ -151,12 +159,16 @@ class MainViewModel @Inject constructor(
     }
 
     fun reorderKeywords(fromIndex: Int, toIndex: Int) {
-        val state = uiState.value as? MainUiState.Success ?: return
-        viewModelScope.launch {
-            val current = state.keywords.toMutableList()
-            if (fromIndex in current.indices && toIndex in current.indices) {
-                val item = current.removeAt(fromIndex)
-                current.add(toIndex, item)
+        // uiState를 동기적으로 즉시 업데이트하여 빠른 드래그 시 stale 데이터 방지
+        val state = _uiState.value as? MainUiState.Success ?: return
+        val current = state.keywords.toMutableList()
+        if (fromIndex in current.indices && toIndex in current.indices) {
+            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 })
             }
         }

app/src/main/java/com/hotdeal/alarm/receiver/BootReceiver.kt

@@ -0,0 +1,48 @@
+package com.hotdeal.alarm.receiver
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import com.hotdeal.alarm.data.local.preferences.AppSettings
+import com.hotdeal.alarm.worker.WorkerScheduler
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * 부팅 완료 시 백그라운드 폴링을 자동으로 재등록하는 리시버
+ */
+@AndroidEntryPoint
+class BootReceiver : BroadcastReceiver() {
+
+    @Inject
+    lateinit var workerScheduler: WorkerScheduler
+
+    @Inject
+    lateinit var appSettings: AppSettings
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action == Intent.ACTION_BOOT_COMPLETED ||
+            intent.action == Intent.ACTION_MY_PACKAGE_REPLACED
+        ) {
+            Log.d("BootReceiver", "부팅/업데이트 감지 → 백그라운드 폴링 재등록")
+            scope.launch {
+                try {
+                    val interval = appSettings.pollingInterval.first()
+                    workerScheduler.schedulePeriodicPolling(interval.toLong())
+                    Log.d("BootReceiver", "폴링 재등록 완료: ${interval}분 간격")
+                } catch (e: Exception) {
+                    Log.e("BootReceiver", "폴링 재등록 실패: ${e.message}")
+                    workerScheduler.schedulePeriodicPolling(WorkerScheduler.DEFAULT_INTERVAL_MINUTES)
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/hotdeal/alarm/worker/HotDealPollingWorker.kt

@@ -116,11 +116,18 @@ class HotDealPollingWorker @AssistedInject constructor(
             // 8. 알림 발송 상태 업데이트
             dealDao.markAsNotified(newDeals.map { it.id })
 
- // 9. 오래된 데이터 정리 (3일 이상 - 배터리/데이터 절약)
+            // 9. 인기글 상태 업데이트 (신규+기존 딜 모두 HOT 마킹)
+            val popularDealIds = allDeals.filter { it.isPopular }.map { it.id }
+            if (popularDealIds.isNotEmpty()) {
+                dealDao.markAsPopular(popularDealIds)
+                Log.d(TAG, "인기글 마킹: ${popularDealIds.size}개")
+            }
+
+ // 10. 오래된 데이터 정리 (3일 이상 - 배터리/데이터 절약)
  val threshold = System.currentTimeMillis() - (3 * 24 * 60 * 60 * 1000L)
  dealDao.deleteOldDeals(threshold)
 
-            Log.d(TAG, "===== 핫딜 폴� 완료 =====")
+            Log.d(TAG, "===== 핫딜 폴 완료 =====")
             Result.success()
         } catch (e: Exception) {
             Log.e(TAG, "폴� 오류: ${e.message}", e)

app/src/main/java/com/hotdeal/alarm/worker/WorkerScheduler.kt

@@ -54,7 +54,7 @@ class WorkerScheduler @Inject constructor(
         
         WorkManager.getInstance(context).enqueueUniquePeriodicWork(
             HotDealPollingWorker.WORK_NAME,
-            ExistingPeriodicWorkPolicy.KEEP,
+            ExistingPeriodicWorkPolicy.UPDATE,
             workRequest
         )
     }

version.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.2.9",
-  "versionCode": 29,
-  "updateUrl": "https://git.webpluss.net/sanjeok77/hotdeal_alarm/releases/download/v0.2.9/app-release.apk",
+  "version": "0.3.3",
+  "versionCode": 33,
+  "updateUrl": "https://git.webpluss.net/sanjeok77/hotdeal_alarm/releases/download/v0.3.3/app-release.apk",
   "changelog": [
     "사이트 및 키워드 순서 조절을 터치 드래그 앤 드롭(Drag & Drop) 방식으로 전면 업그레이드",
     "앱 내 업데이트 시 다운로드 완료 후 설치 화면으로 안 넘어가는 버그 수정",