个人小站

这个请求要求我提供一个综合了WorkManager和网络状态感知功能的完整后台下载管理器实现。看起来用户已经有了一些代码，但想要更完整的解决方案。

根据之前的讨论和用户提供的文件内容，我可以看出他们想要的是一个能够在以下场景正常工作的下载管理器：

1. 能够在应用后台运行
2. 即使应用被杀死也能继续下载
3. 能够感知网络变化并自动处理
4. 支持断点续传和任务队列管理

解决方案可以包含以下组件：

1. WorkManager：用于管理后台任务，即使应用被终止也能恢复任务
2. ForegroundService：在下载过程中显示通知，降低系统杀死服务的概率
3. Room 数据库：存储下载任务状态，便于恢复
4. 生命周期感知：监测应用前台/后台状态转换
5. 下载队列管理：正确管理任务队列和状态转换

我需要提供一个综合的、能够工作的解决方案，结合 WorkManager 进行任务调度，并添加网络感知功能。这个实现应该很实用，能够解决 Android 后台下载的各种限制问题。

综合型 WorkManager 网络感知下载管理器

下面是一个结合 WorkManager 和网络状态感知的完整下载管理器实现：

// WorkManagerNetworkDownloader.kt

import android.app.*
import android.content.Context
import android.content.Intent
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import android.os.Build
import androidx.annotation.RequiresApi
import androidx.core.app.NotificationCompat
import androidx.lifecycle.*
import androidx.room.*
import androidx.work.*
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import okhttp3.*
import java.io.*
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger

/**
 * 下载任务实体类
 */
@Entity(tableName = "download_tasks")
data class DownloadTask(
    @PrimaryKey val id: String,
    val url: String,
    val fileName: String,
    val savePath: String,
    val totalBytes: Long = 0,
    val downloadedBytes: Long = 0,
    val status: DownloadStatus = DownloadStatus.PENDING,
    val priority: Int = 0,
    val createTime: Long = System.currentTimeMillis(),
    val lastUpdated: Long = System.currentTimeMillis(),
    val errorCount: Int = 0,
    val errorMessage: String? = null
)

/**
 * 下载状态枚举
 */
enum class DownloadStatus {
    PENDING,            // 等待下载
    CONNECTING,         // 连接中
    DOWNLOADING,        // 下载中
    PAUSED,             // 暂停状态（用户主动暂停）
    WAITING_FOR_NETWORK,// 等待网络连接
    COMPLETED,          // 下载完成
    FAILED,             // 下载失败
    CANCELED            // 下载取消
}

/**
 * 下载任务DAO
 */
@Dao
interface DownloadTaskDao {
    @Query("SELECT * FROM download_tasks ORDER BY priority DESC, createTime ASC")
    fun getAllTasks(): Flow<List<DownloadTask>>

    @Query("SELECT * FROM download_tasks WHERE status = :status ORDER BY priority DESC, createTime ASC")
    fun getTasksByStatus(status: DownloadStatus): Flow<List<DownloadTask>>

    @Query("SELECT * FROM download_tasks WHERE status IN (:statuses) ORDER BY priority DESC, createTime ASC")
    fun getTasksByStatuses(statuses: List<DownloadStatus>): Flow<List<DownloadTask>>

    @Query("SELECT * FROM download_tasks WHERE id = :taskId")
    suspend fun getTaskById(taskId: String): DownloadTask?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertTask(task: DownloadTask)

    @Update
    suspend fun updateTask(task: DownloadTask)

    @Delete
    suspend fun deleteTask(task: DownloadTask)

    @Query("UPDATE download_tasks SET status = :newStatus WHERE id = :taskId")
    suspend fun updateTaskStatus(taskId: String, newStatus: DownloadStatus)

    @Query("UPDATE download_tasks SET downloadedBytes = :downloadedBytes, lastUpdated = :lastUpdated WHERE id = :taskId")
    suspend fun updateTaskProgress(taskId: String, downloadedBytes: Long, lastUpdated: Long)

    @Query("UPDATE download_tasks SET status = :newStatus WHERE status = :currentStatus")
    suspend fun updateTasksStatus(currentStatus: DownloadStatus, newStatus: DownloadStatus)

    @Query("UPDATE download_tasks SET status = :newStatus WHERE status IN (:currentStatuses)")
    suspend fun updateMultipleTasksStatus(currentStatuses: List<DownloadStatus>, newStatus: DownloadStatus)
}

