2026-02-17发表4 分钟读完 (大约576个字)

📱 各手机品牌后台联网与耗电策略设置引导

为确保 App 能在后台下载，避免被系统过度节电限制，请根据您手机的品牌，按以下步骤手动设置。

🔹 小米（MIUI 系统）

设置路径：
长按 App 桌面图标 → 应用信息 → 电量消耗 → 省电策略 → 不限制

说明：
将“省电策略”设置为“不限制”，可避免系统在后台自动关闭 APP 网络或进程。

🔹 华为（HarmonyOS / EMUI 系统）

设置路径：

打开设置 → 电池 → 性能模式
打开设置 → 电池 → 更多电池设置 → 休眠时始终保持网络连接
打开设置 → 应用和服务 → 应用管理 → App → 耗电详情 → 启动管理 → 允许后台活动

若“允许后台活动”选项无法开启，请先关闭“自动管理”开关。

说明：
开启性能模式并保持休眠时网络连接，可确保应用后台数据传输稳定。

🔹 OPPO & 一加（ColorOS 系统）

设置路径：
长按 App 桌面图标 → 应用详情 → 耗电管理 → 完全允许后台行为

说明：
“完全允许后台行为”可确保 APP 在锁屏或后台状态下依然能正常联网。

🔹 VIVO（OriginOS / FuntouchOS 系统）

设置路径：
设置 → 电池 → 后台耗电管理 → App → 允许后台高耗电

说明：
开启“允许后台高耗电”，防止系统限制 APP 的网络请求或后台播放。

🔹 iQOO（OriginOS / FuntouchOS 系统）

设置路径：
长按 App 桌面图标 → 应用信息 → 电量 → 后台耗电管理 → 允许后台高耗电

说明：
允许后台高耗电可避免系统在后台自动冻结应用，确保后台下载视频稳定。

✅ 温馨提示：

以上设置仅影响 App 的后台运行权限，不会对其他应用造成影响。
若您的系统版本或界面略有差异，请根据相近选项进行操作。

2026-02-17发表1 分钟读完 (大约120个字)

Android Studio Settings

主题和字体设置

VMOptions 设置

Keymap 设置

AS 个性化设置

Appearance & Behavior > System Settings > Startup/Shutdown > Reopen last project on startup 当你下次启动 Android Studio 时，它将不会自动打开你上次关闭的项目，而是让你选择或创建一个新的项目。
Editor > General > Move code fragments with drag-and-drop 禁用 Android Studio 中的代码拖拽功能
Editor > UI Tools > Edit View Mode 设置 Resource 和 Kotlin Preview 的默认打开样式：Code, Split, Design

2025-09-18发表3 分钟读完 (大约492个字)

RecyclerView上滑显示【回到底部】按钮

在 RecyclerView 中的 onScrolled 方法中实现回到底部按钮的显示逻辑。


private var isUserScrolling = false
private var hasScrolledUp = false // 是否向上滚动
private var lastScrollOffset = 0 // 上次滚动位置
private var isScrollingDown = false // 是否向下滚动
private var totalScrollDownDistance = 0 // 累计向下滚动距离

recyclerView.apply {
    this.layoutManager = layoutManager
    this.adapter = adapter

    itemAnimator = null

    // 添加滚动监听，检测用户手动滚动
    addOnScrollListener(object : RecyclerView.OnScrollListener() {
        override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) {
            super.onScrollStateChanged(recyclerView, newState)
            Log.d(TAG, "onScrollStateChanged: newState=$newState")
            isUserScrolling = newState != RecyclerView.SCROLL_STATE_IDLE
        }

        override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
            super.onScrolled(recyclerView, dx, dy)
            handleScrollChanged(dy)
        }
    })
}

scrollToEndBtn.setOnClickListener {
    val itemCount = adapter.itemCount
    if (itemCount > 0) {
        recyclerView.smoothScrollToPosition(itemCount - 1)
    }
}

