dependencies {
    def work_version = "2.9.0"
    implementation "androidx.work:work-runtime-ktx:$work_version"
    
    // 可選 - 測(cè)試支持
    androidTestImplementation "androidx.work:work-testing:$work_version"
}

import android.content.Context
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.File
import kotlin.math.min

class CacheCleanerWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {

    // 清理閾值：只清理7天前的文件
    private companion object {
        const val CLEANUP_THRESHOLD_DAYS = 7
        const val MAX_FILES_PER_BATCH = 50 // 每批次最大文件數(shù)
    }

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        return@withContext try {
            val startTime = System.currentTimeMillis()
            
            // 清理內(nèi)部緩存
            val internalCacheCleaned = cleanCacheDir(applicationContext.cacheDir)
            
            // 清理外部緩存
            val externalCacheCleaned = applicationContext.externalCacheDir?.let {
                cleanCacheDir(it)
            } ?: 0
            
            // 清理自定義緩存目錄
            val customCacheDir = File(applicationContext.filesDir, "custom_cache")
            val customCacheCleaned = cleanCacheDir(customCacheDir)
            
            val totalCleaned = internalCacheCleaned + externalCacheCleaned + customCacheCleaned
            val timeSpent = System.currentTimeMillis() - startTime
            
            // 記錄清理結(jié)果
            logCleanupResult(totalCleaned, timeSpent)
            
            Result.success()
        } catch (e: SecurityException) {
            // 處理權(quán)限問題
            Result.failure()
        } catch (e: Exception) {
            // 其他異常處理
            Result.retry()
        }
    }

    /**
     * 遞歸清理緩存目錄
     * @return 刪除的文件數(shù)量
     */
    private fun cleanCacheDir(cacheDir: File?): Int {
        if (cacheDir == null || !cacheDir.exists()) return 0
        
        var deletedCount = 0
        val thresholdTime = System.currentTimeMillis() - CLEANUP_THRESHOLD_DAYS * 24 * 3600 * 1000
        
        // 處理目錄下的文件
        cacheDir.listFiles()?.let { files ->
            for (file in files) {
                if (deletedCount >= MAX_FILES_PER_BATCH) {
                    // 達(dá)到批次限制，暫停清理
                    break
                }
                
                if (file.isDirectory) {
                    // 遞歸清理子目錄
                    deletedCount += cleanCacheDir(file)
                    
                    // 刪除空目錄
                    if (file.list()?.isEmpty() == true) {
                        file.delete()
                    }
                } else {
                    // 刪除過期文件
                    if (file.lastModified() < thresholdTime) {
                        if (file.delete()) {
                            deletedCount++
                        }
                    }
                }
            }
        }
        
        return deletedCount
    }

    private fun logCleanupResult(fileCount: Int, timeSpent: Long) {
        // 實(shí)際項(xiàng)目中可接入分析工具
        println("緩存清理完成: 刪除 $fileCount 個(gè)文件, 耗時(shí) ${timeSpent}ms")
    }
}

import android.content.Context
import androidx.work.Constraints
import androidx.work.ExistingPeriodicWorkPolicy
import androidx.work.NetworkType
import androidx.work.PeriodicWorkRequest
import androidx.work.PeriodicWorkRequestBuilder
import androidx.work.WorkManager
import java.util.concurrent.TimeUnit

object CacheCleanerScheduler {

    // 唯一任務(wù)名稱
    private const val UNIQUE_WORK_NAME = "cache_cleaner_work"
    
    // 不同構(gòu)建環(huán)境使用不同策略
    fun schedule(context: Context) {
        val workManager = WorkManager.getInstance(context)
        
        // 取消可能存在的舊任務(wù)
        workManager.cancelUniqueWork(UNIQUE_WORK_NAME)
        
        // 構(gòu)建約束條件
        val constraints = buildConstraints()
        
        // 創(chuàng)建定期工作請(qǐng)求
        val workRequest = buildWorkRequest(constraints)
        
        // 使用唯一任務(wù)名稱避免重復(fù)調(diào)度
        workManager.enqueueUniquePeriodicWork(
            UNIQUE_WORK_NAME,
            ExistingPeriodicWorkPolicy.REPLACE,
            workRequest
        )
    }
    
    private fun buildConstraints(): Constraints {
        return Constraints.Builder()
            .setRequiresCharging(true) // 充電時(shí)執(zhí)行
            .setRequiresBatteryNotLow(true) // 電量充足
            .setRequiresStorageNotLow(true) // 存儲(chǔ)空間充足
            .setRequiresDeviceIdle(true) // 設(shè)備空閑
            .setRequiredNetworkType(NetworkType.UNMETERED) // 僅限WiFi
            .build()
    }
    