/**
 * 下载数据库
 */
@Database(entities = [DownloadTask::class], version = 1, exportSchema = false)
abstract class DownloadDatabase : RoomDatabase() {
    abstract fun downloadTaskDao(): DownloadTaskDao

    companion object {
        @Volatile
        private var INSTANCE: DownloadDatabase? = null

        fun getDatabase(context: Context): DownloadDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    DownloadDatabase::class.java,
                    "download_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

/**
 * 下载事件 - 用于UI层观察
 */
sealed class DownloadEvent {
    data class Progress(val taskId: String, val progress: Int, val downloadedBytes: Long, val totalBytes: Long) : DownloadEvent()
    data class StatusChanged(val taskId: String, val status: DownloadStatus) : DownloadEvent()
    data class Complete(val taskId: String, val filePath: String) : DownloadEvent()
    data class Error(val taskId: String, val error: String) : DownloadEvent()
}

/**
 * 网络状态监听器
 */
class NetworkMonitor(private val context: Context) {

    interface NetworkListener {
        fun onNetworkAvailable()
        fun onNetworkUnavailable()
    }

    private val listeners = mutableListOf<NetworkListener>()
    private var isNetworkAvailable = false
    private var isMonitoring = false

    private val connectivityManager by lazy {
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    }

    // 网络回调
    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            if (!isNetworkAvailable) {
                isNetworkAvailable = true
                notifyNetworkAvailable()
            }
        }

        override fun onLost(network: Network) {
            if (!isAnyNetworkAvailable()) {
                isNetworkAvailable = false
                notifyNetworkUnavailable()
            }
        }
    }

    // 开始监听
    fun startMonitoring() {
        if (isMonitoring) return

        isNetworkAvailable = isAnyNetworkAvailable()

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            val request = NetworkRequest.Builder()
                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                .build()
            connectivityManager.registerNetworkCallback(request, networkCallback)
        } else {
            // 旧版本Android可以使用广播接收器，此处省略
        }

        isMonitoring = true
    }

    // 停止监听
    fun stopMonitoring() {
        if (!isMonitoring) return

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            connectivityManager.unregisterNetworkCallback(networkCallback)
        }

        isMonitoring = false
    }

    // 添加监听器
    fun addListener(listener: NetworkListener) {
        if (!listeners.contains(listener)) {
            listeners.add(listener)
        }
    }

    // 移除监听器
    fun removeListener(listener: NetworkListener) {
        listeners.remove(listener)
    }

    // 检查是否有可用网络
    fun isNetworkAvailable(): Boolean {
        return isAnyNetworkAvailable()
    }

    // 检查是否有任何可用网络
    private fun isAnyNetworkAvailable(): Boolean {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val network = connectivityManager.activeNetwork ?: return false
            val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false

            return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
        } else {
            @Suppress("DEPRECATION")
            val networkInfo = connectivityManager.activeNetworkInfo
            return networkInfo != null && networkInfo.isConnected
        }
    }

    // 通知网络可用
    private fun notifyNetworkAvailable() {
        listeners.forEach { it.onNetworkAvailable() }
    }

    // 通知网络不可用
    private fun notifyNetworkUnavailable() {
        listeners.forEach { it.onNetworkUnavailable() }
    }
}

/**
 * 下载工作器 - 基于WorkManager
 */