1. 累计下滑距离超过200像素，出现【回到底部】按钮

✅ 显示条件：

用户向下滚动，通过 dy 参数检测滚动方向（正值=向下，负值=向上）
累计下滑距离超过200像素
最后2条Item不可见

/**
 * 处理滚动变化
 */
private fun handleScrollChanged(dy: Int) {
    val currentScrollOffset = recyclerView.computeVerticalScrollOffset()

    // 检测滚动方向
    if (dy > 0) {
        // 向下滚动 (正值表示向下)
        isScrollingDown = true
        totalScrollDownDistance += dy
    } else if (dy < 0) {
        // 向上滚动 (负值表示向上)
        isScrollingDown = false
        // 重置累计向下滚动距离
        totalScrollDownDistance = 0
    }

    // 检查最后2条Item是否可见
    val itemCount = adapter.itemCount
    val lastVisiblePosition = layoutManager.findLastVisibleItemPosition()
    val isNearBottom = itemCount > 2 && lastVisiblePosition >= itemCount - 2

    // 当向下滚动累计超过200时显示按钮，但如果最后2条Item可见则隐藏
    val shouldShow = isScrollingDown && totalScrollDownDistance > 200 && !isNearBottom

    if (shouldShow != hasScrolledUp) {
        hasScrolledUp = shouldShow
        scrollToEndBtn.isVisible = shouldShow
    }

    lastScrollOffset = currentScrollOffset
}

2. 底部不可见高度大于600像素，出现【回到底部】按钮

✅ 显示条件：

底部不可见高度大于600像素

/**
 * 当页面底部不可见高度大于600像素，出现该btn
 */
private fun handleScrollChanged() {
    // 检查底部不可见内容高度
    val scrollRange = recyclerView.computeVerticalScrollRange()     // 总内容高度
    val scrollExtent = recyclerView.computeVerticalScrollExtent()   // 可见区域高度
    val scrollOffset = recyclerView.computeVerticalScrollOffset()   // 当前滚动位置
    val bottomInvisibleHeight = scrollRange - scrollExtent - scrollOffset // 底部不可见高度
    val shouldShow = bottomInvisibleHeight >= 600             // 是否接近底部

    if (shouldShow != hasScrolledUp) {
        hasScrolledUp = shouldShow
        scrollToEndBtn.isVisible = shouldShow
    }
}

2025-04-12发表8 分钟读完 (大约1254个字)

在 Windows 上调试 Android TV 并模拟方向键和返回键的操作，可以通过以下工具和方法实现。这些工具支持通过 ADB（Android Debug Bridge）发送按键事件，从而模拟遥控器操作。

1. 使用 ADB 命令行

ADB 是调试 Android 设备的核心工具，您可以直接通过命令行发送按键事件来模拟方向键和返回键。

步骤：

安装 ADB 工具：
- 下载并安装 Platform Tools（包含 ADB 工具）。
- 解压后将 adb.exe 所在目录添加到系统的环境变量中，方便全局调用。
连接 Android TV：
- 确保 Android TV 和电脑处于同一局域网。
- 在 Android TV 上启用开发者选项，并开启“USB 调试”或“网络调试”。
- 使用以下命令连接设备：
  1
  adb connect <TV_IP>:5555
  示例：
  1
  adb connect 192.168.1.100:5555
发送按键事件：
使用以下命令模拟方向键和返回键：
- 返回键（KEYCODE_BACK）：
  1
  adb shell input keyevent 4
- 方向键上（KEYCODE_DPAD_UP）：
  1
  adb shell input keyevent 19
- 方向键下（KEYCODE_DPAD_DOWN）：
  1
  adb shell input keyevent 20
- 方向键左（KEYCODE_DPAD_LEFT）：
  1
  adb shell input keyevent 21
- 方向键右（KEYCODE_DPAD_RIGHT）：
  1
  adb shell input keyevent 22
- 确定键（KEYCODE_ENTER）：
  1
  adb shell input keyevent 23

