v0.3.6: update PollingAlarmReceiver.kt

app/build.gradle.kts

@@ -24,8 +24,8 @@ android {
  applicationId = "com.hotdeal.alarm"
  minSdk = 31
  targetSdk = 35
-        versionCode = 31
+        versionCode = 36
-        versionName = "0.3.1"
+        versionName = "0.3.6"
 
  testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  vectorDrawables {

app/proguard-rules.pro

@@ -1,8 +1,40 @@
 # Add project specific ProGuard rules here.
 -keepattributes Signature
 -keepattributes *Annotation*
+
+# Data Entities & Models
 -keep class com.hotdeal.alarm.data.local.db.entity.** { *; }
 -keep class com.hotdeal.alarm.domain.model.** { *; }
+-keep class com.hotdeal.alarm.data.local.preferences.** { *; }
+
+# Room Database & DAOs
+-keep class * extends androidx.room.RoomDatabase
+-keep class com.hotdeal.alarm.data.local.db.dao.** { *; }
+-dontwarn androidx.room.paging.**
+
+# WorkManager & Hilt Worker
+-keep class androidx.work.** { *; }
+-keep class androidx.hilt.work.** { *; }
+-keep class com.hotdeal.alarm.worker.** { *; }
+-keep class * extends androidx.work.ListenableWorker {
+    public <init>(android.content.Context, androidx.work.WorkerParameters);
+}
+-keep class * extends androidx.work.Worker {
+    public <init>(android.content.Context, androidx.work.WorkerParameters);
+}
+-keep class * extends androidx.work.CoroutineWorker {
+    public <init>(android.content.Context, androidx.work.WorkerParameters);
+}
+
+# Dagger & Hilt
+-keep class com.hotdeal.alarm.di.** { *; }
+-keep class * extends android.app.Application
+-keep class * extends android.app.Service
+-keep class * extends android.content.BroadcastReceiver
+-keep class com.hotdeal.alarm.receiver.** { *; }
+
+# Scrapers & Remote Data
+-keep class com.hotdeal.alarm.data.remote.scraper.** { *; }
 
 # OkHttp
 -dontwarn okhttp3.**
@@ -19,4 +51,3 @@
 
 # JSpecify annotations (for Jsoup compatibility)
 -dontwarn org.jspecify.annotations.**
-

app/src/main/AndroidManifest.xml

@@ -14,8 +14,9 @@
     <!-- Notifications (Android 13+) -->
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
-    <!-- Exact Alarms (Android 12+) -->
+    <!-- Exact Alarms (Android 12+, Android 13+) -->
     <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+    <uses-permission android:name="android.permission.USE_EXACT_ALARM" />
 
     <!-- Boot Completed -->
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
@@ -36,17 +37,17 @@
         android:usesCleartextTraffic="true"
         tools:targetApi="35">
 
- <!-- Disable default WorkManager initializer to use HiltWorkerFactory -->
+        <!-- Disable default WorkManager initializer to use HiltWorkerFactory -->
- <provider
+        <provider
- android:name="androidx.startup.InitializationProvider"
+            android:name="androidx.startup.InitializationProvider"
- android:authorities="${applicationId}.androidx-startup"
+            android:authorities="${applicationId}.androidx-startup"
- android:exported="false"
+            android:exported="false"
- tools:node="merge">
+            tools:node="merge">
- <meta-data
+            <meta-data
- android:name="androidx.work.WorkManagerInitializer"
+                android:name="androidx.work.WorkManagerInitializer"
- android:value="androidx.startup"
+                android:value="androidx.startup"
- tools:node="remove" />
+                tools:node="remove" />
- </provider>
+        </provider>
 
         <activity
             android:name=".presentation.main.MainActivity"
@@ -65,30 +66,50 @@
             android:exported="false"
             android:foregroundServiceType="dataSync" />
 
-    <!-- Boot Receiver -->
+        <!-- Polling Alarm Receiver: 정확한 주기 알람 수신 및 핫딜 스크래핑 트리거 -->
+        <receiver
+            android:name=".receiver.PollingAlarmReceiver"
+            android:enabled="true"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.hotdeal.alarm.ACTION_POLL_ALARM" />
+            </intent-filter>
+        </receiver>
 
-    <!-- Widget -->
+        <!-- Boot Receiver: 부팅/앱 업데이트 후 백그라운드 폴링 자동 재등록 -->
-    <receiver
+        <receiver
-        android:name=".widget.HotDealWidget"
+            android:name=".receiver.BootReceiver"
-        android:exported="true">
+            android:enabled="true"
-        <intent-filter>
+            android:exported="true">
-            <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            <intent-filter>
-        </intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
-        <meta-data
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
-            android:name="android.appwidget.provider"
+            </intent-filter>
-            android:resource="@xml/widget_info" />
+        </receiver>
-    </receiver>
 
-    <!-- FileProvider for APK installation -->
+        <!-- Widget Receiver -->
-    <provider
+        <receiver
-        android:name="androidx.core.content.FileProvider"
+            android:name=".widget.HotDealWidget"
-        android:authorities="${applicationId}.fileprovider"
+            android:exported="true">
-        android:exported="false"
+            <intent-filter>
-        android:grantUriPermissions="true">
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-        <meta-data
+            </intent-filter>
-            android:name="android.support.FILE_PROVIDER_PATHS"
+            <meta-data
-            android:resource="@xml/file_paths" />
+                android:name="android.appwidget.provider"
-    </provider>
+                android:resource="@xml/widget_info" />
-</application>
+        </receiver>
+
+        <!-- FileProvider for APK installation -->
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            tools:replace="android:authorities"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+    </application>
 
 </manifest>

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/remote/scraper/PpomppuScraper.kt

@@ -3,6 +3,7 @@ package com.hotdeal.alarm.data.remote.scraper
 import android.util.Log
 import com.hotdeal.alarm.domain.model.HotDeal
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
 import okhttp3.OkHttpClient
@@ -13,7 +14,7 @@ import kotlin.random.Random
 
 /**
  * 뽐뿌 스크래퍼
- * - hotlist_flag=999 페이지에서 인기글 ID를 수집하여 HOT 뱃지 표시
+ * - hotlist_flag=999 페이지와 일반 게시판을 병렬 스크래핑하여 HOT 뱃지 신속 감지
  * - 기존 hotpop_bg_color CSS 클래스도 폴백으로 감지
  */
 class PpomppuScraper(client: OkHttpClient) : BaseScraper(client) {
@@ -27,15 +28,13 @@ 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")
 
-            val delayTime = Random.nextLong(2000, 4000)
+            // 1. 인기글 목록과 일반 게시판을 병렬(async)로 동시에 요청하여 딜레이 최소화
+            val hotPostIdsDeferred = async { fetchHotPostIds(board) }
+            
+            val delayTime = Random.nextLong(500, 1500)
             delay(delayTime)
             
             val userAgent = getRandomUserAgent()
@@ -45,17 +44,20 @@ class PpomppuScraper(client: OkHttpClient) : BaseScraper(client) {
                 .header("Accept-Language", "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7")
                 .header("Accept-Charset", "utf-8,ISO-8859-1")
                 .header("Referer", "https://www.ppomppu.co.kr/")
-                .timeout(30000)
+                .timeout(12000)
                 .followRedirects(true)
                 .get()
 
+            val hotPostIds = hotPostIdsDeferred.await()
+            Log.d("Ppomppu", "인기글 ID ${hotPostIds.size}개 수집됨: $hotPostIds")
+            
             val deals = mutableListOf<HotDeal>()
             val rowElements: Elements = doc.select("tr.baseList")
             Log.d("Ppomppu", "찾은 행 요소: ${rowElements.size}개")
 
             var count = 0
             rowElements.forEach { row ->
-                if (count >= 20) return@forEach
+                if (count >= 25) return@forEach
 
                 try {
                     val titleElement = row.selectFirst("a.baseList-title") ?: return@forEach
@@ -108,14 +110,12 @@ class PpomppuScraper(client: OkHttpClient) : BaseScraper(client) {
             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)
+                .timeout(8000)
                 .followRedirects(true)
                 .get()
 

app/src/main/java/com/hotdeal/alarm/domain/usecase/HotDealScraperManager.kt

@@ -0,0 +1,175 @@
+package com.hotdeal.alarm.domain.usecase
+
+import android.content.Context
+import android.util.Log
+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.HotDealEntity
+import com.hotdeal.alarm.data.local.db.entity.KeywordEntity
+import com.hotdeal.alarm.data.local.db.entity.SiteConfigEntity
+import com.hotdeal.alarm.data.remote.scraper.ScraperFactory
+import com.hotdeal.alarm.domain.model.HotDeal
+import com.hotdeal.alarm.service.NotificationService
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * 핫딜 스크래핑, DB 저장, 키워드 매칭, 알림 발송을 총괄하는 핵심 매니저
+ * 
+ * 포그라운드(앱 진입/새로고침), 백그라운드(AlarmReceiver), WorkManager 모두에서
+ * 공통으로 직접 호출하여 지연 없이 즉시 수집 및 알림을 발송합니다.
+ */
+@Singleton
+class HotDealScraperManager @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val scraperFactory: ScraperFactory,
+    private val notificationService: NotificationService,
+    private val dealDao: HotDealDao,
+    private val siteConfigDao: SiteConfigDao,
+    private val keywordDao: KeywordDao
+) {
+    companion object {
+        private const val TAG = "HotDealScraperManager"
+    }
+
+    // 중복 동시 실행 방지 뮤텍스
+    private val mutex = Mutex()
+
+    /**
+     * 핫딜 수집 및 키워드 알림 발송 전체 프로세스 실행
+     * @return 수집된 새로운 핫딜 목록
+     */
+    suspend fun fetchAndProcessDeals(): List<HotDeal> = withContext(Dispatchers.IO) {
+        mutex.withLock {
+            try {
+                Log.d(TAG, "===== 🚀 핫딜 수집 프로세스 시작 =====")
+
+                // 1. 활성화된 사이트 설정 조회
+                val enabledConfigs = siteConfigDao.getEnabledConfigs()
+                Log.d(TAG, "활성화된 사이트 설정: ${enabledConfigs.size}개")
+
+                if (enabledConfigs.isEmpty()) {
+                    Log.w(TAG, "활성화된 사이트 설정이 없습니다.")
+                    return@withContext emptyList()
+                }
+
+                // 2. 활성화된 키워드 조회
+                val keywords = keywordDao.getEnabledKeywords()
+                Log.d(TAG, "활성화된 키워드: ${keywords.size}개 (${keywords.map { it.keyword }})")
+
+                // 3. 각 사이트/게시판 병렬 스크래핑
+                val allDeals = enabledConfigs.map { config ->
+                    async { scrapeSite(config) }
+                }.awaitAll().flatten()
+
+                Log.d(TAG, "스크래핑 완료: 총 ${allDeals.size}개 핫딜 수집됨")
+                if (allDeals.isEmpty()) {
+                    return@withContext emptyList()
+                }
+
+                // 4. 새로운 핫딜 필터링 (기존 DB에 없는 것)
+                val newDeals = filterNewDeals(allDeals)
+                Log.d(TAG, "새로운 핫딜: ${newDeals.size}개")
+
+                // 5. 인기글 상태 일괄 업데이트 (기존 + 신규 모두)
+                val popularDealIds = allDeals.filter { it.isPopular }.map { it.id }
+                if (popularDealIds.isNotEmpty()) {
+                    dealDao.markAsPopular(popularDealIds)
+                    Log.d(TAG, "🔥 인기글 마킹: ${popularDealIds.size}개")
+                }
+
+                if (newDeals.isNotEmpty()) {
+                    // 6. 키워드 매칭
+                    val keywordMatchedDeals = if (keywords.isNotEmpty()) {
+                        filterByKeywords(newDeals, keywords).also {
+                            Log.d(TAG, "⭐ 키워드 매칭 핫딜: ${it.size}개 -> ${it.map { d -> d.title }}")
+                        }
+                    } else {
+                        emptyList()
+                    }
+
+                    // 7. DB에 새 핫딜 저장
+                    var insertedCount = 0
+                    newDeals.forEach { deal ->
+                        try {
+                            val entity = HotDealEntity.fromDomain(deal)
+                            dealDao.insertDeal(entity)
+                            insertedCount++
+                        } catch (e: Exception) {
+                            Log.w(TAG, "핫딜 저장 실패: ${deal.id}")
+                        }
+                    }
+                    Log.d(TAG, "DB 저장 완료: $insertedCount 개")
+
+                    // 8. 키워드 매칭 알림 즉시 발송! (시스템바 노티피케이션)
+                    if (keywordMatchedDeals.isNotEmpty()) {
+                        Log.d(TAG, "🔔 키워드 매칭 알림 발송: ${keywordMatchedDeals.size}개")
+                        notificationService.showKeywordMatchNotification(keywordMatchedDeals)
+                        dealDao.markAsKeywordMatch(keywordMatchedDeals.map { it.id })
+                    }
+
+                    // 9. 알림 발송 상태 업데이트
+                    dealDao.markAsNotified(newDeals.map { it.id })
+                }
+
+                // 10. 오래된 데이터 정리 (3일 이상)
+                val threshold = System.currentTimeMillis() - (3 * 24 * 60 * 60 * 1000L)
+                dealDao.deleteOldDeals(threshold)
+
+                Log.d(TAG, "===== ✅ 핫딜 수집 프로세스 종료 =====")
+                newDeals
+            } catch (e: Exception) {
+                Log.e(TAG, "핫딜 수집 오류: ${e.message}", e)
+                emptyList()
+            }
+        }
+    }
+
+    private suspend fun scrapeSite(config: SiteConfigEntity): List<HotDeal> {
+        val scraper = scraperFactory.getScraper(config.siteName) ?: return emptyList()
+        val result = scraper.scrape(config.boardName)
+
+        result.fold(
+            onSuccess = { deals ->
+                try {
+                    siteConfigDao.updateLastScrapedAt(config.siteBoardKey, System.currentTimeMillis())
+                } catch (e: Exception) {
+                    // 무시
+                }
+            },
+            onFailure = { error ->
+                Log.e(TAG, "${config.siteName}/${config.boardName} 실패: ${error.message}")
+            }
+        )
+
+        return result.getOrElse { emptyList() }
+    }
+
+    private suspend fun filterNewDeals(deals: List<HotDeal>): List<HotDeal> {
+        return deals.filter { deal ->
+            val existingByUrl = dealDao.getDealByUrl(deal.url)
+            if (existingByUrl != null) return@filter false
+
+            val existingById = dealDao.getDealById(deal.id)
+            if (existingById != null) return@filter false
+
+            true
+        }
+    }
+
+    private fun filterByKeywords(deals: List<HotDeal>, keywords: List<KeywordEntity>): List<HotDeal> {
+        return deals.filter { deal ->
+            keywords.any { keyword ->
+                deal.title.contains(keyword.keyword, ignoreCase = true)
+            }
+        }
+    }
+}

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

@@ -3,6 +3,7 @@ package com.hotdeal.alarm.presentation.deallist
 import android.content.Intent
 import android.net.Uri
 import androidx.compose.animation.*
+import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.background
 import androidx.compose.foundation.horizontalScroll
 import androidx.compose.foundation.layout.*
@@ -44,9 +45,9 @@ import kotlinx.coroutines.launch
 
 /**
  * One UI 9 & Material 3 Expressive Compact Deal Feed Screen
- * 온디맨드 검색(In-AppBar Search)과 스크롤 반응형 상단바로 화면 시야 및 컨텐츠 노출 수를 극대화한 화면
+ * 온디맨드 검색(In-AppBar Search)과 실시간 신규 핫딜 자동 상단 동기화 화면
  */
-@OptIn(ExperimentalMaterial3Api::class)
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
 @Composable
 fun DealListScreen(
     viewModel: MainViewModel,
@@ -62,7 +63,7 @@ fun DealListScreen(
 
     // Pull to Refresh
     val pullToRefreshState = rememberPullToRefreshState(positionalThreshold = 40.dp)
-    var isRefreshing by remember { mutableStateOf(false) }
+    val isRefreshingByVm by viewModel.isRefreshing.collectAsStateWithLifecycle()
 
     val listState = rememberLazyListState()
     val scope = rememberCoroutineScope()
@@ -70,9 +71,19 @@ fun DealListScreen(
         derivedStateOf { listState.firstVisibleItemIndex > 3 }
     }
 
-    LaunchedEffect(uiState) {
+    // 신규 수집 핫딜 자동 상단 노출 상태
-        if (uiState !is MainUiState.Loading) {
+    var previousTopDealId by remember { mutableStateOf<String?>(null) }
-            isRefreshing = false
+    var hasNewUnseenDeals by remember { mutableStateOf(false) }
+
+    // 사용자가 최상단으로 올라오면 새 핫딜 배너 숨김
+    LaunchedEffect(listState.firstVisibleItemIndex) {
+        if (listState.firstVisibleItemIndex == 0) {
+            hasNewUnseenDeals = false
+        }
+    }
+
+    LaunchedEffect(isRefreshingByVm) {
+        if (!isRefreshingByVm) {
             pullToRefreshState.endRefresh()
         }
     }
@@ -99,7 +110,6 @@ fun DealListScreen(
             TopAppBar(
                 title = {
                     if (isSearchActive) {
-                        // 검색 모드일 때의 인라인 검색 텍스트 필드
                         TextField(
                             value = searchText,
                             onValueChange = { searchText = it },
@@ -125,7 +135,6 @@ fun DealListScreen(
                                 .focusRequester(searchFocusRequester)
                         )
                     } else {
-                        // 기본 상단 타이틀
                         Row(
                             verticalAlignment = Alignment.CenterVertically,
                             horizontalArrangement = Arrangement.spacedBy(8.dp)
@@ -180,7 +189,6 @@ fun DealListScreen(
                             }
                         }
                     } else {
-                        // 1. 검색 버튼 (누르면 검색 모드로 전환)
                         IconButton(onClick = { isSearchActive = true }) {
                             Icon(
                                 imageVector = Icons.Outlined.Search,
@@ -189,7 +197,6 @@ fun DealListScreen(
                             )
                         }
 
-                        // 2. 새로고침 버튼
                         IconButton(onClick = { viewModel.refresh() }) {
                             Icon(
                                 imageVector = Icons.Outlined.Refresh,
@@ -349,6 +356,25 @@ fun DealListScreen(
                             }
                         }
 
+                        // 신규 파싱 핫딜 실시간 최상단 자동 노출 감지
+                        LaunchedEffect(filteredDeals.firstOrNull()?.id) {
+                            val currentTop = filteredDeals.firstOrNull()
+                            if (currentTop != null) {
+                                if (previousTopDealId != null && previousTopDealId != currentTop.id) {
+                                    // 신규 핫딜 감지
+                                    if (listState.firstVisibleItemIndex <= 1) {
+                                        // 사용자가 상단에 머물고 있으면 즉시 최상단(0)으로 부드럽게 스크롤하여 새 핫딜 바로 노출!
+                                        listState.animateScrollToItem(0)
+                                        hasNewUnseenDeals = false
+                                    } else {
+                                        // 사용자가 아래 글을 읽고 있는 경우 배너 표시
+                                        hasNewUnseenDeals = true
+                                    }
+                                }
+                                previousTopDealId = currentTop.id
+                            }
+                        }
+
                         if (filteredDeals.isEmpty()) {
                             if (state.deals.isEmpty()) {
                                 NoDealsState(onRefresh = { viewModel.refresh() })
@@ -368,30 +394,77 @@ fun DealListScreen(
                                 )
                             }
                         } else {
-                            LazyColumn(
+                            Box(modifier = Modifier.fillMaxSize()) {
-                                modifier = Modifier.fillMaxSize(),
+                                LazyColumn(
-                                state = listState,
+                                    modifier = Modifier.fillMaxSize(),
-                                contentPadding = PaddingValues(horizontal = 14.dp, vertical = 4.dp),
+                                    state = listState,
-                                verticalArrangement = Arrangement.spacedBy(7.dp)
+                                    contentPadding = PaddingValues(horizontal = 14.dp, vertical = 4.dp),
-                            ) {
+                                    verticalArrangement = Arrangement.spacedBy(7.dp)
-                                items(
+                                ) {
-                                    items = filteredDeals,
+                                    items(
-                                    key = { it.id }
+                                        items = filteredDeals,
-                                ) { deal ->
+                                        key = { it.id }
-                                    DealItem(
+                                    ) { deal ->
-                                        deal = deal,
+                                        DealItem(
-                                        onClick = {
+                                            deal = deal,
-                                            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(deal.url))
+                                            modifier = Modifier.animateItemPlacement(),
-                                            context.startActivity(intent)
+                                            onClick = {
-                                        },
+                                                val intent = Intent(Intent.ACTION_VIEW, Uri.parse(deal.url))
-                                        onFavoriteToggle = { dealId ->
+                                                context.startActivity(intent)
-                                            viewModel.toggleFavorite(dealId)
+                                            },
-                                        }
+                                            onFavoriteToggle = { dealId ->
-                                    )
+                                                viewModel.toggleFavorite(dealId)
+                                            }
+                                        )
+                                    }
+
+                                    item {
+                                        Spacer(modifier = Modifier.height(16.dp))
+                                    }
                                 }
 
-                                item {
+                                // 새 핫딜 도착 시 상단 플로팅 칩 알림 (아래 스크롤 중일 때)
-                                    Spacer(modifier = Modifier.height(16.dp))
+                                androidx.compose.animation.AnimatedVisibility(
+                                    visible = hasNewUnseenDeals,
+                                    enter = fadeIn() + expandVertically(),
+                                    exit = fadeOut() + shrinkVertically(),
+                                    modifier = Modifier
+                                        .align(Alignment.TopCenter)
+                                        .padding(top = 8.dp)
+                                        .zIndex(10f)
+                                ) {
+                                    Surface(
+                                        shape = CornerRadius.shapePill,
+                                        color = MaterialTheme.colorScheme.primary,
+                                        shadowElevation = 6.dp,
+                                        modifier = Modifier.elasticPressClickable {
+                                            scope.launch {
+                                                listState.animateScrollToItem(0)
+                                                hasNewUnseenDeals = false
+                                            }
+                                        }
+                                    ) {
+                                        Row(
+                                            verticalAlignment = Alignment.CenterVertically,
+                                            horizontalArrangement = Arrangement.spacedBy(6.dp),
+                                            modifier = Modifier.padding(horizontal = 14.dp, vertical = 6.dp)
+                                        ) {
+                                            Icon(
+                                                imageVector = Icons.Filled.ArrowUpward,
+                                                contentDescription = null,
+                                                tint = MaterialTheme.colorScheme.onPrimary,
+                                                modifier = Modifier.size(13.dp)
+                                            )
+                                            Text(
+                                                text = "새로운 핫딜 도착 (터치하여 보기)",
+                                                style = MaterialTheme.typography.labelSmall.copy(
+                                                    fontWeight = FontWeight.Bold,
+                                                    fontSize = 11.5.sp
+                                                ),
+                                                color = MaterialTheme.colorScheme.onPrimary
+                                            )
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -421,7 +494,6 @@ fun DealListScreen(
 
             LaunchedEffect(pullToRefreshState.isRefreshing) {
                 if (pullToRefreshState.isRefreshing) {
-                    isRefreshing = true
                     viewModel.refresh()
                 }
             }

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

@@ -40,6 +40,9 @@ class MainActivity : ComponentActivity() {
     @Inject
     lateinit var workerScheduler: WorkerScheduler
 
+    @Inject
+    lateinit var scraperManager: com.hotdeal.alarm.domain.usecase.HotDealScraperManager
+
     private var downloadReceiver: BroadcastReceiver? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -216,7 +219,13 @@ class MainActivity : ComponentActivity() {
     override fun onResume() {
         super.onResume()
         if (isInBackground) {
-            workerScheduler.executeOnce()
+            lifecycleScope.launch {
+                try {
+                    scraperManager.fetchAndProcessDeals()
+                } catch (e: Exception) {
+                    // 무시
+                }
+            }
         }
         isInBackground = false
     }

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

@@ -10,6 +10,7 @@ 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.domain.usecase.HotDealScraperManager
 import com.hotdeal.alarm.worker.WorkerScheduler
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.*
@@ -21,6 +22,7 @@ class MainViewModel @Inject constructor(
     private val hotDealDao: HotDealDao,
     private val siteConfigDao: SiteConfigDao,
     private val keywordDao: KeywordDao,
+    private val scraperManager: HotDealScraperManager,
     private val workerScheduler: WorkerScheduler,
     private val appSettings: AppSettings
 ) : ViewModel() {
@@ -28,6 +30,10 @@ class MainViewModel @Inject constructor(
     private val _uiState = MutableStateFlow<MainUiState>(MainUiState.Loading)
     val uiState: StateFlow<MainUiState> = _uiState.asStateFlow()
 
+    // 새로고침 진행 상태
+    private val _isRefreshing = MutableStateFlow(false)
+    val isRefreshing: StateFlow<Boolean> = _isRefreshing.asStateFlow()
+
     // 폴링 주기
     val pollingInterval: StateFlow<Int> = appSettings.pollingInterval
         .stateIn(viewModelScope, SharingStarted.Eagerly, 2)
@@ -44,11 +50,19 @@ class MainViewModel @Inject constructor(
     }
 
     private fun initializeApp() {
+        // 1. 사이트 설정 초기화 후 DB Flow 구독 (별도 코루틴 — collect는 지속 실행)
         viewModelScope.launch {
             initializeDefaultSiteConfigs()
             loadState()
+        }
+
+        // 2. 백그라운드 폴링 등록 + 앱 진입 즉시 직접 1회 스크래핑 실행
+        viewModelScope.launch {
             val savedInterval = appSettings.pollingInterval.first()
-            startPolling(savedInterval.toLong())
+            workerScheduler.schedulePeriodicPolling(savedInterval.toLong())
+            
+            // 지연 없는 직접 스크래핑 실행 -> Room Flow를 통해 메인화면에 즉시 반영됨!
+            refresh()
         }
     }
 
@@ -63,7 +77,7 @@ class MainViewModel @Inject constructor(
                     siteName = site.name,
                     boardName = board.id,
                     displayName = "${site.displayName} - ${board.displayName}",
-                    isEnabled = false
+                    isEnabled = true // 기본 활성화 (설치 즉시 수집 가동)
                 )
             }
         }
@@ -81,7 +95,6 @@ class MainViewModel @Inject constructor(
             keywordDao.observeAllKeywords(),
             appSettings.keywordOrder
         ) { deals, configs, keywords, keywordOrder ->
-            // 사용자가 설정한 키워드 순서에 따라 정렬
             val domainKeywords = keywords.map { it.toDomain() }
             val sortedKeywords = if (keywordOrder.isEmpty()) {
                 domainKeywords
@@ -105,12 +118,14 @@ class MainViewModel @Inject constructor(
     fun toggleSiteConfig(siteBoardKey: String, enabled: Boolean) {
         viewModelScope.launch {
             siteConfigDao.updateEnabled(siteBoardKey, enabled)
+            // 사이트 활성화 변경 시 즉시 새 핫딜 갱신
+            if (enabled) {
+                refresh()
+            }
         }
     }
 
     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)
@@ -133,6 +148,8 @@ class MainViewModel @Inject constructor(
             val currentOrder = appSettings.keywordOrder.first().toMutableList()
             currentOrder.add(0, newId)
             appSettings.setKeywordOrder(currentOrder)
+            // 키워드 등록 후 매칭 검사를 위해 즉시 갱신
+            refresh()
         }
     }
 
@@ -148,19 +165,19 @@ class MainViewModel @Inject constructor(
     fun toggleKeyword(id: Long, enabled: Boolean) {
         viewModelScope.launch {
             keywordDao.updateEnabled(id, enabled)
+            if (enabled) {
+                refresh()
+            }
         }
     }
 
     fun reorderKeywords(fromIndex: Int, toIndex: Int) {
-        // 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 })
             }
@@ -179,8 +196,20 @@ class MainViewModel @Inject constructor(
         }
     }
 
+    /**
+     * 직접 즉시 스크래핑 실행 (WorkManager 큐 대기 지연 없이 UI 및 DB 즉시 갱신)
+     */
     fun refresh() {
-        workerScheduler.executeOnce()
+        viewModelScope.launch {
+            _isRefreshing.value = true
+            try {
+                scraperManager.fetchAndProcessDeals()
+            } catch (e: Exception) {
+                // 에러 발생 시 무시 (UI는 DB Flow로 유지)
+            } finally {
+                _isRefreshing.value = false
+            }
+        }
     }
 
     fun startPolling(intervalMinutes: Long = WorkerScheduler.DEFAULT_INTERVAL_MINUTES) {

app/src/main/java/com/hotdeal/alarm/presentation/settings/SettingsScreen.kt

@@ -140,8 +140,17 @@ fun SettingsScreen(viewModel: MainViewModel) {
                     permissionStatus = permissionStatus,
                     currentPollingInterval = currentPollingInterval,
                     onRequestPermission = {
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        if (!permissionStatus.hasNotificationPermission) {
-                            notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+                            } else {
+                                PermissionHelper.openNotificationSettings(context)
+                            }
+                        } else if (!permissionStatus.hasExactAlarmPermission) {
+                            permissionDialogTitle = "알람 및 리마인더 권한 필요"
+                            permissionDialogMessage = "화면이 꺼져있을 때도 실시간 핫딜 알림을 받으려면 '알람 및 리마인더' 권한 허용이 필요합니다."
+                            permissionDialogAction = { PermissionHelper.openExactAlarmSettings(context) }
+                            showPermissionDialog = true
                         }
                     }
                 )
@@ -216,13 +225,19 @@ private fun NotificationTab(
                         Text("실시간 모니터링 요약", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.Bold)
                     }
                     Spacer(modifier = Modifier.height(10.dp))
+                    val isPermissionOk = permissionStatus.hasNotificationPermission && permissionStatus.hasExactAlarmPermission
+                    val permText = when {
+                        !permissionStatus.hasNotificationPermission -> "알림권한 필요"
+                        !permissionStatus.hasExactAlarmPermission -> "알람권한 필요"
+                        else -> "실시간 가동"
+                    }
                     Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                         BentoMiniTile(
                             title = "알림 상태",
-                            value = if (permissionStatus.hasNotificationPermission) "정상 가동" else "권한 필요",
+                            value = permText,
-                            isHighlight = !permissionStatus.hasNotificationPermission,
+                            isHighlight = !isPermissionOk,
                             modifier = Modifier.weight(1f),
-                            onClick = if (!permissionStatus.hasNotificationPermission) onRequestPermission else null
+                            onClick = if (!isPermissionOk) onRequestPermission else null
                         )
                         BentoMiniTile(title = "감시 주기", value = "${currentPollingInterval}분 간격", modifier = Modifier.weight(1f))
                     }

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/receiver/PollingAlarmReceiver.kt

@@ -0,0 +1,71 @@
+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.domain.usecase.HotDealScraperManager
+import com.hotdeal.alarm.worker.AlarmScheduler
+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
+
+/**
+ * 주기적 알람 수신 시 백그라운드 스크래핑을 즉시 실행하고 다음 알람을 예약하는 리시버
+ * 
+ * goAsync()를 사용하여 WorkManager의 Doze 지연 없이 백그라운드에서 즉시 핫딜을 수집하고 알림을 발송합니다.
+ */
+@AndroidEntryPoint
+class PollingAlarmReceiver : BroadcastReceiver() {
+
+    companion object {
+        private const val TAG = "PollingAlarmReceiver"
+    }
+
+    @Inject
+    lateinit var scraperManager: HotDealScraperManager
+
+    @Inject
+    lateinit var alarmScheduler: AlarmScheduler
+
+    @Inject
+    lateinit var appSettings: AppSettings
+
+    private val receiverScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action == AlarmScheduler.ACTION_POLL_ALARM) {
+            Log.d(TAG, "⏰ [실시간 알람 수신] 백그라운드 스크래핑 즉시 시작 및 다음 알람 예약")
+
+            val pendingResult = goAsync()
+
+            receiverScope.launch {
+                try {
+                    // 1. 백그라운드에서 직접 스크래핑, DB 저장, 키워드 알림 즉시 발송!
+                    val newDeals = scraperManager.fetchAndProcessDeals()
+                    Log.d(TAG, "⏰ [스크래핑 완료] 신규 핫딜 ${newDeals.size}개 처리됨")
+                } catch (e: Exception) {
+                    Log.e(TAG, "알람 처리 중 오류: ${e.message}", e)
+                } finally {
+                    // 2. 다음 주기 알람 예약 (Self-rescheduling)
+                    try {
+                        val interval = appSettings.pollingInterval.first().toLong()
+                        alarmScheduler.scheduleAlarm(interval)
+                        Log.d(TAG, "⏰ 다음 폴링 알람 예약 완료: ${interval}분 후")
+                    } catch (e: Exception) {
+                        Log.e(TAG, "다음 알람 예약 실패: ${e.message}")
+                        alarmScheduler.scheduleAlarm(WorkerScheduler.DEFAULT_INTERVAL_MINUTES)
+                    }
+
+                    pendingResult.finish()
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,116 @@
+package com.hotdeal.alarm.worker
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.hotdeal.alarm.receiver.PollingAlarmReceiver
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * 실시간 백그라운드 폴링을 위한 AlarmManager 스케줄러
+ * 
+ * WorkManager PeriodicWork의 15분 주기 제한 및 Doze 모드 지연을 극복하기 위해
+ * AlarmManager (setExactAndAllowWhileIdle / setAndAllowWhileIdle)를 사용하여
+ * 사용자가 설정한 주기(1분, 2분, 5분 등)대로 정확하게 백그라운드 수집을 보장합니다.
+ */
+@Singleton
+class AlarmScheduler @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    companion object {
+        private const val TAG = "AlarmScheduler"
+        const val ACTION_POLL_ALARM = "com.hotdeal.alarm.ACTION_POLL_ALARM"
+        private const val REQUEST_CODE = 2001
+    }
+
+    private val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+
+    /**
+     * 알람 예약 (Doze mode에서도 정확히 깨어남)
+     * @param intervalMinutes 폴링 간격 (분)
+     */
+    fun scheduleAlarm(intervalMinutes: Long) {
+        val safeInterval = intervalMinutes.coerceAtLeast(1L)
+        val triggerTime = System.currentTimeMillis() + (safeInterval * 60 * 1000L)
+
+        val intent = Intent(context, PollingAlarmReceiver::class.java).apply {
+            action = ACTION_POLL_ALARM
+        }
+        val pendingIntent = PendingIntent.getBroadcast(
+            context,
+            REQUEST_CODE,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                if (alarmManager.canScheduleExactAlarms()) {
+                    alarmManager.setExactAndAllowWhileIdle(
+                        AlarmManager.RTC_WAKEUP,
+                        triggerTime,
+                        pendingIntent
+                    )
+                    Log.d(TAG, "Exact Alarm 예약 완료: ${safeInterval}분 후 (${triggerTime})")
+                } else {
+                    alarmManager.setAndAllowWhileIdle(
+                        AlarmManager.RTC_WAKEUP,
+                        triggerTime,
+                        pendingIntent
+                    )
+                    Log.d(TAG, "Inexact Alarm 예약 완료: ${safeInterval}분 후 (권한 없음)")
+                }
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setExactAndAllowWhileIdle(
+                    AlarmManager.RTC_WAKEUP,
+                    triggerTime,
+                    pendingIntent
+                )
+                Log.d(TAG, "Exact Alarm 예약 완료 (API < 31): ${safeInterval}분 후")
+            } else {
+                alarmManager.setExact(
+                    AlarmManager.RTC_WAKEUP,
+                    triggerTime,
+                    pendingIntent
+                )
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Alarm 예약 실패: ${e.message}", e)
+            try {
+                alarmManager.setAndAllowWhileIdle(
+                    AlarmManager.RTC_WAKEUP,
+                    triggerTime,
+                    pendingIntent
+                )
+            } catch (fallbackEx: Exception) {
+                Log.e(TAG, "Alarm 폴백 예약도 실패: ${fallbackEx.message}")
+            }
+        }
+    }
+
+    /**
+     * 알람 취소
+     */
+    fun cancelAlarm() {
+        val intent = Intent(context, PollingAlarmReceiver::class.java).apply {
+            action = ACTION_POLL_ALARM
+        }
+        val pendingIntent = PendingIntent.getBroadcast(
+            context,
+            REQUEST_CODE,
+            intent,
+            PendingIntent.FLAG_NO_CREATE or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        if (pendingIntent != null) {
+            alarmManager.cancel(pendingIntent)
+            pendingIntent.cancel()
+            Log.d(TAG, "Alarm 취소 완료")
+        }
+    }
+}

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

@@ -6,33 +6,20 @@ import androidx.hilt.work.HiltWorker
 import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
-import com.hotdeal.alarm.data.local.db.entity.HotDealEntity
+import com.hotdeal.alarm.domain.usecase.HotDealScraperManager
-import com.hotdeal.alarm.data.local.db.entity.KeywordEntity
-import com.hotdeal.alarm.data.local.db.entity.SiteConfigEntity
-import com.hotdeal.alarm.data.remote.scraper.ScraperFactory
-import com.hotdeal.alarm.domain.model.HotDeal
 import com.hotdeal.alarm.service.NotificationService
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.withContext
 
 /**
- * 핫딜 폴� Worker
+ * 핫딜 폴링 Worker (WorkManager 전용)
- * 
- * 키워드 매칭된 핫딜만 알림 발송
  */
 @HiltWorker
 class HotDealPollingWorker @AssistedInject constructor(
     @Assisted private val context: Context,
     @Assisted workerParams: WorkerParameters,
-    private val scraperFactory: ScraperFactory,
+    private val scraperManager: HotDealScraperManager,
-    private val notificationService: NotificationService,
+    private val notificationService: NotificationService
-    private val dealDao: com.hotdeal.alarm.data.local.db.dao.HotDealDao,
-    private val siteConfigDao: com.hotdeal.alarm.data.local.db.dao.SiteConfigDao,
-    private val keywordDao: com.hotdeal.alarm.data.local.db.dao.KeywordDao
 ) : CoroutineWorker(context, workerParams) {
     
     companion object {
@@ -40,153 +27,18 @@ class HotDealPollingWorker @AssistedInject constructor(
         const val TAG = "HotDealPolling"
     }
     
-    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
+    override suspend fun doWork(): Result {
-        try {
+        Log.d(TAG, "WorkManager HotDealPollingWorker 실행됨")
-            Log.d(TAG, "===== 핫딜 폴� 시작 =====")
+        return try {
-            
+            scraperManager.fetchAndProcessDeals()
-            // 1. 활성화된 사이트 설정 조회
-            val enabledConfigs = siteConfigDao.getEnabledConfigs()
-            Log.d(TAG, "활성화된 사이트 설정: ${enabledConfigs.size}개")
-            
-            if (enabledConfigs.isEmpty()) {
-                Log.w(TAG, "활성화된 사이트 설정이 없습니다.")
-                return@withContext Result.success()
-            }
-
-            // 2. 활성화된 키워드 조회
-            val keywords = keywordDao.getEnabledKeywords()
-            Log.d(TAG, "활성화된 키워드: ${keywords.size}개")
-
-            // 3. 각 사이트/게시판 스크래핑 (병렬)
-            Log.d(TAG, "스크래핑 시작...")
-            val allDeals = enabledConfigs.map { config ->
-                async {
-                    scrapeSite(config)
-                }
-            }.awaitAll().flatten()
-
-            Log.d(TAG, "스크래핑 완료: 총 ${allDeals.size}개 핫딜")
-            
-            if (allDeals.isEmpty()) {
-                Log.w(TAG, "스크래핑된 핫딜이 없습니다.")
-                return@withContext Result.success()
-            }
-
-            // 4. 새로운 핫딜 필터링
-            val newDeals = filterNewDeals(allDeals)
-            Log.d(TAG, "새로운 핫딜: ${newDeals.size}개")
-
-            if (newDeals.isEmpty()) {
-                Log.d(TAG, "새로운 핫딜이 없습니다.")
-                return@withContext Result.success()
-            }
-
-            // 5. 키워드 매칭 (키워드가 있을 때만)
-            val keywordMatchedDeals = if (keywords.isNotEmpty()) {
-                filterByKeywords(newDeals, keywords).also {
-                    Log.d(TAG, "키워드 매칭 핫딜: ${it.size}개")
-                }
-            } else {
-                Log.d(TAG, "키워드가 없어 매칭 체크를 건�뜁니다.")
-                emptyList()
-            }
-
-            // 6. DB 저장
-            var insertedCount = 0
-            newDeals.forEach { deal ->
-                try {
-                    val entity = HotDealEntity.fromDomain(deal)
-                    dealDao.insertDeal(entity)
-                    insertedCount++
-                } catch (e: Exception) {
-                    Log.w(TAG, "핫딜 저장 실패 (무시됨): ${deal.id}")
-                }
-            }
-            Log.d(TAG, "DB 저장 완료: $insertedCount/${newDeals.size}개 저장됨")
-
-            // 7. 키워드 매칭 알림 발송 (키워드 매칭된 것만!)
-            if (keywordMatchedDeals.isNotEmpty()) {
-                Log.d(TAG, "키워드 매칭 알림 발송: ${keywordMatchedDeals.size}개")
-                notificationService.showKeywordMatchNotification(keywordMatchedDeals)
-                dealDao.markAsKeywordMatch(keywordMatchedDeals.map { it.id })
-            } else {
-                Log.d(TAG, "키워드 매칭된 핫딜이 없어 알림을 발송하지 않습니다.")
-            }
-
-            // 8. 알림 발송 상태 업데이트
-            dealDao.markAsNotified(newDeals.map { it.id })
-
-            // 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, "===== 핫딜 폴 완료 =====")
             Result.success()
         } catch (e: Exception) {
-            Log.e(TAG, "폴� 오류: ${e.message}", e)
+            Log.e(TAG, "Worker 실행 실패: ${e.message}", e)
-            if (runAttemptCount < 3) {
+            if (runAttemptCount < 3) Result.retry() else Result.failure()
-                Result.retry()
-            } else {
-                Result.failure()
-            }
         }
     }
     
     override suspend fun getForegroundInfo(): ForegroundInfo {
         return notificationService.createForegroundInfo()
     }
-    
-    private suspend fun scrapeSite(config: SiteConfigEntity): List<HotDeal> {
-        val scraper = scraperFactory.getScraper(config.siteName)
-        if (scraper == null) {
-            Log.w(TAG, "스크래퍼를 찾을 수 없음: ${config.siteName}")
-            return emptyList()
-        }
-
-        Log.d(TAG, "스크래핑: ${config.siteName}/${config.boardName}")
-        val result = scraper.scrape(config.boardName)
-        
-        result.fold(
-            onSuccess = { deals ->
-                Log.d(TAG, " ${config.siteName}: ${deals.size}개 핫딜 파싱됨")
-                try {
-                    siteConfigDao.updateLastScrapedAt(config.siteBoardKey, System.currentTimeMillis())
-                } catch (e: Exception) {
-                    Log.w(TAG, "lastScrapedAt 업데이트 실패: ${config.siteBoardKey}")
-                }
-            },
-            onFailure = { error ->
-                Log.e(TAG, " ${config.siteName} 스크래핑 실패: ${error.message}")
-            }
-        )
-
-        return result.getOrElse { emptyList() }
-    }
-    
-    private suspend fun filterNewDeals(deals: List<HotDeal>): List<HotDeal> {
-        return deals.filter { deal ->
-            val existingByUrl = dealDao.getDealByUrl(deal.url)
-            if (existingByUrl != null) return@filter false
-            
-            val existingById = dealDao.getDealById(deal.id)
-            if (existingById != null) return@filter false
-            
-            true
-        }
-    }
-    
-    private fun filterByKeywords(deals: List<HotDeal>, keywords: List<KeywordEntity>): List<HotDeal> {
-        return deals.filter { deal ->
-            keywords.any { keyword ->
-                deal.title.contains(keyword.keyword, ignoreCase = true)
-            }
-        }
-    }
 }

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

@@ -1,6 +1,7 @@
 package com.hotdeal.alarm.worker
 
 import android.content.Context
+import android.util.Log
 import androidx.work.*
 import dagger.hilt.android.qualifiers.ApplicationContext
 import java.util.concurrent.TimeUnit
@@ -8,35 +9,40 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Worker 스케줄러
+ * 실시간 백그라운드 폴링 통합 스케줄러
  * 
- * 기본 폴� 주기: 2분
+ * 1. AlarmManager (AlarmScheduler): Doze Mode에서도 사용자가 지정한 정확한 주기(1분, 2분 등)로 즉시 실행
- * 배터리/데이터 절약을 위해 최소 2분 권장
+ * 2. WorkManager (HotDealPollingWorker): OS 백그라운드 작업 관리 및 백업 실행
  */
 @Singleton
 class WorkerScheduler @Inject constructor(
-    @ApplicationContext private val context: Context
+    @ApplicationContext private val context: Context,
+    private val alarmScheduler: AlarmScheduler
 ) {
     companion object {
+        private const val TAG = "WorkerScheduler"
         const val DEFAULT_INTERVAL_MINUTES = 2L
         const val MIN_INTERVAL_MINUTES = 1L
         const val MAX_INTERVAL_MINUTES = 60L
     }
     
     /**
-     * 주기적 폴� 예약
+     * 주기적 폴링 예약 (AlarmManager + WorkManager 이중 등록)
-     * @param intervalMinutes 폴� 간격 (분) - 기본 2분
+     * @param intervalMinutes 폴링 간격 (분)
      */
     fun schedulePeriodicPolling(intervalMinutes: Long = DEFAULT_INTERVAL_MINUTES) {
-        // 최소/최대 값 제한
         val safeInterval = intervalMinutes.coerceIn(MIN_INTERVAL_MINUTES, MAX_INTERVAL_MINUTES)
+        Log.d(TAG, "주기적 폴링 예약 시작: ${safeInterval}분 간격")
 
+        // 1. AlarmManager 기반 정확한 주기 알람 예약 (Doze mode 관통)
+        alarmScheduler.scheduleAlarm(safeInterval)
+        
+        // 2. WorkManager 기반 백업 주기 작업 예약
         val constraints = Constraints.Builder()
             .setRequiredNetworkType(NetworkType.CONNECTED)
             .setRequiresDeviceIdle(false)
             .build()
         
-        // 유연한 실행 시간 (±25%)
         val flexTime = (safeInterval * 0.25).toLong().coerceAtLeast(1)
         
         val workRequest = PeriodicWorkRequestBuilder<HotDealPollingWorker>(
@@ -54,21 +60,23 @@ class WorkerScheduler @Inject constructor(
         
         WorkManager.getInstance(context).enqueueUniquePeriodicWork(
             HotDealPollingWorker.WORK_NAME,
-            ExistingPeriodicWorkPolicy.KEEP,
+            ExistingPeriodicWorkPolicy.UPDATE,
             workRequest
         )
     }
     
     /**
-     * 한 번만 실행
+     * 즉시 1회 실행 (메인화면 진입 / 새로고침 / 알람 수신 시)
      */
     fun executeOnce() {
+        Log.d(TAG, "즉시 1회 스크래핑 요청 (executeOnce)")
         val constraints = Constraints.Builder()
             .setRequiredNetworkType(NetworkType.CONNECTED)
             .build()
         
         val workRequest = OneTimeWorkRequestBuilder<HotDealPollingWorker>()
             .setConstraints(constraints)
+            .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
             .addTag(HotDealPollingWorker.TAG)
             .build()
         
@@ -76,22 +84,28 @@ class WorkerScheduler @Inject constructor(
     }
     
     /**
-     * 폴� 취소
+     * 폴링 취소
      */
     fun cancelPolling() {
+        Log.d(TAG, "폴링 전체 취소")
+        alarmScheduler.cancelAlarm()
         WorkManager.getInstance(context).cancelUniqueWork(HotDealPollingWorker.WORK_NAME)
     }
     
     /**
-     * 폴� 활성화 여부 확인
+     * 폴링 활성화 여부 확인
      */
     fun isPollingActive(): Boolean {
-        val workInfos = WorkManager.getInstance(context)
+        return try {
-            .getWorkInfosForUniqueWork(HotDealPollingWorker.WORK_NAME)
+            val workInfos = WorkManager.getInstance(context)
-            .get()
+                .getWorkInfosForUniqueWork(HotDealPollingWorker.WORK_NAME)
+                .get()
             
-        return workInfos.any { 
+            workInfos.any { 
-            it.state == WorkInfo.State.RUNNING || it.state == WorkInfo.State.ENQUEUED 
+                it.state == WorkInfo.State.RUNNING || it.state == WorkInfo.State.ENQUEUED 
+            }
+        } catch (e: Exception) {
+            false
         }
     }
 }

version.json

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