import 'dart:io'; import 'package:flutter/foundation.dart'; import '../../models/notice_item.dart'; import '../../models/run_task.dart'; import '../background_task/background_task.dart'; import '../background_task/background_task_scheduler.dart'; import '../background_task/generic_background_task.dart'; import '../distro_manager.dart'; import '../toolchain_service.dart'; /// 探测阶段(队列线性执行:入队 → 依赖检测 → 自动补全 → 执行探测 → 整理) enum ProbePhase { queued, checkingDependency, installingDependency, probing, finalizing } /// 一次探测涉及的模块引用(供 UI 建通知条目) @immutable class ProbeModuleRef { final String id; final String displayName; const ProbeModuleRef(this.id, this.displayName); @override bool operator ==(Object other) => other is ProbeModuleRef && other.id == id && other.displayName == displayName; @override int get hashCode => Object.hash(id, displayName); } /// 探测进度快照(队列线性执行:当前模块 + 队列全貌) @immutable class ProbeProgress { final ProbePhase phase; /// 本轮队列中的全部模块(含已完成/排队中) final List queue; /// 当前正在执行三动作的模块 final ProbeModuleRef? current; const ProbeProgress({ required this.phase, required this.queue, this.current, }); } /// 模块探测结果状态 enum ModuleProbeStatus { /// 成功(可能 0 个任务,但探测本身成功) ok, /// 探测失败(工具链缺失 / 依赖安装失败 / 执行失败 / 输出不可解析 / 超时) failed, /// 被用户取消 cancelled, /// 因整轮探测超出时间预算而被跳过(尚未开始执行) skippedByBudget, } /// 单个模块的探测结果(结构化,失败必须显式携带原因) @immutable class ModuleProbeResult { final String moduleId; final ModuleProbeStatus status; final List tasks; /// 失败分类(用于 l10n 文案),status != failed 时为 null final NoticeFailure? failure; /// 失败细节:缺失的工具名、stderr 末尾等(技术信息,允许原样展示) final String? failureDetail; const ModuleProbeResult._({ required this.moduleId, required this.status, this.tasks = const [], this.failure, this.failureDetail, }); const ModuleProbeResult.ok(String moduleId, List tasks) : this._(moduleId: moduleId, status: ModuleProbeStatus.ok, tasks: tasks); const ModuleProbeResult.failed( String moduleId, { required NoticeFailure failure, String? detail, }) : this._( moduleId: moduleId, status: ModuleProbeStatus.failed, failure: failure, failureDetail: detail, ); const ModuleProbeResult.cancelled(String moduleId) : this._(moduleId: moduleId, status: ModuleProbeStatus.cancelled); const ModuleProbeResult.skippedByBudget(String moduleId) : this._(moduleId: moduleId, status: ModuleProbeStatus.skippedByBudget); } /// 探测请求 @immutable class ProjectProbeRequest { final Directory projectDir; final String? currentFilePath; /// 当前真实选中的容器系统名(必需) final String systemName; /// 仅探测指定模块(用于"重新同步真实任务") final String? onlyModuleId; const ProjectProbeRequest({ required this.projectDir, required this.systemName, this.currentFilePath, this.onlyModuleId, }); } /// 探测报告:聚合所有模块结果 + 最终任务列表 @immutable class ProjectProbeReport { final String systemName; final List detectedTasks; final Map moduleResults; final DateTime finishedAt; /// 本轮队列涉及的模块总数(用于"已完成 X/Y 个模块"文案) final int totalModules; /// 是否因超出时间预算而中止 final bool abortedByBudget; const ProjectProbeReport({ required this.systemName, required this.detectedTasks, required this.moduleResults, required this.finishedAt, this.totalModules = 0, this.abortedByBudget = false, }); static ProjectProbeReport empty(String systemName) => ProjectProbeReport( systemName: systemName, detectedTasks: const [], moduleResults: const {}, finishedAt: DateTime.now(), ); /// 真正跑完(成功或失败)的模块数,不含被跳过/被取消的 int get completedModules => moduleResults.values .where((r) => r.status == ModuleProbeStatus.ok || r.status == ModuleProbeStatus.failed) .length; bool get hasFailure => moduleResults.values.any((r) => r.status == ModuleProbeStatus.failed); } /// 一次探测会话:承载进度、取消、缓存读写与容器执行能力。 /// /// 依赖能力(供模块的"依赖检测 / 自动补全"两个动作使用): /// * [isToolchainInstalled]:优先在宿主 rootfs 内快速判定,必要时回落到容器 `command -v`; /// * [installToolchains]:按发行版家族复用 [ToolchainService] 的安装命令, /// 带长超时、可取消、逐行回传输出(供弹窗显示安装进度)。 class ProjectProbe { /// 整轮探测的默认时间预算:超过后不再出队新模块(剩余模块标记为"预算跳过") static const Duration defaultBudget = Duration(minutes: 15); final ProjectProbeRequest request; final DistroManager distroManager; /// 本轮探测的时间预算 final Duration budget; /// 取消令牌(取消后容器内的子进程会被立即杀掉) final HeadlessCancelToken cancelToken; /// 进度(null 表示已结束) final ValueNotifier progress; /// 安装过程最后一行输出(供弹窗副标题显示安装进度) final ValueNotifier installLine; bool _disposed = false; DateTime? _deadline; ProjectProbe({ required this.request, required this.distroManager, this.budget = defaultBudget, HeadlessCancelToken? cancelToken, ValueNotifier? progress, ValueNotifier? installLine, }) : cancelToken = cancelToken ?? HeadlessCancelToken(), progress = progress ?? ValueNotifier(null), installLine = installLine ?? ValueNotifier(null); Directory get projectDir => request.projectDir; String? get currentFilePath => request.currentFilePath; String get systemName => request.systemName; String? get onlyModuleId => request.onlyModuleId; bool get isCancelled => cancelToken.isCancelled; bool get isDisposed => _disposed; /// 开始计时(由总调度在真正开跑时调用,排队/等待用户的时间不计入预算) void startBudget([Duration? override]) { _deadline = DateTime.now().add(override ?? budget); } /// 已耗时(未开始计时返回 Duration.zero) Duration get elapsed { final deadline = _deadline; if (deadline == null) return Duration.zero; final remaining = deadline.difference(DateTime.now()); final used = budget - remaining; return used.isNegative ? Duration.zero : used; } /// 是否已超出时间预算 bool get isBudgetExceeded { final deadline = _deadline; if (deadline == null) return false; return DateTime.now().isAfter(deadline); } void cancel() => cancelToken.cancel(); /// 在容器内静默执行命令(带取消支持 + 可选逐行输出) Future runHeadless( String command, { Duration timeout = const Duration(seconds: 90), void Function(String chunk)? onStdout, }) { return distroManager.runHeadlessCommand( systemName: systemName, workspacePath: projectDir.path, command: command, timeout: timeout, cancelToken: cancelToken, onStdout: onStdout, ); } /// 容器内是否存在指定二进制(无法确认且未被取消时返回 true,避免受限/单测环境误报缺失) Future hasCommand(String binary) async { if (isCancelled) return false; final result = await runHeadless( 'command -v $binary >/dev/null 2>&1 && echo CE_OK', timeout: const Duration(seconds: 20), ); if (isCancelled) return false; if (result == null) return true; return result.exitCode == 0 && result.stdout.toString().contains('CE_OK'); } /// 依赖是否已安装(优先宿主侧 rootfs 快速判定,失败再回落容器检查) Future isToolchainInstalled(ToolchainRequirement requirement) async { if (isCancelled) return false; try { final rootDir = await distroManager.getSystemRootDir(systemName); if (rootDir.existsSync()) { return ToolchainService.isToolInstalledInRootfs(rootDir, requirement.checkBinary); } } catch (_) { // 宿主信息不可用 -> 回落容器内检查 } return hasCommand(requirement.checkBinary); } /// 自动补全依赖:按发行版家族合成安装命令并在容器内执行 /// /// 队列是线性执行的,因此同一时刻只会有一次安装,天然不会与其它模块争抢包管理器锁。 /// 同一批缺失依赖合并成一条脚本执行(只取一次包管理器锁、只 update 一次)。 Future installToolchains(List toolchainKeys) async { if (isCancelled || _disposed || toolchainKeys.isEmpty) return false; final DistroFamily family; try { family = await distroManager.detectDistroFamily(systemName); } catch (_) { return false; } if (family == DistroFamily.unknown) return false; final commands = []; for (final key in toolchainKeys) { final requirement = ToolchainService.supportedTools[key]; final command = requirement?.getInstallCommand(family); if (command != null && command.trim().isNotEmpty) { commands.add(command); } } if (commands.isEmpty) return false; final script = commands.join(' && '); // 接入统一调度器:通过 TaskExecutionScope.packageManager 保证独占排他锁, // 不与用户同时触发的 LSP 组件安装/卸载冲突 final task = GenericBackgroundTask( id: 'probe:toolchains:${toolchainKeys.join('+')}', scope: TaskExecutionScope.packageManager, priority: TaskPriority.projectLifecycle, showNotice: false, // 模块探测自身已有专用的 ModulePhaseText 弹窗显示 runner: (taskContext) async { if (isCancelled || _disposed) return false; final result = await runHeadless( script, timeout: const Duration(minutes: 10), onStdout: (chunk) { final line = chunk.trim(); if (line.isNotEmpty) setInstallLine(line); }, ); return result != null && result.exitCode == 0; }, ); try { return await BackgroundTaskScheduler.instance.submit(task); } catch (_) { return false; } } /// 更新安装进度行(带释放保护,避免取消/释放后写入已 dispose 的 notifier) void setInstallLine(String? line) { if (_disposed) return; installLine.value = line; } void reportProgress(ProbeProgress value) { if (isCancelled || _disposed) return; progress.value = value; } /// 释放(幂等:取消与正常结束路径都可能调用) void dispose() { if (_disposed) return; _disposed = true; progress.dispose(); installLine.dispose(); } }