优点：

免费且无需额外工具。
支持高度定制化。

缺点：

需要手动输入命令，效率较低。

2. 使用 Scrcpy

Scrcpy 是一款开源的 Android 屏幕投射和控制工具，支持通过鼠标或键盘模拟 Android TV 的操作。

步骤：

下载 Scrcpy：
- 前往 Scrcpy GitHub 页面下载最新版本。
- 解压后运行 scrcpy.exe。
连接 Android TV：
- 同样需要启用开发者选项和网络调试。
- 使用以下命令启动 Scrcpy：
  1
  scrcpy --tcpip=<TV_IP>:5555
模拟按键：
- 在 Scrcpy 窗口中，使用键盘的方向键即可模拟 Android TV 的方向键操作。
- 按下键盘上的 Esc 键可模拟返回键。

优点：

提供屏幕投射功能，便于观察操作效果。
支持鼠标点击和键盘按键模拟。

缺点：

需要一定的学习成本。
不适合批量自动化操作。

3. 使用 ADB Remote ATV（Windows 版）

ADB Remote ATV 是一款专为 Android TV 设计的虚拟遥控器工具，支持通过 ADB 模拟方向键、返回键等操作。

步骤：

下载工具：
- 前往 GitHub 项目页面或 Gitee 项目页面下载最新版本。
配置 ADB 连接：
- 打开工具并输入 Android TV 的 IP 地址。
- 点击“连接”按钮。
模拟按键：
- 界面上提供了虚拟的方向键、返回键和其他按键，点击即可发送对应的 ADB 命令。

优点：

图形化界面，操作简单直观。
支持多种按键模拟。

缺点：

功能相对基础，不适合复杂场景。

4. 使用 AutoHotkey（AHK）脚本

如果您希望在 Windows 上创建一个自定义的快捷键映射工具，可以使用 AutoHotkey 编写脚本。

步骤：

安装 AutoHotkey：
- 前往 AutoHotkey 官网下载并安装。

编写脚本：
创建一个新的 .ahk 文件，内容如下：

; 模拟方向键
Up::Run, adb shell input keyevent 19
Down::Run, adb shell input keyevent 20
Left::Run, adb shell input keyevent 21
Right::Run, adb shell input keyevent 22

; 模拟返回键
Esc::Run, adb shell input keyevent 4

; 模拟确定键
Enter::Run, adb shell input keyevent 23

运行脚本：
- 双击 .ahk 文件运行脚本。
- 按下键盘上的方向键或 Esc 键即可发送对应的 ADB 命令。

优点：

高度灵活，可根据需求自定义快捷键。
支持一键触发复杂操作。

缺点：

需要一定的脚本编写能力。

5. 使用 Total Control

Total Control 是一款商业化的 Android 控制工具，支持通过 PC 模拟 Android TV 的各种操作。

特点：

支持多设备管理。
提供虚拟遥控器功能，可模拟方向键和返回键。
支持自动化测试和脚本录制。

下载地址：

官网：https://www.sigma-rt.com/

优点：

功能强大，适合专业开发和测试。
提供图形化界面。

缺点：

商业软件，可能需要付费。

总结

根据您的需求，推荐以下选择：

简单易用：使用 ADB Remote ATV 或 Scrcpy。
灵活性高：使用 ADB 命令行 或 AutoHotkey 脚本。
专业工具：选择 Total Control。

如果只是偶尔调试，建议从 ADB 命令行或 Scrcpy 开始；如果需要长期使用，可以考虑更专业的工具。

2025-04-12发表18 分钟读完 (大约2738个字)

需要扩展框架以支持M3U8文件下载。M3U8是HTTP Live Streaming (HLS)协议使用的文件格式，是一种用于流媒体的文件列表格式。

M3U8文件下载的特点：

