Files
LN-Code-Editor/lib/providers/run_provider.dart
T
2026-09-17 16:32:27 +08:00

671 lines
24 KiB
Dart
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import 'dart:async';
import 'package:flutter/foundation.dart';
import '../models/notice_item.dart';
import '../models/project_task_table.dart';
import '../models/run_task.dart';
import '../models/run_task_type.dart';
import '../services/distro_manager.dart';
import '../services/project_task_dispatcher.dart';
import '../services/project_modules/project_module.dart';
import '../services/project_modules/project_probe.dart';
import '../services/run_task_storage_service.dart';
import 'notice_center.dart';
/// 运行任务状态管理 Provider
///
/// 探测相关职责已收敛为"探测会话"模型:
/// * 每次探测创建一次 [ProjectProbe],进度通过 [probeProgress] 暴露给 UI;
/// * 每个模块对应一条通知([NoticeCenter]),并发模块 = 多条通知并存;
/// * 失败按 [ModuleProbeResult] 结构化上报,绝不返回硬编码兜底任务。
class RunProvider extends ChangeNotifier {
final RunTaskStorageService _storageService;
final ProjectTaskDispatcher _dispatcher;
final DistroManager _distroManager;
final NoticeCenter? _noticeCenter;
RunProvider({
RunTaskStorageService? storageService,
ProjectTaskDispatcher? dispatcher,
DistroManager? distroManager,
NoticeCenter? noticeCenter,
Duration? probeBudget,
}) : _storageService = storageService ?? RunTaskStorageService(),
_dispatcher = dispatcher ?? ProjectTaskDispatcher.instance,
_distroManager = distroManager ?? DistroManager(),
_noticeCenter = noticeCenter,
_probeBudget = probeBudget ?? ProjectProbe.defaultBudget;
/// 整轮探测的时间预算(超出后剩余模块跳过,并弹一条可关闭的提示)
final Duration _probeBudget;
/// 当前工程的系统任务内存表:**类型 → 任务数组**(哈希表)
///
/// 进入项目时逐类型加载;模块探测完成即写入自己类型那一格(增量更新)。
final ProjectTaskTable _taskTable = ProjectTaskTable();
/// 最近一次运行的任务ID(持久化保存)
String? _lastRunTaskId;
/// 最近一次运行的任务(如果有)
RunTask? _lastRunTask;
/// 当前绑定的工程根路径
String? _currentProjectRoot;
/// 当前工程最近活跃打开的文件路径(用于维持当前文件任务)
String? _lastActiveFilePath;
/// 当前进行中的探测会话(null 表示空闲)
ProjectProbe? _activeProbe;
ProjectProbeReport? _lastProbeReport;
final List<String> _activeProbeNoticeIds = [];
/// 本轮已结算(成功/失败/跳过)的模块通知 id:
/// 这些卡片内容已定稿,后续队列进度不得再覆盖它们
/// (否则完成卡片会被回写为"排队等待中…",失败原因也会被冲掉)
final Set<String> _finishedProbeNoticeIds = {};
/// 用户探测并发合并:正在执行的那次 + 是否需要补跑一次
Future<void>? _userProbeInFlight;
bool _userProbePending = false;
/// 已释放标记:探测可能在释放后才返回,避免对已 dispose 的 notifier 通知
bool _disposed = false;
/// 安全通知(释放后不再触发)
void _notify() {
if (_disposed) return;
super.notifyListeners();
}
/// 类型 → 任务数组(UI 按类型分段渲染)
ProjectTaskTable get taskTable => _taskTable;
List<RunTask> get detectedTasks => List.unmodifiable(_taskTable.detectedTasks);
List<RunTask> get customTasks => _taskTable.tasksOf(RunTaskType.user);
RunTask? get lastRunTask => _lastRunTask;
String? get lastRunTaskId => _lastRunTaskId;
String? get currentProjectRoot => _currentProjectRoot;
/// 探测是否进行中(含模块依赖检测与自动补全)
bool get isDetecting => _activeProbe != null;
@visibleForTesting
ProjectProbe? get activeProbeForTest => _activeProbe;
/// 当前探测进度(null 表示无进行中的探测)
ValueListenable<ProbeProgress?>? get probeProgress => _activeProbe?.progress;
/// 最近一次探测的结构化报告
ProjectProbeReport? get lastProbeReport => _lastProbeReport;
/// 正在探测/同步的模块 id(供"重新同步"按钮显示 loading)
Set<String> get syncingModules {
final probe = _activeProbe;
if (probe == null) return const <String>{};
final only = probe.onlyModuleId;
if (only != null) return {only};
return {for (final m in probe.progress.value?.queue ?? const []) m.id};
}
bool isModuleSyncing(String moduleId) => syncingModules.contains(moduleId);
/// 需要跑真实构建工具自省、因而支持"重新同步真实任务"的模块 id
List<String> get resyncableModuleIds =>
[for (final m in _dispatcher.modules) if (m.supportsResync) m.id];
/// 模块展示名(用于 UI 文案插值;找不到时回退为 id)
String moduleDisplayName(String moduleId) => _moduleDisplayName(moduleId);
/// 获取当前合并后的所有可用任务列表(自定义任务置顶,随后为各类型探测任务)
List<RunTask> get allTasks => [...customTasks, ..._taskTable.detectedTasks];
/// 内部方法:尝试从现有任务列表中匹配 lastRunTaskId
void _resolveLastRunTask() {
_lastRunTask = null;
if (_lastRunTaskId == null) return;
// 单文件任务联动:如果上一次执行的任务是单文件任务(以 detected_single_ 开头)
if (_lastRunTaskId!.startsWith('detected_single_')) {
final singleTasks = _taskTable.tasksOf(RunTaskType.singleFile);
if (singleTasks.isNotEmpty) {
// 当前文件支持单文件运行,自动联动为当前文件的单文件任务
_lastRunTask = singleTasks.first;
_lastRunTaskId = singleTasks.first.id;
return;
}
// 当前文件不支持单文件运行,清除当前可执行的 _lastRunTask(保留 _lastRunTaskId 以便切回可运行文件时恢复)
return;
}
for (final task in allTasks) {
if (task.id == _lastRunTaskId) {
_lastRunTask = task;
return;
}
}
}
/// 记录最近一次执行的任务("上一次执行任务"与用户任务一样持久化在 JSON 中)
Future<void> setLastRunTask(RunTask task) async {
_lastRunTask = task;
_lastRunTaskId = task.id;
_notify();
final root = _currentProjectRoot;
if (root != null) {
// 只更新 lastRunTaskId,保留磁盘上已有的用户任务(内存可能尚未加载完)
await _storageService.saveLastRunTaskId(
projectRoot: root,
lastRunTaskId: _lastRunTaskId,
);
}
// 与用户任务同样的处理:写盘后用用户探测把内存态从磁盘校准一次(含并发合并)
await probeUser(projectRoot: root);
}
/// 当打开或切换工程时初始化任务(进入项目即自动探测)
///
/// [systemName] 必须传入当前真实选中的系统;为空时**只做用户探测**(系统探测会因无系统被跳过),
/// 等系统就绪后由入口处的去重逻辑自动补一次。
Future<void> onProjectOpened(String projectRoot, {String? activeFilePath, String? systemName}) async {
_currentProjectRoot = projectRoot;
_lastActiveFilePath = activeFilePath;
await probeProject(
projectRoot: projectRoot,
currentFilePath: activeFilePath,
systemName: systemName,
);
}
/// 关闭工程时清理状态
void onProjectClosed() {
cancelActiveProbe();
_currentProjectRoot = null;
_lastActiveFilePath = null;
_taskTable.clear();
_lastRunTaskId = null;
_lastRunTask = null;
_lastProbeReport = null;
_notify();
}
/// ===================== 探测层(三个函数) =====================
/// 探测函数(总入口):**终止正在运行的模块 + 清空内存任务表**,然后依次执行
/// [probeUser](用户探测:磁盘 → 内存)与 [probeSystem](系统探测:模块队列 → 内存)。
///
/// 进入项目、切换工程、手动"项目探测"都走它。
Future<void> probeProject({
required String projectRoot,
String? currentFilePath,
String? systemName,
}) async {
// 1. 终止进行中的模块(取消会话:容器内子进程会被立即杀掉)
cancelActiveProbe();
if (_currentProjectRoot != projectRoot) {
_currentProjectRoot = projectRoot;
}
// 2. 清空内存任务表(系统任务只存在于内存,用户任务随后由用户探测重新载入)
_taskTable.clear();
_lastRunTask = null;
_notify();
// 3. 用户探测(快:读磁盘 → 覆盖内存 user 格与"上次执行任务")
await probeUser(projectRoot: projectRoot);
// 4. 当前文件任务(快:本地重算,0ms 立即展现,不需等耗时的容器探测)
final activeFile = currentFilePath ?? _lastActiveFilePath;
if (activeFile != null && activeFile.isNotEmpty) {
_applySingleFileTask(projectRoot, activeFile);
_notify();
}
// 5. 系统探测(慢:模块队列线性执行 → 写入各自的类型格)
await probeSystem(
projectRoot: projectRoot,
currentFilePath: currentFilePath,
systemName: systemName,
);
}
/// 用户主动点击"项目探测":若已有探测在进行则拒绝,由 UI 弹出 toast 提示。
/// 返回 true 表示已开始探测。
Future<bool> requestProjectProbe({
required String projectRoot,
String? currentFilePath,
String? systemName,
}) async {
if (isDetecting) return false;
await probeProject(
projectRoot: projectRoot,
currentFilePath: currentFilePath,
systemName: systemName,
);
return true;
}
/// 用户探测:从磁盘载入用户自定义任务与"上一次执行任务",并**覆盖**内存中的用户类型格。
///
/// 并发合并:短时间内被连续触发(例如用户连续编辑几十次任务)时,正在执行的那次结束后
/// 最多再补跑一次,保证"最后一次编辑一定生效",同时不会放大磁盘 IO。
Future<void> probeUser({String? projectRoot}) async {
final root = projectRoot ?? _currentProjectRoot;
if (root == null) return;
// 同步绑定工程根:这样"期间切换了工程"能被下面的守卫准确识别并丢弃结果
_currentProjectRoot ??= root;
final inFlight = _userProbeInFlight;
if (inFlight != null) {
_userProbePending = true;
return inFlight;
}
final completer = Completer<void>();
_userProbeInFlight = completer.future;
try {
await _loadUserState(root);
} catch (e) {
debugPrint('[RunProvider] 用户探测失败: $e');
} finally {
_userProbeInFlight = null;
completer.complete();
if (_userProbePending) {
_userProbePending = false;
unawaited(probeUser(projectRoot: root));
}
}
}
Future<void> _loadUserState(String projectRoot) async {
final config = await _storageService.loadConfig(projectRoot);
if (_currentProjectRoot != projectRoot) return;
// 覆盖内存中的用户任务(而不是合并),并同步"上次执行任务"
_taskTable.setUserTasks(config.tasks);
_lastRunTaskId = config.lastRunTaskId;
_resolveLastRunTask();
_notify();
}
/// 系统探测:模块发现 → 入队 → 线性执行三动作,结果逐模块写入内存任务表。
Future<void> probeSystem({
required String projectRoot,
String? currentFilePath,
String? systemName,
String? onlyModuleId,
}) async {
// 单模块同步时只清该模块类型;整轮探测时清空全部构建模块类型(用户任务格与当前文件格不动)
if (onlyModuleId == null) {
for (final type in RunTaskType.values) {
if (type == RunTaskType.user || type == RunTaskType.singleFile) continue;
_taskTable.replaceType(type, const <RunTask>[]);
}
} else {
final type = RunTaskType.fromModuleId(onlyModuleId);
if (type != null) _taskTable.replaceType(type, const <RunTask>[]);
}
_notify();
// 终止可能仍在后台执行的旧探测会话,防止与新会话并发争抢包管理器锁与资源
if (_activeProbe != null) {
_activeProbe?.cancel();
_activeProbe = null;
}
// 清理上一轮遗留的探测通知,避免新探测的进度更新到正在退场的卡片上
_clearProbeNotices();
final probe = _dispatcher.createProbe(
projectRoot: projectRoot,
currentFilePath: currentFilePath,
systemName: systemName,
distroManager: _distroManager,
onlyModuleId: onlyModuleId,
budget: _probeBudget,
);
_activeProbe = probe;
// 进度 -> 通知(队列中每个模块一条;当前模块显示三动作阶段,其余显示排队)
void onProgress() {
if (!identical(_activeProbe, probe)) return;
final progress = probe.progress.value;
if (progress == null || _noticeCenter == null) return;
_syncProbeNotices(progress, probe);
_notify();
}
probe.progress.addListener(onProgress);
// 结果 -> 立即写入类型表 + 结算该模块弹窗(无需等整轮探测结束)
void onModuleResult(ProjectModule module, ModuleProbeResult result) {
// 边界:探测已被取消 / 已被新的探测取代 / 工程已切换时,结果必须丢弃,
// 否则会把上一个工程(或已被取消的会话)的任务写进当前工程的内存表。
if (!identical(_activeProbe, probe) || probe.isCancelled) return;
if (_currentProjectRoot != projectRoot) return;
_applyModuleResult(module, result);
_notify();
}
ProjectProbeReport report;
try {
report = await _dispatcher.run(probe, onModuleResult: onModuleResult);
} catch (e) {
debugPrint('[RunProvider] 系统探测失败: $e');
report = ProjectProbeReport.empty(systemName ?? '');
} finally {
probe.progress.removeListener(onProgress);
}
if (!identical(_activeProbe, probe)) {
// 期间被取消或已被新的探测取代:会话由这里释放,结果一律丢弃
probe.dispose();
return;
}
_activeProbe = null;
// 仅当"仍是同一个工程"且"本次是整轮探测"时才收尾(单模块同步不动当前文件格)
if (_currentProjectRoot == projectRoot && !probe.isCancelled) {
_lastProbeReport = report;
if (onlyModuleId == null) {
final activeFile = currentFilePath ?? _lastActiveFilePath;
if (activeFile != null && activeFile.isNotEmpty) {
_applySingleFileTask(projectRoot, activeFile);
}
}
_resolveLastRunTask();
}
_finishProbeNotices(report, cancelled: probe.isCancelled);
// 预算中止:补一条可关闭的说明(× 保留,用户可自行关闭或稍后重新探测)
if (!probe.isCancelled && report.abortedByBudget && !_disposed) {
_noticeCenter?.push(NoticeItem(
id: 'probe:budget',
kind: NoticeKind.failure,
text: ProbeBudgetExceededText(
completed: report.completedModules,
total: report.totalModules,
),
sticky: true,
));
}
probe.dispose();
_notify();
}
/// 把"当前打开文件"的任务写入 singleFile(当前文件)类型格。
///
/// 边界:本地重算而不是从报告里挑——即使工程没有任何模块被激活(报告为空),
/// 当前文件任务也必须照常出现。
void _applySingleFileTask(String projectRoot, String? currentFilePath) {
if (_disposed) return;
if (currentFilePath != null && currentFilePath.isNotEmpty) {
_lastActiveFilePath = currentFilePath;
}
final effectivePath = currentFilePath ?? _lastActiveFilePath;
final single = (effectivePath == null || effectivePath.isEmpty)
? null
: ProjectTaskDispatcher.detectSingleFileTask(projectRoot, effectivePath);
_taskTable.replaceType(
RunTaskType.singleFile,
single == null ? const <RunTask>[] : <RunTask>[single],
);
}
/// 当前打开文件变化时本地重算当前文件任务(不跑容器、不触发系统探测)
///
/// 边界:当前文件任务与"当前打开的文件"强相关,切标签页后必须立即更新,
/// 否则列表里会残留上一个文件的运行项。
void refreshSingleFileTask({String? currentFilePath}) {
final root = _currentProjectRoot;
if (root == null) return;
if (currentFilePath != null && currentFilePath.isNotEmpty) {
_lastActiveFilePath = currentFilePath;
}
_applySingleFileTask(root, currentFilePath ?? _lastActiveFilePath);
_resolveLastRunTask();
_notify();
}
/// 单模块强制重新同步(系统探测的一个特例)
Future<void> syncModuleTasks(
String moduleId, {
String? systemName,
String? currentFilePath,
}) async {
final projectRoot = _currentProjectRoot;
if (projectRoot == null) return;
if (isModuleSyncing(moduleId)) return;
await probeSystem(
projectRoot: projectRoot,
currentFilePath: currentFilePath,
systemName: systemName,
onlyModuleId: moduleId,
);
}
/// 取消当前探测(切换工程 / 用户关闭提示 / 关闭弹窗时调用)
void cancelActiveProbe() {
final probe = _activeProbe;
if (probe == null) return;
probe.cancel();
_clearProbeNotices();
_activeProbe = null;
_notify();
}
/// 单个模块探测结束:写入它自己类型的那一格 + 结算它的弹窗
void _applyModuleResult(ProjectModule module, ModuleProbeResult result) {
// 边界:运行时注册的自定义模块没有内置类型映射 -> 归入 other(不能丢任务)
final type = RunTaskType.fromModuleId(module.id) ?? RunTaskType.other;
_taskTable.replaceType(
type,
result.status == ModuleProbeStatus.ok ? result.tasks : const <RunTask>[],
);
if (_currentProjectRoot != null) {
_resolveLastRunTask();
}
final center = _noticeCenter;
if (center == null) return;
final noticeId = _noticeIdFor(module.id);
_finishedProbeNoticeIds.add(noticeId);
switch (result.status) {
case ModuleProbeStatus.ok:
center.complete(
noticeId,
kind: NoticeKind.success,
text: ModuleDoneText(module.displayName, taskCount: result.tasks.length),
autoCloseAfter: const Duration(milliseconds: 1500),
// 模块已结束:关闭这张卡片不再具有破坏性,无需再二次确认
confirmBeforeDismiss: false,
);
break;
case ModuleProbeStatus.failed:
center.complete(
noticeId,
kind: NoticeKind.failure,
text: ModuleFailureText(
moduleDisplayName: module.displayName,
failure: result.failure ?? NoticeFailure.executionFailed,
detail: result.failureDetail,
),
sticky: true,
confirmBeforeDismiss: false,
);
break;
case ModuleProbeStatus.cancelled:
case ModuleProbeStatus.skippedByBudget:
center.dismiss(noticeId);
break;
}
}
/// 依据队列进度为每个模块建立/更新通知条目
///
/// 队列线性执行:当前模块显示它正在做的动作(依赖检测/自动补全/执行探测),
/// 队列中其它模块统一显示"排队等待中"。
void _syncProbeNotices(ProbeProgress progress, ProjectProbe probe) {
final center = _noticeCenter;
if (center == null) return;
final currentPhase = switch (progress.phase) {
ProbePhase.queued => ProbeNoticePhase.queued,
ProbePhase.checkingDependency => ProbeNoticePhase.checkingDependency,
ProbePhase.installingDependency => ProbeNoticePhase.installingDependency,
ProbePhase.probing => ProbeNoticePhase.detecting,
ProbePhase.finalizing => ProbeNoticePhase.finalizing,
};
final installDetail = probe.installLine.value;
for (final module in progress.queue) {
final noticeId = _noticeIdFor(module.id);
// 已结算的模块不再改写:否则完成/失败卡片会被回写成"排队等待中…"
if (_finishedProbeNoticeIds.contains(noticeId)) continue;
final isCurrent = progress.current?.id == module.id;
final phase = isCurrent ? currentPhase : ProbeNoticePhase.queued;
final text = ModulePhaseText(
moduleDisplayName: module.displayName,
phase: phase,
detail: isCurrent && phase == ProbeNoticePhase.installingDependency
? installDetail
: null,
);
if (!_activeProbeNoticeIds.contains(noticeId)) {
_activeProbeNoticeIds.add(noticeId);
center.push(NoticeItem(
id: noticeId,
kind: NoticeKind.progress,
text: text,
// 进行中的通知被用户 × 掉 => 取消本次探测;这是破坏性操作,关闭前二次确认
onUserDismiss: cancelActiveProbe,
confirmBeforeDismiss: true,
));
} else {
center.update(noticeId, kind: NoticeKind.progress, text: text);
}
}
}
/// 整轮探测收尾:把仍未结算的进度条目关掉(结果已由 [_applyModuleResult] 逐模块结算)
void _finishProbeNotices(ProjectProbeReport report, {required bool cancelled}) {
final center = _noticeCenter;
if (center == null) {
_activeProbeNoticeIds.clear();
_finishedProbeNoticeIds.clear();
return;
}
if (cancelled) {
_clearProbeNotices();
return;
}
final resolved = {for (final id in report.moduleResults.keys) _noticeIdFor(id)};
for (final noticeId in List<String>.from(_activeProbeNoticeIds)) {
if (!resolved.contains(noticeId)) {
center.dismiss(noticeId);
}
}
_activeProbeNoticeIds
..clear()
..addAll(resolved);
_finishedProbeNoticeIds.clear();
}
void _clearProbeNotices() {
final center = _noticeCenter;
if (center == null) {
_activeProbeNoticeIds.clear();
_finishedProbeNoticeIds.clear();
return;
}
for (final noticeId in _activeProbeNoticeIds) {
center.dismiss(noticeId);
}
_activeProbeNoticeIds.clear();
_finishedProbeNoticeIds.clear();
}
String _noticeIdFor(String moduleId) => 'probe:$moduleId';
String _moduleDisplayName(String moduleId) =>
_dispatcher.getModule(moduleId)?.displayName ?? moduleId;
/// 保存用户自定义任务:**先写盘,再调用用户探测**从磁盘覆盖内存中的用户任务格。
///
/// 用户连续编辑时,[probeUser] 会把并发调用合并成"正在跑的那次 + 最多补跑一次",
/// 既保证最后一次编辑生效,又不会把磁盘 IO 放大几十倍。
Future<void> updateCustomTasks(List<RunTask> updatedTasks) async {
final root = _currentProjectRoot;
if (root == null) return;
await _storageService.saveConfig(
projectRoot: root,
tasks: updatedTasks,
lastRunTaskId: _lastRunTaskId,
);
await probeUser(projectRoot: root);
}
/// 添加单个自定义任务(以**磁盘**为基准做读改写,避免内存未加载完时丢失已有任务)
Future<void> addCustomTask(RunTask task) {
return _mutateCustomTasks((list) => [...list, task]);
}
/// 删除单个自定义任务(以磁盘为基准)
Future<void> removeCustomTask(String taskId) {
return _mutateCustomTasks((list) => list.where((t) => t.id != taskId).toList());
}
/// 修改单个自定义任务(以磁盘为基准;磁盘上不存在则追加)
Future<void> editCustomTask(RunTask task) {
return _mutateCustomTasks((list) {
final index = list.indexWhere((t) => t.id == task.id);
if (index == -1) return [...list, task];
final next = List<RunTask>.from(list);
next[index] = task;
return next;
});
}
/// 读改写用户任务:先读磁盘上的当前列表,应用 [mutate] 后再写回,
/// 最后用用户探测把内存态从磁盘覆盖一次(含并发合并)。
Future<void> _mutateCustomTasks(List<RunTask> Function(List<RunTask> current) mutate) async {
final root = _currentProjectRoot;
if (root == null) return;
final existing = (await _storageService.loadConfig(root)).tasks;
await _storageService.saveConfig(
projectRoot: root,
tasks: mutate(existing),
lastRunTaskId: _lastRunTaskId,
);
await probeUser(projectRoot: root);
}
@override
void dispose() {
// 只取消,不释放会话:探测协程仍在运行,会在自己的收尾分支里 dispose,
// 这里提前 dispose 会造成"取消后写入已释放 notifier"的 use-after-dispose。
_disposed = true;
_activeProbe?.cancel();
_activeProbe = null;
_userProbePending = false;
super.dispose();
}
}