class DownloadWorker(
    appContext: Context,
    workerParams: WorkerParameters
) : CoroutineWorker(appContext, workerParams) {

    companion object {
        const val TAG_DOWNLOAD = "download_worker"
        const val KEY_TASK_ID = "task_id"
        const val KEY_RETRY_COUNT = "retry_count"
        const val MAX_RETRY_COUNT = 5
        const val NOTIFICATION_CHANNEL_ID = "download_channel"
        const val NOTIFICATION_ID = 1

        // 调度下载任务
        fun scheduleDownload(context: Context, taskId: String, retryCount: Int = 0): Operation {
            val constraints = Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresStorageNotLow(true)
                .build()

            val inputData = workDataOf(
                KEY_TASK_ID to taskId,
                KEY_RETRY_COUNT to retryCount
            )

            val request = OneTimeWorkRequestBuilder<DownloadWorker>()
                .setConstraints(constraints)
                .setInputData(inputData)
                .addTag(TAG_DOWNLOAD)
                .addTag(taskId)
                .setBackoffCriteria(
                    BackoffPolicy.EXPONENTIAL,
                    WorkRequest.MIN_BACKOFF_MILLIS,
                    TimeUnit.MILLISECONDS
                )
                .build()

            return WorkManager.getInstance(context)
                .enqueueUniqueWork(
                    "download_$taskId",
                    ExistingWorkPolicy.REPLACE,
                    request
                )
        }

        // 取消下载任务
        fun cancelDownload(context: Context, taskId: String) {
            WorkManager.getInstance(context).cancelUniqueWork("download_$taskId")
        }
    }

    private val downloadManager by lazy {
        WorkManagerNetworkDownloader.getInstance(applicationContext)
    }

    @RequiresApi(Build.VERSION_CODES.O)
    private fun createNotificationChannel() {
        val notificationManager = applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        val channel = NotificationChannel(
            NOTIFICATION_CHANNEL_ID,
            "下载通知",
            NotificationManager.IMPORTANCE_LOW
        ).apply {
            description = "显示下载进度"
            setShowBadge(false)
        }

        notificationManager.createNotificationChannel(channel)
    }

    // 创建前台通知信息
    private fun createForegroundInfo(title: String, progress: Int = 0): ForegroundInfo {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            createNotificationChannel()
        }

        val cancelIntent = WorkManager.getInstance(applicationContext)
            .createCancelPendingIntent(id)

        val notification = NotificationCompat.Builder(applicationContext, NOTIFICATION_CHANNEL_ID)
            .setContentTitle(title)
            .setTicker(title)
            .setContentText("下载中...")
            .setSmallIcon(android.R.drawable.stat_sys_download)
            .setOngoing(true)
            .setProgress(100, progress, progress == 0)
            .addAction(android.R.drawable.ic_delete, "取消", cancelIntent)
            .build()

        return ForegroundInfo(NOTIFICATION_ID, notification)
    }

    override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
        val taskId = inputData.getString(KEY_TASK_ID) ?: return@withContext Result.failure()
        val retryCount = inputData.getInt(KEY_RETRY_COUNT, 0)

        try {
            // 获取下载任务
            val task = downloadManager.getTaskById(taskId) ?: return@withContext Result.failure()

            // 设置为前台Worker
            setForeground(createForegroundInfo("下载: ${task.fileName}"))

            // 更新任务状态
            downloadManager.updateTaskStatus(taskId, DownloadStatus.DOWNLOADING)

            // 执行下载
            val file = downloadManager.performDownload(task, this@DownloadWorker)

            // 下载完成
            downloadManager.updateTaskStatus(taskId, DownloadStatus.COMPLETED)
            downloadManager.notifyDownloadComplete(task.id, file.absolutePath)

            Result.success()
        } catch (e: Exception) {
            e.printStackTrace()

            // 判断错误类型
            val isNetworkError = e is IOException && (
                e.message?.contains("network", ignoreCase = true) == true ||
                e.message?.contains("connect", ignoreCase = true) == true ||
                e.message?.contains("timeout", ignoreCase = true) == true
            )

            if (isNetworkError) {
                // 网络错误，更新状态为等待网络
                downloadManager.updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)

                // 判断是否需要重试
                if (retryCount < MAX_RETRY_COUNT) {
                    Result.retry()
                } else {
                    downloadManager.updateTaskStatus(taskId, DownloadStatus.FAILED)
                    downloadManager.updateTaskError(
                        taskId,
                        "网络连接失败: ${e.message ?: "未知错误"}"
                    )
                    Result.failure()
                }
            } else if (isStopped) {
                // Worker被停止，可能是系统限制或用户取消
                downloadManager.updateTaskStatus(taskId, DownloadStatus.PAUSED)
                Result.retry()
            } else {
                // 其他错误
                downloadManager.updateTaskStatus(taskId, DownloadStatus.FAILED)
                downloadManager.updateTaskError(
                    taskId,
                    "下载失败: ${e.message ?: "未知错误"}"
                )
                Result.failure()
            }
        }
    }
}

/**
 * 应用生命周期观察者
 */
class AppLifecycleObserver(private val context: Context) : DefaultLifecycleObserver {

    private val downloader = WorkManagerNetworkDownloader.getInstance(context)

    override fun onStart(owner: LifecycleOwner) {
        // 应用进入前台
        downloader.onAppForeground()
    }