M3U8文件本身是一个索引文件，包含了多个.ts分片文件的URL
需要先下载M3U8文件，解析其中的内容，获取所有的分片URL
然后依次或并行下载所有的.ts分片
最后将所有分片合并成一个完整的媒体文件

我需要设计以下内容：

M3U8文件解析器，用于解析M3U8文件格式并提取分片URL
分片下载管理器，用于管理所有分片的下载状态
分片合并器，用于将所有分片合并成完整媒体文件

我会基于之前设计的下载框架，扩展一个专门用于M3U8下载的功能模块。

扩展下载框架，支持M3U8文件下载

下面是针对M3U8文件下载的功能扩展，可以集成到之前的下载框架中：

// M3U8DownloadManager.kt

import kotlinx.coroutines.*
import okhttp3.*
import okio.buffer
import okio.sink
import okio.source
import java.io.*
import java.util.concurrent.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import java.util.regex.Pattern
import java.net.URL

/**
 * M3U8文件解析器
 */
class M3U8Parser {
    // M3U8文件信息
    data class M3U8Info(
        val masterUrl: String,             // 主M3U8 URL
        val baseUrl: String,               // 基础URL
        val duration: Float = 0f,          // 总时长(秒)
        val segmentList: List<M3U8Segment> // 分片列表
    )
    
    // 分片信息
    data class M3U8Segment(
        val url: String,         // 分片URL
        val duration: Float,     // 分片时长(秒)
        val index: Int,          // 分片索引
        var tsFilePath: String = "" // 本地保存路径
    )
    
    // 解析M3U8文件
    suspend fun parse(url: String, client: OkHttpClient): M3U8Info = withContext(Dispatchers.IO) {
        // 发送请求获取M3U8内容
        val request = Request.Builder()
            .url(url)
            .build()
            
        val response = client.newCall(request).execute()
        if (!response.isSuccessful) {
            throw IOException("Failed to fetch M3U8 file: ${response.code}")
        }
        
        val content = response.body?.string() ?: throw IOException("Empty M3U8 content")
        
        // 判断是否是主播放列表
        if (content.contains("#EXT-X-STREAM-INF")) {
            return@withContext parseMainPlaylist(url, content, client)
        } else {
            return@withContext parseMediaPlaylist(url, content)
        }
    }
    
    // 解析主播放列表
    private suspend fun parseMainPlaylist(masterUrl: String, content: String, client: OkHttpClient): M3U8Info = withContext(Dispatchers.IO) {
        // 提取带宽最高的子播放列表
        val lines = content.split("\n")
        var maxBandwidth = 0
        var selectedUrl = ""
        
        for (i in lines.indices) {
            val line = lines[i]
            if (line.startsWith("#EXT-X-STREAM-INF")) {
                // 提取带宽参数
                val bandwidthPattern = Pattern.compile("BANDWIDTH=(\\d+)")
                val matcher = bandwidthPattern.matcher(line)
                if (matcher.find()) {
                    val bandwidth = matcher.group(1).toInt()
                    if (bandwidth > maxBandwidth) {
                        maxBandwidth = bandwidth
                        // 下一行应该是URL
                        if (i + 1 < lines.size) {
                            val urlLine = lines[i + 1].trim()
                            if (!urlLine.startsWith("#")) {
                                selectedUrl = urlLine
                            }
                        }
                    }
                }
            }
        }
        
        // 如果URL是相对路径，转换为完整URL
        val fullUrl = if (selectedUrl.startsWith("http")) {
            selectedUrl
        } else {
            val baseUrl = URL(masterUrl)
            val path = if (selectedUrl.startsWith("/")) {
                selectedUrl
            } else {
                val masterPath = baseUrl.path
                val lastSlash = masterPath.lastIndexOf('/')
                if (lastSlash != -1) {
                    masterPath.substring(0, lastSlash + 1) + selectedUrl
                } else {
                    "/$selectedUrl"
                }
            }
            URL(baseUrl.protocol, baseUrl.host, baseUrl.port, path).toString()
        }
        
        // 解析子播放列表
        return@withContext parse(fullUrl, client)
    }
    