    private fun buildWorkRequest(constraints: Constraints): PeriodicWorkRequest {
        val intervalHours = if (BuildConfig.DEBUG) {
            4 // 調(diào)試模式下4小時(shí)一次
        } else {
            24 // 生產(chǎn)環(huán)境24小時(shí)一次
        }
        
        val flexInterval = if (BuildConfig.DEBUG) {
            1 // 調(diào)試模式靈活間隔1小時(shí)
        } else {
            3 // 生產(chǎn)環(huán)境靈活間隔3小時(shí)
        }
        
        return PeriodicWorkRequestBuilder<CacheCleanerWorker>(
            intervalHours.toLong(), 
            TimeUnit.HOURS,
            flexInterval.toLong(),
            TimeUnit.HOURS
        )
            .setConstraints(constraints)
            .setInitialDelay(calculateInitialDelay()) // 隨機(jī)初始延遲
            .addTag("cache_cleanup") // 添加標(biāo)簽便于查詢
            .build()
    }
    
    /**
     * 計(jì)算隨機(jī)初始延遲（1-6小時(shí)）
     * 避免所有設(shè)備同時(shí)執(zhí)行清理任務(wù)
     */
    private fun calculateInitialDelay(): Long {
        val randomHours = (1..6).random()
        return randomHours.toLong()
    }
    
    // 取消任務(wù)
    fun cancel(context: Context) {
        WorkManager.getInstance(context)
            .cancelUniqueWork(UNIQUE_WORK_NAME)
    }
    
    // 查詢?nèi)蝿?wù)狀態(tài)
    fun getWorkInfo(context: Context) {
        WorkManager.getInstance(context)
            .getWorkInfosForUniqueWorkLiveData(UNIQUE_WORK_NAME)
            .observeForever { workInfos ->
                workInfos?.forEach { info ->
                    println("任務(wù)狀態(tài): ${info.state}, ID: ${info.id}")
                }
            }
    }
}

class MyApp : Application() {
    
    override fun onCreate() {
        super.onCreate()
        
        // 初始化WorkManager
        initWorkManager()
        
        // 調(diào)度緩存清理任務(wù)
        if (shouldScheduleCleanup()) {
            CacheCleanerScheduler.schedule(this)
        }
    }
    
    private fun initWorkManager() {
        // 高級(jí)配置示例（可選）
        val config = Configuration.Builder()
            .setMinimumLoggingLevel(if (BuildConfig.DEBUG) Log.DEBUG else Log.ERROR)
            .setExecutor(Executors.newFixedThreadPool(4))
            .setTaskExecutor(Executors.newScheduledThreadPool(2))
            .build()
        
        WorkManager.initialize(this, config)
    }
    
    private fun shouldScheduleCleanup(): Boolean {
        // 實(shí)際項(xiàng)目中可添加更多條件判斷
        return !isPowerSaveMode() && hasSufficientStorage()
    }
    
    private fun isPowerSaveMode(): Boolean {
        val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
        return powerManager.isPowerSaveMode
    }
    
    private fun hasSufficientStorage(): Boolean {
        val stat = StatFs(cacheDir.absolutePath)
        val availableBytes = stat.availableBlocksLong * stat.blockSizeLong
        return availableBytes > 100 * 1024 * 1024 // 100MB以上可用空間
    }
}

<application
    android:name=".MyApp"
    android:usesCleartextTraffic="true"
    tools:targetApi="28">
    
    <!-- WorkManager需要后臺(tái)權(quán)限 -->
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    
    <!-- 可選：添加清理任務(wù)狀態(tài)接收器 -->
    <receiver android:name="androidx.work.impl.diagnostics.DiagnosticsReceiver"
        android:enabled="true"
        android:exported="false"
        tools:ignore="ExportedReceiver" />
</application>

// 創(chuàng)建任務(wù)鏈
fun scheduleChainedCleanup(context: Context) {
    val cleanImageWork = OneTimeWorkRequestBuilder<ImageCacheWorker>().build()
    val cleanDbWork = OneTimeWorkRequestBuilder<DbCacheWorker>().build()
    val cleanNetworkWork = OneTimeWorkRequestBuilder<NetworkCacheWorker>().build()
    val reportWork = OneTimeWorkRequestBuilder<CleanupReportWorker>().build()
    
    WorkManager.getInstance(context)
        .beginWith(cleanImageWork)
        .then(cleanDbWork)
        .then(cleanNetworkWork)
        .then(reportWork)
        .enqueue()
}