    override fun onStop(owner: LifecycleOwner) {
        // 应用进入后台
        downloader.onAppBackground()
    }
}

/**
 * 主下载管理器类
 */
class WorkManagerNetworkDownloader private constructor(private val context: Context) : NetworkMonitor.NetworkListener {

    companion object {
        @Volatile
        private var INSTANCE: WorkManagerNetworkDownloader? = null

        fun getInstance(context: Context): WorkManagerNetworkDownloader {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: WorkManagerNetworkDownloader(context.applicationContext).also {
                    INSTANCE = it
                }
            }
        }
    }

    private val database = DownloadDatabase.getDatabase(context)
    private val downloadTaskDao = database.downloadTaskDao()
    private val workManager = WorkManager.getInstance(context)
    private val networkMonitor = NetworkMonitor(context)

    private val downloadScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
    private val activeDownloads = AtomicInteger(0)

    private val _downloadEvents = MutableSharedFlow<DownloadEvent>(extraBufferCapacity = 64)
    val downloadEvents: SharedFlow<DownloadEvent> = _downloadEvents.asSharedFlow()

    // 任务列表Flow
    val allTasks = downloadTaskDao.getAllTasks()
    val pendingTasks = downloadTaskDao.getTasksByStatus(DownloadStatus.PENDING)
    val activeTasks = downloadTaskDao.getTasksByStatuses(
        listOf(DownloadStatus.DOWNLOADING, DownloadStatus.CONNECTING)
    )
    val completedTasks = downloadTaskDao.getTasksByStatus(DownloadStatus.COMPLETED)
    val failedTasks = downloadTaskDao.getTasksByStatus(DownloadStatus.FAILED)
    val pausedTasks = downloadTaskDao.getTasksByStatuses(
        listOf(DownloadStatus.PAUSED, DownloadStatus.WAITING_FOR_NETWORK)
    )

    // OkHttp客户端
    private val okHttpClient = OkHttpClient.Builder()
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS)
        .build()

    init {
        // 启动网络监控
        networkMonitor.addListener(this)
        networkMonitor.startMonitoring()

        // 初始化时恢复所有应该运行的任务
        downloadScope.launch {
            // 将之前正在下载的任务标记为等待状态
            downloadTaskDao.updateMultipleTasksStatus(
                listOf(DownloadStatus.DOWNLOADING, DownloadStatus.CONNECTING),
                DownloadStatus.PENDING
            )

            // 如果网络可用，启动所有等待网络的任务
            if (networkMonitor.isNetworkAvailable()) {
                downloadTaskDao.getTasksByStatus(DownloadStatus.WAITING_FOR_NETWORK).first().forEach { task ->
                    resumeDownload(task.id)
                }
            }

            // 恢复所有待处理的任务
            downloadTaskDao.getTasksByStatus(DownloadStatus.PENDING).first().forEach { task ->
                startDownload(task.id)
            }
        }
    }

    // 添加下载任务
    suspend fun addDownloadTask(
        url: String,
        fileName: String,
        savePath: String,
        priority: Int = 0
    ): String {
        val taskId = "${url.hashCode()}_${System.currentTimeMillis()}"

        // 确保保存目录存在
        val saveDir = File(savePath)
        if (!saveDir.exists()) {
            saveDir.mkdirs()
        }

        // 创建任务
        val task = DownloadTask(
            id = taskId,
            url = url,
            fileName = fileName,
            savePath = savePath,
            status = DownloadStatus.PENDING,
            priority = priority
        )

        // 保存到数据库
        downloadTaskDao.insertTask(task)

        // 触发状态变更事件
        _downloadEvents.emit(DownloadEvent.StatusChanged(taskId, DownloadStatus.PENDING))

        // 如果网络可用，立即开始下载
        if (networkMonitor.isNetworkAvailable()) {
            startDownload(taskId)
        } else {
            // 网络不可用，标记为等待网络
            updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)
        }

        return taskId
    }

    // 开始下载
    suspend fun startDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status == DownloadStatus.PENDING || task.status == DownloadStatus.PAUSED ||
            task.status == DownloadStatus.WAITING_FOR_NETWORK || task.status == DownloadStatus.FAILED) {

            // 如果网络不可用，标记为等待网络
            if (!networkMonitor.isNetworkAvailable()) {
                updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)
                return
            }

            // 更新状态为等待中
            updateTaskStatus(taskId, DownloadStatus.CONNECTING)

            // 调度下载任务
            DownloadWorker.scheduleDownload(context, taskId)

            // 增加活跃下载计数
            activeDownloads.incrementAndGet()
        }
    }

    // 暂停下载
    suspend fun pauseDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status == DownloadStatus.DOWNLOADING || task.status == DownloadStatus.CONNECTING ||
            task.status == DownloadStatus.PENDING || task.status == DownloadStatus.WAITING_FOR_NETWORK) {

            // 取消Worker
            DownloadWorker.cancelDownload(context, taskId)

            // 更新状态
            updateTaskStatus(taskId, DownloadStatus.PAUSED)

            // 减少活跃下载计数
            val activeCount = activeDownloads.decrementAndGet()
            if (activeCount < 0) {
                activeDownloads.set(0)
            }
        }
    }

    // 恢复下载
    suspend fun resumeDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status == DownloadStatus.PAUSED || task.status == DownloadStatus.FAILED ||
            task.status == DownloadStatus.WAITING_FOR_NETWORK) {

            // 如果网络可用，开始下载
            if (networkMonitor.isNetworkAvailable()) {
                updateTaskStatus(taskId, DownloadStatus.PENDING)
                startDownload(taskId)
            } else {
                // 网络不可用，标记为等待网络
                updateTaskStatus(taskId, DownloadStatus.WAITING_FOR_NETWORK)
            }
        }
    }

    // 取消下载
    suspend fun cancelDownload(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        // 取消Worker
        DownloadWorker.cancelDownload(context, taskId)

        // 更新状态
        updateTaskStatus(taskId, DownloadStatus.CANCELED)

        // 减少活跃下载计数
        val activeCount = activeDownloads.decrementAndGet()
        if (activeCount < 0) {
            activeDownloads.set(0)
        }

        // 删除部分下载的文件
        val file = File(task.savePath, task.fileName)
        if (file.exists()) {
            file.delete()
        }
    }

    // 删除任务
    suspend fun deleteTask(taskId: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        // 如果正在下载，先取消
        if (task.status == DownloadStatus.DOWNLOADING || task.status == DownloadStatus.CONNECTING ||
            task.status == DownloadStatus.PENDING || task.status == DownloadStatus.WAITING_FOR_NETWORK) {
            cancelDownload(taskId)
        }

        // 从数据库删除
        downloadTaskDao.deleteTask(task)
    }

    // 获取任务
    suspend fun getTaskById(taskId: String): DownloadTask? {
        return downloadTaskDao.getTaskById(taskId)
    }

    // 更新任务状态
    suspend fun updateTaskStatus(taskId: String, status: DownloadStatus) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        if (task.status != status) {
            val updatedTask = task.copy(
                status = status,
                lastUpdated = System.currentTimeMillis()
            )

            downloadTaskDao.updateTask(updatedTask)
            _downloadEvents.emit(DownloadEvent.StatusChanged(taskId, status))
        }
    }

    // 更新任务错误信息
    suspend fun updateTaskError(taskId: String, errorMessage: String) {
        val task = downloadTaskDao.getTaskById(taskId) ?: return

        val updatedTask = task.copy(
            errorCount = task.errorCount + 1,
            errorMessage = errorMessage,
            lastUpdated = System.currentTimeMillis()
        )

        downloadTaskDao.updateTask(updatedTask)
        _downloadEvents.emit(DownloadEvent.Error(taskId, errorMessage))
    }

    // 通知下载完成
    suspend fun notifyDownloadComplete(taskId: String, filePath: String) {
        _downloadEvents.emit(DownloadEvent.Complete(taskId, filePath))
    }

    // 执行文件下载
    suspend fun performDownload(task: DownloadTask, worker: DownloadWorker): File = withContext(Dispatchers.IO) {
        // 确保目录存在
        val saveDir = File(task.savePath)
        if (!saveDir.exists()) {
            saveDir.mkdirs()
        }

        val file = File(saveDir, task.fileName)
        var totalBytes = task.totalBytes
        var downloadedBytes = task.downloadedBytes

        // 检查文件是否已存在且有部分数据
        if (file.exists() && downloadedBytes > 0) {
            if (file.length() != downloadedBytes) {
                // 文件大小不一致，使用实际文件大小
                downloadedBytes = file.length()
            }
        } else if (downloadedBytes > 0) {
            // 文件不存在但下载记录不为0，重置下载记录
            downloadedBytes = 0
        }

        // 构建请求
        val requestBuilder = Request.Builder()
            .url(task.url)

        // 添加Range头以支持断点续传
        if (downloadedBytes > 0) {
            requestBuilder.addHeader("Range", "bytes=$downloadedBytes-")
        }

        val request = requestBuilder.build()

        // 执行请求
        okHttpClient.newCall(request).execute().use { response ->
            if (!response.isSuccessful) {
                throw IOException("HTTP error: ${response.code}")
            }

            val body = response.body ?: throw IOException("Empty response body")
            val contentLength = body.contentLength()

            // 确定总大小
            if (totalBytes <= 0 && contentLength > 0) {
                totalBytes = when {
                    response.code == 206 -> { // 断点续传
                        val contentRange = response.header("Content-Range")
                        if (contentRange != null) {
                            // 解析形如 "bytes 100-999/1000" 的Content-Range头
                            val rangeMatcher = Regex("bytes \\d+-\\d+/(\\d+)").find(contentRange)
                            rangeMatcher?.groupValues?.get(1)?.toLongOrNull() ?: (downloadedBytes + contentLength)
                        } else {
                            downloadedBytes + contentLength
                        }
                    }
                    else -> contentLength // 完整下载
                }

                // 更新任务总大小
                val updatedTask = task.copy(totalBytes = totalBytes)
                downloadTaskDao.updateTask(updatedTask)
            }

            // 准备输出流
            val outputStream = if (downloadedBytes > 0 && file.exists()) {
                FileOutputStream(file, true) // 断点续传，追加模式
            } else {
                FileOutputStream(file) // 从头下载，覆盖模式
            }

            outputStream.use { output ->
                val buffer = ByteArray(8192)
                val input = body.byteStream()
                var bytesRead: Int
                var lastProgressUpdate = 0L

                while (input.read(buffer).also { bytesRead = it } != -1) {
                    // 检查Worker是否已停止
                    if (worker.isStopped) {
                        throw InterruptedException("下载已停止")
                    }

                    // 检查网络状态
                    if (!networkMonitor.isNetworkAvailable()) {
                        throw IOException("网络连接已断开")
                    }

                    output.write(buffer, 0, bytesRead)
                    downloadedBytes += bytesRead

                    // 更新进度
                    val now = System.currentTimeMillis()
                    if (now - lastProgressUpdate > 500) { // 每500ms更新一次
                        lastProgressUpdate = now

                        val progress = if (totalBytes > 0) {
                            (downloadedBytes * 100 / totalBytes).toInt()
                        } else 0

                        // 更新数据库
                        downloadTaskDao.updateTaskProgress(task.id, downloadedBytes, now)

                        // 发送进度事件
                        _downloadEvents.emit(
                            DownloadEvent.Progress(
                                task.id,
                                progress,
                                downloadedBytes,
                                totalBytes
                            )
                        )

                        // 更新前台服务通知
                        worker.setForeground(
                            worker.createForegroundInfo(
                                "下载: ${task.fileName}",
                                progress
                            )
                        )
                    }
                }
            }
        }

        // 返回下载完成的文件
        file
    }

    // 网络变为可用
    override fun onNetworkAvailable() {
        downloadScope.launch {
            // 恢复所有等待网络的任务
            downloadTaskDao.getTasksByStatus(DownloadStatus.WAITING_FOR_NETWORK).first().forEach { task ->
                resumeDownload(task.id)
            }
        }
    }

    // 网络变为不可用
    override fun onNetworkUnavailable() {
        downloadScope.launch {
            // 暂停所有正在下载的任务
            downloadTaskDao.getTasksByStatuses(
                listOf(DownloadStatus.DOWNLOADING, DownloadStatus.CONNECTING, DownloadStatus.PENDING)
            ).first().forEach { task ->
                // 标记为等待网络
                updateTaskStatus(task.id, DownloadStatus.WAITING_FOR_NETWORK)

                // 取消当前工作
                DownloadWorker.cancelDownload(context, task.id)
            }
        }
    }

    // 应用进入前台
    fun onAppForeground() {
        downloadScope.launch {
            // 检查并恢复可能被系统暂停的任务
            downloadTaskDao.getTasksByStatus(DownloadStatus.PAUSED).first().forEach { task ->
                // 如果任务是因为系统限制被暂停的（而非用户主动暂停），则尝试恢复
                // 这里可以通过某些标记或时间戳来判断
                if (task.errorMessage?.contains("系统限制") == true ||
                    System.currentTimeMillis() - task.lastUpdated > 30000) { // 30秒内未更新

                    if (networkMonitor.isNetworkAvailable()) {
                        resumeDownload(task.id)
                    } else {
                        updateTaskStatus(task.id, DownloadStatus.WAITING_FOR_NETWORK)
                    }
                }
            }
        }
    }

    // 应用进入后台
    fun onAppBackground() {
        // 应用进入后台时，不需要特别处理，
        // 因为我们使用WorkManager来执行下载任务，
        // 这允许任务在后台继续执行
    }

    // 释放资源
    fun release() {
        networkMonitor.removeListener(this)
        networkMonitor.stopMonitoring()
        downloadScope.cancel()
    }
}