    // 解析媒体播放列表
    private fun parseMediaPlaylist(url: String, content: String): M3U8Info {
        val lines = content.split("\n")
        val segments = mutableListOf<M3U8Segment>()
        var totalDuration = 0f
        var segmentDuration = 0f
        var segmentIndex = 0
        var isFirstSegment = true
        
        // 提取基础URL
        val baseUrl = getBaseUrl(url)
        
        for (line in lines) {
            val trimmedLine = line.trim()
            
            // 提取片段时长
            if (trimmedLine.startsWith("#EXTINF:")) {
                val durationText = trimmedLine.substring(8).split(",")[0]
                segmentDuration = durationText.toFloat()
                isFirstSegment = false
                continue
            }
            
            // 提取片段URL
            if (!trimmedLine.startsWith("#") && trimmedLine.isNotEmpty() && !isFirstSegment) {
                // 构建完整URL
                val segmentUrl = if (trimmedLine.startsWith("http")) {
                    trimmedLine
                } else {
                    if (trimmedLine.startsWith("/")) {
                        // 绝对路径
                        val urlObj = URL(url)
                        URL(urlObj.protocol, urlObj.host, urlObj.port, trimmedLine).toString()
                    } else {
                        // 相对路径
                        "$baseUrl$trimmedLine"
                    }
                }
                
                segments.add(M3U8Segment(segmentUrl, segmentDuration, segmentIndex++))
                totalDuration += segmentDuration
            }
        }
        
        return M3U8Info(url, baseUrl, totalDuration, segments)
    }
    
    // 获取基础URL
    private fun getBaseUrl(url: String): String {
        val lastSlash = url.lastIndexOf('/')
        return if (lastSlash != -1) {
            url.substring(0, lastSlash + 1)
        } else {
            "$url/"
        }
    }
}

/**
 * M3U8下载管理器
 */
class M3U8DownloadManager {
    private val client = OkHttpClient.Builder()
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .build()
        
    private val downloadScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    private val m3u8Parser = M3U8Parser()
    private val downloadManager = DownloadManager.getInstance()
    
    // 下载状态
    enum class M3U8DownloadStatus {
        IDLE, PARSING, DOWNLOADING, MERGING, COMPLETED, FAILED, CANCELED
    }
    
    // M3U8下载监听器
    interface M3U8DownloadListener {
        fun onParsingProgress(url: String, progress: Int)
        fun onDownloadProgress(url: String, progress: Int, downloadedSegments: Int, totalSegments: Int)
        fun onMergingProgress(url: String, progress: Int)
        fun onStatusChanged(url: String, status: M3U8DownloadStatus)
        fun onSuccess(url: String, filePath: String)
        fun onFailed(url: String, e: Exception)
    }
    
    // M3U8下载任务
    data class M3U8DownloadTask(
        val url: String,
        val savePath: String,
        val fileName: String,
        var status: M3U8DownloadStatus = M3U8DownloadStatus.IDLE,
        var m3u8Info: M3U8Parser.M3U8Info? = null,
        var downloadedSegments: AtomicInteger = AtomicInteger(0),
        var mergeProgress: AtomicInteger = AtomicInteger(0)
    )
    
    private val downloadTasks = ConcurrentHashMap<String, M3U8DownloadTask>()
    private val listeners = ConcurrentHashMap<String, MutableList<M3U8DownloadListener>>()
    private val activeDownloads = AtomicInteger(0)
    private val maxConcurrentDownloads = 3
    
    // 添加下载任务
    fun addTask(url: String, savePath: String, fileName: String): M3U8DownloadTask {
        val taskId = url.hashCode().toString()
        
        return downloadTasks.getOrPut(taskId) {
            // 创建保存目录
            val saveDir = File(savePath)
            if (!saveDir.exists()) {
                saveDir.mkdirs()
            }
            
            // 创建临时目录
            val tempDir = File(savePath, ".temp_$fileName")
            if (!tempDir.exists()) {
                tempDir.mkdirs()
            }
            
            M3U8DownloadTask(url, savePath, fileName)
        }
    }
    