class AdaptiveCacheWorker(context: Context, params: WorkerParameters) : 
    CoroutineWorker(context, params) {
    
    override suspend fun doWork(): Result {
        val startTime = System.currentTimeMillis()
        
        // 獲取設(shè)備性能等級(jí)
        val performanceLevel = getDevicePerformanceLevel()
        
        // 根據(jù)性能調(diào)整批次大小
        val batchSize = when (performanceLevel) {
            DevicePerformance.LOW -> 20
            DevicePerformance.MEDIUM -> 50
            DevicePerformance.HIGH -> 100
        }
        
        // 執(zhí)行自適應(yīng)清理
        cleanCacheWithBatchSize(batchSize)
        
        // 記錄執(zhí)行時(shí)間
        val duration = System.currentTimeMillis() - startTime
        saveExecutionStats(duration, batchSize)
        
        return Result.success()
    }
    
    private fun getDevicePerformanceLevel(): DevicePerformance {
        // 根據(jù)CPU核心數(shù)、內(nèi)存等判斷設(shè)備性能
        val cores = Runtime.getRuntime().availableProcessors()
        val memory = ActivityManager.MemoryInfo().let {
            (context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager)
                .getMemoryInfo(it)
            it.totalMem / (1024 * 1024) // MB
        }
        
        return when {
            cores <= 2 && memory < 1500 -> DevicePerformance.LOW
            cores > 4 && memory > 3000 -> DevicePerformance.HIGH
            else -> DevicePerformance.MEDIUM
        }
    }
    
    enum class DevicePerformance { LOW, MEDIUM, HIGH }
}

class ForegroundCacheWorker(context: Context, params: WorkerParameters) : 
    CoroutineWorker(context, params) {
    
    override suspend fun doWork(): Result {
        setForeground(createForegroundInfo())
        return withContext(Dispatchers.IO) {
            // 執(zhí)行長時(shí)間清理操作
            cleanLargeCache()
            Result.success()
        }
    }
    
    private fun createForegroundInfo(): ForegroundInfo {
        val id = NotificationHelper.NOTIFICATION_ID_CLEANUP
        val notification = NotificationHelper.createCleanupNotification(applicationContext)
        return ForegroundInfo(id, notification)
    }
}

object NotificationHelper {
    const val NOTIFICATION_ID_CLEANUP = 1001
    
    fun createCleanupNotification(context: Context): Notification {
        val channelId = "cache_cleanup_channel"
        val builder = NotificationCompat.Builder(context, channelId)
            .setContentTitle("正在優(yōu)化存儲(chǔ)空間")
            .setContentText("清理緩存文件中...")
            .setSmallIcon(R.drawable.ic_cleanup)
            .setPriority(NotificationCompat.PRIORITY_LOW)
        
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                channelId,
                "緩存清理",
                NotificationManager.IMPORTANCE_LOW
            ).apply {
                description = "緩存清理任務(wù)通知"
            }
            val manager = context.getSystemService(NotificationManager::class.java)
            manager.createNotificationChannel(channel)
        }
        
        return builder.build()
    }
}

@RunWith(AndroidJUnit4::class)
class CacheCleanerWorkerTest {
    
    private lateinit var context: Context
    private lateinit var executor: Executor
    
    @Before
    fun setUp() {
        context = ApplicationProvider.getApplicationContext()
        executor = Executors.newSingleThreadExecutor()
        
        // 初始化測(cè)試WorkManager
        val config = Configuration.Builder()
            .setExecutor(executor)
            .setTaskExecutor(executor)
            .build()
        
        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
    }
    
    @Test
    fun testCacheCleanup() = runBlocking {
        // 創(chuàng)建測(cè)試緩存文件
        val testDir = File(context.cacheDir, "test_cleanup")
        testDir.mkdirs()
        repeat(10) { File(testDir, "file_$it.txt").createNewFile() }
        
        // 創(chuàng)建Worker
        val worker = CacheCleanerWorker(context, WorkerParameters.EMPTY)
        
        // 執(zhí)行任務(wù)
        val result = worker.doWork()
        
        // 驗(yàn)證結(jié)果
        assertThat(result, `is`(Result.success()))
        assertThat(testDir.listFiles()?.size, `is`(0))
    }
    
    @Test
    fun testBatchProcessing() {
        // 創(chuàng)建超過批次限制的文件
        val testDir = File(context.cacheDir, "large_dir")
        testDir.mkdirs()
        repeat(200) { File(testDir, "file_$it.txt").createNewFile() }
        
        val worker = CacheCleanerWorker(context, WorkerParameters.EMPTY)
        worker.cleanCacheDir(testDir)
        
        // 驗(yàn)證批次處理
        val remaining = testDir.listFiles()?.size ?: 0
        assertThat(remaining, `is`(150)) // 200 - 50 = 150
    }
}

adb shell dumpsys jobscheduler

// 在開發(fā)模式下添加測(cè)試按鈕
fun forceRunCleanup(context: Context) {
    val request = OneTimeWorkRequestBuilder<CacheCleanerWorker>().build()
    WorkManager.getInstance(context).enqueue(request)
}

WorkManager.getInstance(context)
    .getWorkInfoByIdLiveData(request.id)
    .observe(this) { info ->
        when (info?.state) {
            WorkInfo.State.ENQUEUED -> println("任務(wù)排隊(duì)中")
            WorkInfo.State.RUNNING -> println("任務(wù)執(zhí)行中")
            WorkInfo.State.SUCCEEDED -> println("任務(wù)成功")
            WorkInfo.State.FAILED -> println("任務(wù)失敗")
            WorkInfo.State.BLOCKED -> println("任務(wù)阻塞")
            WorkInfo.State.CANCELLED -> println("任務(wù)取消")
        }
    }