使用方法

下面是如何在应用中使用这个下载管理器的完整示例：

// 在Application类中初始化
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // 注册生命周期观察者，用于监控应用前台/后台状态
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver(this))
    }
}

// 在Activity或Fragment中使用下载管理器
class DownloadActivity : AppCompatActivity() {

    private val downloader by lazy {
        WorkManagerNetworkDownloader.getInstance(applicationContext)
    }

    private var downloadEventJob: Job? = null
    private var adaptor: DownloadAdaptor? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_download)

        // 初始化RecyclerView适配器
        val recyclerView = findViewById<RecyclerView>(R.id.recyclerViewDownloads)
        adaptor = DownloadAdaptor(emptyList()) { task, action ->
            handleAction(task, action)
        }
        recyclerView.adapter = adaptor
        recyclerView.layoutManager = LinearLayoutManager(this)

        // 监听下载事件
        downloadEventJob = lifecycleScope.launch {
            downloader.downloadEvents.collect { event ->
                when (event) {
                    is DownloadEvent.Progress -> {
                        adaptor?.updateProgress(event.taskId, event.progress)
                    }
                    is DownloadEvent.StatusChanged -> {
                        // 刷新UI或显示通知
                        showToast("任务${event.taskId}状态变更: ${event.status}")
                    }
                    is DownloadEvent.Complete -> {
                        showToast("下载完成: ${event.filePath}")
                    }
                    is DownloadEvent.Error -> {
                        showToast("下载错误: ${event.error}")
                    }
                }
            }
        }

        // 观察下载任务列表
        lifecycleScope.launch {
            downloader.allTasks.collect { tasks ->
                adaptor?.updateTasks(tasks)
            }
        }

        // 添加下载按钮点击事件
        findViewById<Button>(R.id.btnAddDownload).setOnClickListener {
            showAddDownloadDialog()
        }
    }

    private fun showAddDownloadDialog() {
        val urlEditText = EditText(this).apply {
            hint = "请输入下载URL"
            setText("https://example.com/large-file.zip")
        }

        AlertDialog.Builder(this)
            .setTitle("添加下载")
            .setView(urlEditText)
            .setPositiveButton("下载") { _, _ ->
                val url = urlEditText.text.toString()
                if (url.isNotEmpty()) {
                    addDownload(url)
                }
            }
            .setNegativeButton("取消", null)
            .show()
    }

    private fun addDownload(url: String) {
        lifecycleScope.launch {
            try {
                val fileName = url.substringAfterLast("/")
                val savePath = getExternalFilesDir(null)?.absolutePath ?: filesDir.absolutePath

                val taskId = downloader.addDownloadTask(
                    url = url,
                    fileName = fileName,
                    savePath = savePath
                )

                showToast("下载任务已添加")
            } catch (e: Exception) {
                showToast("添加下载失败: ${e.message}")
            }
        }
    }

    private fun handleAction(task: DownloadTask, action: String) {
        lifecycleScope.launch {
            when (action) {
                "pause" -> downloader.pauseDownload(task.id)
                "resume" -> downloader.resumeDownload(task.id)
                "cancel" -> downloader.cancelDownload(task.id)
                "delete" -> downloader.deleteTask(task.id)
            }
        }
    }

    private fun showToast(message: String) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }

    override fun onDestroy() {
        super.onDestroy()
        downloadEventJob?.cancel()
    }