    // 添加监听器
    fun addListener(url: String, listener: M3U8DownloadListener) {
        val taskId = url.hashCode().toString()
        val taskListeners = listeners.getOrPut(taskId) { mutableListOf() }
        taskListeners.add(listener)
    }
    
    // 移除监听器
    fun removeListener(url: String, listener: M3U8DownloadListener) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.remove(listener)
    }
    
    // 开始下载
    fun startDownload(url: String) {
        val taskId = url.hashCode().toString()
        val task = downloadTasks[taskId] ?: return
        
        if (task.status != M3U8DownloadStatus.IDLE && 
            task.status != M3U8DownloadStatus.FAILED) {
            return
        }
        
        // 修改状态为解析中
        task.status = M3U8DownloadStatus.PARSING
        notifyStatusChanged(task.url, task.status)
        
        downloadScope.launch {
            try {
                // 1. 解析M3U8文件
                notifyParsingProgress(task.url, 0)
                val m3u8Info = m3u8Parser.parse(task.url, client)
                task.m3u8Info = m3u8Info
                notifyParsingProgress(task.url, 100)
                
                // 2. 准备下载分片
                task.status = M3U8DownloadStatus.DOWNLOADING
                notifyStatusChanged(task.url, task.status)
                
                // 重置计数器
                task.downloadedSegments.set(0)
                
                // 3. 下载所有分片
                val tempDir = File(task.savePath, ".temp_${task.fileName}")
                downloadAllSegments(task, m3u8Info, tempDir.absolutePath)
                
                // 4. 合并分片
                task.status = M3U8DownloadStatus.MERGING
                notifyStatusChanged(task.url, task.status)
                task.mergeProgress.set(0)
                
                mergeSegments(task, m3u8Info, tempDir.absolutePath)
                
                // 5. 完成
                task.status = M3U8DownloadStatus.COMPLETED
                notifyStatusChanged(task.url, task.status)
                
                // 6. 清理临时文件
                cleanupTempFiles(tempDir)
                
                // 7. 通知成功
                val outputFilePath = File(task.savePath, task.fileName).absolutePath
                notifySuccess(task.url, outputFilePath)
                
            } catch (e: Exception) {
                if (task.status != M3U8DownloadStatus.CANCELED) {
                    task.status = M3U8DownloadStatus.FAILED
                    notifyStatusChanged(task.url, task.status)
                    notifyFailed(task.url, e)
                }
            }
        }
    }
    
    // 下载所有分片
    private suspend fun downloadAllSegments(
        task: M3U8DownloadTask, 
        m3u8Info: M3U8Parser.M3U8Info, 
        tempDirPath: String
    ) = withContext(Dispatchers.IO) {
        val totalSegments = m3u8Info.segmentList.size
        val segmentJobs = mutableListOf<Deferred<Boolean>>()
        val semaphore = Semaphore(20) // 限制同时下载的分片数
        
        for (segment in m3u8Info.segmentList) {
            val segmentFile = File(tempDirPath, "segment_${segment.index}.ts")
            segment.tsFilePath = segmentFile.absolutePath
            
            // 如果分片已存在且大小大于0，则跳过
            if (segmentFile.exists() && segmentFile.length() > 0) {
                task.downloadedSegments.incrementAndGet()
                val progress = (task.downloadedSegments.get() * 100 / totalSegments)
                notifyDownloadProgress(task.url, progress, task.downloadedSegments.get(), totalSegments)
                continue
            }
            
            // 使用信号量限制并发
            semaphore.acquire()
            
            val job = downloadScope.async {
                try {
                    // 下载分片
                    val request = Request.Builder()
                        .url(segment.url)
                        .build()
                        
                    client.newCall(request).execute().use { response ->
                        if (!response.isSuccessful) {
                            throw IOException("Failed to download segment: ${response.code}")
                        }
                        
                        val responseBody = response.body ?: throw IOException("Empty response body")
                        
                        // 保存分片
                        segmentFile.sink().buffer().use { sink ->
                            responseBody.source().use { source ->
                                sink.writeAll(source)
                            }
                        }
                        
                        // 更新进度
                        val downloaded = task.downloadedSegments.incrementAndGet()
                        val progress = (downloaded * 100 / totalSegments)
                        notifyDownloadProgress(task.url, progress, downloaded, totalSegments)
                        
                        return@async true
                    }
                } catch (e: Exception) {
                    return@async false
                } finally {
                    semaphore.release()
                }
            }
            
            segmentJobs.add(job)
        }
        
        // 等待所有分片下载完成
        val results = segmentJobs.awaitAll()
        
        // 检查是否有失败的分片
        if (results.contains(false)) {
            throw IOException("Some segments failed to download")
        }
    }
    
    // 合并分片
    private suspend fun mergeSegments(
        task: M3U8DownloadTask, 
        m3u8Info: M3U8Parser.M3U8Info, 
        tempDirPath: String
    ) = withContext(Dispatchers.IO) {
        val segments = m3u8Info.segmentList
        val totalSegments = segments.size
        val outputFile = File(task.savePath, task.fileName)
        
        // 如果是mp4文件，需要先合并为ts，再转换为mp4
        val isMp4 = task.fileName.endsWith(".mp4", ignoreCase = true)
        val tempOutputFile = if (isMp4) {
            File(task.savePath, "${task.fileName}.ts")
        } else {
            outputFile
        }
        
        // 创建输出流
        val outputStream = FileOutputStream(tempOutputFile)
        
        try {
            // 依次写入每个分片
            for ((index, segment) in segments.withIndex()) {
                val segmentFile = File(segment.tsFilePath)
                if (!segmentFile.exists()) {
                    throw IOException("Segment file not found: ${segment.tsFilePath}")
                }
                
                // 写入分片数据
                segmentFile.source().buffer().use { source ->
                    outputStream.sink().buffer().use { sink ->
                        sink.writeAll(source)
                    }
                }
                
                // 更新进度
                val progress = ((index + 1) * 100 / totalSegments)
                task.mergeProgress.set(progress)
                notifyMergingProgress(task.url, progress)
            }
        } finally {
            outputStream.close()
        }
        
        // 如果是mp4，需要进行格式转换
        if (isMp4) {
            // 这里使用简单文件重命名代替格式转换
            // 实际应用中，应该使用FFmpeg等工具进行正确的格式转换
            if (tempOutputFile.exists()) {
                tempOutputFile.renameTo(outputFile)
            }
        }
    }
    
    // 清理临时文件
    private fun cleanupTempFiles(tempDir: File) {
        if (tempDir.exists()) {
            tempDir.listFiles()?.forEach { it.delete() }
            tempDir.delete()
        }
    }
    
    // 取消下载
    fun cancelDownload(url: String) {
        val taskId = url.hashCode().toString()
        val task = downloadTasks[taskId] ?: return
        
        task.status = M3U8DownloadStatus.CANCELED
        notifyStatusChanged(task.url, task.status)
        
        // 清理临时目录
        val tempDir = File(task.savePath, ".temp_${task.fileName}")
        cleanupTempFiles(tempDir)
    }
    
    // 获取下载任务
    fun getTask(url: String): M3U8DownloadTask? {
        val taskId = url.hashCode().toString()
        return downloadTasks[taskId]
    }
    
    // 通知解析进度
    private fun notifyParsingProgress(url: String, progress: Int) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onParsingProgress(url, progress)
        }
    }
    
    // 通知下载进度
    private fun notifyDownloadProgress(url: String, progress: Int, downloadedSegments: Int, totalSegments: Int) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onDownloadProgress(url, progress, downloadedSegments, totalSegments)
        }
    }
    
    // 通知合并进度
    private fun notifyMergingProgress(url: String, progress: Int) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onMergingProgress(url, progress)
        }
    }
    
    // 通知状态变化
    private fun notifyStatusChanged(url: String, status: M3U8DownloadStatus) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onStatusChanged(url, status)
        }
    }
    
    // 通知下载成功
    private fun notifySuccess(url: String, filePath: String) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onSuccess(url, filePath)
        }
    }
    
    // 通知下载失败
    private fun notifyFailed(url: String, e: Exception) {
        val taskId = url.hashCode().toString()
        listeners[taskId]?.forEach { listener ->
            listener.onFailed(url, e)
        }
    }
    
    // 释放资源
    fun release() {
        downloadScope.cancel()
        downloadTasks.clear()
        listeners.clear()
    }
}

使用示例

以下是如何使用M3U8下载功能的示例代码：

// M3U8下载示例

fun main() {
    // 创建M3U8下载管理器
    val m3u8DownloadManager = M3U8DownloadManager()
    
    // 添加下载任务
    val task = m3u8DownloadManager.addTask(
        url = "https://example.com/video.m3u8",
        savePath = "/downloads",
        fileName = "video.mp4"  // 可以是.mp4或.ts格式
    )
    
    // 添加下载监听器
    m3u8DownloadManager.addListener(task.url, object : M3U8DownloadManager.M3U8DownloadListener {
        override fun onParsingProgress(url: String, progress: Int) {
            println("解析进度: $progress%")
        }
        
        override fun onDownloadProgress(url: String, progress: Int, downloadedSegments: Int, totalSegments: Int) {
            println("下载进度: $progress%, 已下载分片: $downloadedSegments/$totalSegments")
        }
        
        override fun onMergingProgress(url: String, progress: Int) {
            println("合并进度: $progress%")
        }
        
        override fun onStatusChanged(url: String, status: M3U8DownloadManager.M3U8DownloadStatus) {
            println("状态变更: $status")
        }
        
        override fun onSuccess(url: String, filePath: String) {
            println("下载成功: $filePath")
        }
        
        override fun onFailed(url: String, e: Exception) {
            println("下载失败: ${e.message}")
        }
    })
    
    // 开始下载
    m3u8DownloadManager.startDownload(task.url)
    
    // 等待下载完成
    readLine()
    
    // 清理资源
    m3u8DownloadManager.release()
}

M3U8下载功能说明

M3U8文件解析
- 支持解析主播放列表和媒体播放列表
- 自动选择最高质量的流进行下载
- 处理相对路径和绝对路径的URL
分片下载
- 支持高并发分片下载
- 使用信号量控制并发数量
- 支持已下载分片检测，避免重复下载
下载进度
- 提供三个阶段的进度回调：解析进度、下载进度、合并进度
- 详细的状态变化通知
文件合并
- 按顺序合并所有TS分片
- 支持MP4格式输出（需配合实际工具进行格式转换）
- 自动清理临时文件
异常处理
- 完善的错误处理机制
- 支持取消下载操作
- 出错时自动清理临时文件

注意事项

关于格式转换：
本示例中的MP4格式转换仅做演示，实际应用中应该使用专业工具（如FFmpeg）进行正确的格式转换。
有关DRM保护：
一些M3U8流可能有DRM保护，需要额外的解密逻辑。您可以扩展此框架添加解密功能。
性能优化：
- 调整Semaphore的许可数量来控制并发下载量
- 可以根据网络状况动态调整并发数
- 对于大型视频，考虑增加磁盘缓冲区大小

希望这个M3U8下载框架能满足您的需求！您可以根据实际项目需要进一步扩展其功能。

2025-04-12发表24 分钟读完 (大约3637个字)

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

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

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

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

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

我需要提供一个综合的、能够工作的解决方案，结合 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()
    }