页面UI替换1远程遥控和各项弹窗和作业主页面和子页面+路径规划的主页面重构等

This commit is contained in:
2026-10-28 14:38:24 +08:00
parent 8a41113c92
commit eb8dec2868
64 changed files with 25316 additions and 1174 deletions

View File

@@ -0,0 +1,57 @@
import '../../domain/repositories/autonomous_work_gateway.dart';
import 'local_demo_work_gateway.dart';
import 'path_planning_work_gateway.dart';
/// 可选的环境实现清单。新增 B 环境时在这里加一项。
enum AutonomousWorkScene {
pathPlanning,
localDemo,
}
/// 环境选择 + 实例构建。
///
/// 三种切换方式,按优先级:
/// 1. 运行期覆盖(单测 / 灰度 / 某租户专用):[overrideWith]
/// 2. 编译期注入:flutter run --dart-define=AUTONOMOUS_WORK_SCENE=local_demo
/// 3. 默认:path_planning(当前 A 环境)
class AutonomousWorkGatewayFactory {
AutonomousWorkGatewayFactory._();
static AutonomousWorkGateway? _override;
static AutonomousWorkScene resolveScene() {
const raw = String.fromEnvironment(
'AUTONOMOUS_WORK_SCENE',
defaultValue: 'path_planning',
);
switch (raw) {
case 'local_demo':
case 'demo':
return AutonomousWorkScene.localDemo;
case 'path_planning':
default:
return AutonomousWorkScene.pathPlanning;
}
}
static AutonomousWorkGateway build(AutonomousWorkScene scene) {
switch (scene) {
case AutonomousWorkScene.localDemo:
return LocalDemoWorkGateway();
case AutonomousWorkScene.pathPlanning:
return PathPlanningWorkGateway();
}
}
static AutonomousWorkGateway current() =>
_override ?? build(resolveScene());
/// 运行期替换实现(单测、灰度、特定业务线)
static void overrideWith(AutonomousWorkGateway gateway) {
_override = gateway;
}
static void clearOverride() {
_override = null;
}
}

View File

@@ -0,0 +1,229 @@
import 'dart:async';
import 'package:latlong2/latlong.dart';
import '../../domain/entities/work_session_models.dart';
import '../../domain/repositories/autonomous_work_gateway.dart';
/// B 环境示例实现:完全本地内存,不依赖任何后端。
///
/// 用途有两个:
/// 1. 证明「一套页面功能,多套实现」的切换成本 = 新增一个文件;
/// 2. 无网络环境 / UI 联调 / 演示时也能跑完整的启停流程。
///
/// 接真实 B 环境时,拷这个文件改内部实现即可(HTTP、MQTT、本地库都行),
/// 页面与抽屉一行都不用改。
class LocalDemoWorkGateway implements AutonomousWorkGateway {
LocalDemoWorkGateway();
static const List<LatLng> _demoPath = <LatLng>[
LatLng(31.0833, 120.8403),
LatLng(31.0839, 120.8410),
LatLng(31.0845, 120.8412),
LatLng(31.0851, 120.8406),
LatLng(31.0847, 120.8398),
];
/// 覆盖模式的作业区域边界(演示数据:把轨迹包成一个矩形),
/// 对应 A 环境的 outer,地图上画灰色半透明框
static const List<LatLng> _demoOuter = <LatLng>[
LatLng(31.0830, 120.8394),
LatLng(31.0830, 120.8416),
LatLng(31.0854, 120.8416),
LatLng(31.0854, 120.8394),
];
final StreamController<WorkTaskSnapshot?> _controller =
StreamController<WorkTaskSnapshot?>.broadcast();
final List<WorkTaskSnapshot> _tasks = <WorkTaskSnapshot>[];
/// 本地保存的圈地记录(B 环境无后端,只存在内存里)
final List<WorkRouteOption> _savedRoutes = <WorkRouteOption>[];
int _seq = 1000;
int _routeSeq = 2000;
@override
String get gatewayId => 'local_demo';
@override
WorkSceneCapabilities get capabilities => const WorkSceneCapabilities(
routeLibrary: true,
taskQueue: true,
pause: true,
resume: true,
stop: true,
cancelQueued: true,
schedule: true,
routeEditing: false,
progress: true,
multiActiveTaskResolve: true,
);
@override
Future<WorkScope> resolveScope({required String deviceId}) async =>
const WorkScope(siteId: 1, orgId: 1);
@override
Future<WorkResult<List<WorkRouteOption>>> loadRoutes({
required int siteId,
}) async {
return WorkResult.ok(<WorkRouteOption>[
..._savedRoutes,
const WorkRouteOption(
id: 'demo-1',
name: 'A区 · 演示路线01',
pathPoints: _demoPath,
outerPoints: _demoOuter,
planModeLabel: '覆盖模式',
metaText: '5 个路径点 · 4 个边界点 · 覆盖模式',
),
const WorkRouteOption(
id: 'demo-2',
name: 'B区 · 演示路线02',
pathPoints: _demoPath,
coverageMode: false,
planModeLabel: '自定义模式',
metaText: '5 个路径点 · 自定义模式',
),
]);
}
@override
Future<WorkResult<WorkRouteOption>> resolveRouteGeometry({
required String deviceId,
required WorkRouteOption route,
}) async {
// 演示数据自带完整几何,无需再查
if (route.hasGeometry) return WorkResult.ok(route);
return WorkResult.fail('「${route.name}」没有可用的路径数据');
}
@override
Future<WorkResult<bool>> saveRouteRecord({
required String deviceId,
required String name,
required List<LatLng> path,
required List<LatLng> outer,
required int planModel,
String? imageBase64,
}) async {
_savedRoutes.add(
WorkRouteOption(
id: 'demo-${++_routeSeq}',
name: name,
pathPoints: List<LatLng>.from(path),
outerPoints: planModel == 0 ? List<LatLng>.from(outer) : const [],
coverageMode: planModel == 0,
planModeLabel: planModel == 0 ? '覆盖模式' : '自定义模式',
),
);
return const WorkResult<bool>.ok(true);
}
@override
Future<WorkResult<List<WorkTaskSnapshot>>> loadTasks({
required String deviceId,
}) async {
return WorkResult.ok(List<WorkTaskSnapshot>.unmodifiable(_tasks));
}
@override
Stream<WorkTaskSnapshot?> watchTask({required String deviceId}) =>
_controller.stream;
@override
Future<WorkResult<WorkTaskSnapshot>> startWork(
WorkStartRequest request,
) async {
final reuseId = request.reuseTaskId;
if (reuseId != null) {
for (final task in _tasks) {
if (task.taskId == reuseId) {
_emit(task);
return WorkResult.ok(task);
}
}
}
final snapshot = WorkTaskSnapshot(
taskId: '${++_seq}',
deviceId: request.deviceId,
state: WorkRunState.running,
routeId: request.route.id,
routeName: request.route.name,
rawStatus: 'DEMO_EXECUTING',
createdAt: DateTime.now().toString().substring(0, 19),
progress: 0,
);
_tasks.add(snapshot);
_emit(snapshot);
return WorkResult.ok(snapshot);
}
@override
Future<WorkResult<WorkTaskSnapshot>> pauseWork({
required String deviceId,
required WorkTaskSnapshot task,
}) async =>
_update(task, WorkRunState.paused, 'DEMO_PAUSE');
@override
Future<WorkResult<WorkTaskSnapshot>> resumeWork({
required String deviceId,
required WorkTaskSnapshot task,
}) async =>
_update(task, WorkRunState.running, 'DEMO_EXECUTING');
@override
Future<WorkResult<WorkTaskSnapshot>> stopWork({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
final result = _update(task, WorkRunState.finished, 'DEMO_FINISHED');
_controller.add(null);
return result;
}
@override
Future<WorkResult<WorkTaskSnapshot>> cancelQueued({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
if (task.state == WorkRunState.running) {
return WorkResult.fail('执行中的任务请用「停止作业」终止');
}
_tasks.removeWhere((t) => t.taskId == task.taskId);
_controller.add(null);
return WorkResult.ok(task.copyWith(state: WorkRunState.finished));
}
@override
Future<WorkResult<WorkTaskSnapshot>> activateTask({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
for (final item in _tasks) {
if (item.taskId == task.taskId) {
_emit(item);
return WorkResult.ok(item);
}
}
return WorkResult.fail('任务不存在或已结束');
}
WorkResult<WorkTaskSnapshot> _update(
WorkTaskSnapshot task,
WorkRunState state,
String rawStatus,
) {
final next = task.copyWith(state: state, rawStatus: rawStatus);
final index = _tasks.indexWhere((t) => t.taskId == task.taskId);
if (index >= 0) _tasks[index] = next;
_emit(next);
return WorkResult.ok(next);
}
void _emit(WorkTaskSnapshot snapshot) {
_controller.add(snapshot);
}
}

View File

@@ -0,0 +1,553 @@
import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:latlong2/latlong.dart';
import '../../../../core/app/app_user_cubit.dart';
import '../../../../core/consts/http_api_consts.dart';
import '../../../../core/di/injection.dart';
import '../../../devices/domain/entities/device_task_entity.dart';
import '../../../devices/domain/usecases/create_device_task_usecase.dart';
import '../../../devices/presentation/bloc/device_task_cubit.dart';
import '../../../devices/presentation/bloc/devices_cubit.dart';
import '../../../v2/site/presentation/cubit/site_cubit.dart';
import '../../domain/entities/work_session_models.dart';
import '../../domain/repositories/autonomous_work_gateway.dart';
/// A 环境实现:完全复用「路径规划」那条链路
/// 作业记录 selectBySiteId → 任务池 getDeviceTaskPool → createDeviceTask →
/// pause/recovery/cancel + MQTT arrive 监听。
///
/// 这里刻意复用全局的 [DevicesCubit] / [DeviceTaskCubit](均为 lazySingleton),
/// 保证与路径规划页共享同一份任务状态与同一条推送流,不会出现"两边状态不一致"。
class PathPlanningWorkGateway implements AutonomousWorkGateway {
PathPlanningWorkGateway({
DevicesCubit? devices,
DeviceTaskCubit? tasks,
CreateDeviceTaskUseCase? createTask,
}) : _devices = devices ?? sl<DevicesCubit>(),
_tasks = tasks ?? sl<DeviceTaskCubit>(),
_createTask = createTask ?? sl<CreateDeviceTaskUseCase>();
final DevicesCubit _devices;
final DeviceTaskCubit _tasks;
final CreateDeviceTaskUseCase _createTask;
@override
String get gatewayId => 'path_planning';
@override
WorkSceneCapabilities get capabilities => const WorkSceneCapabilities(
routeLibrary: true,
taskQueue: true,
pause: true,
resume: true,
stop: true,
cancelQueued: true,
schedule: false, // 定时计划后端未提供
routeEditing: true, // 走 RouteEditorPageV2
progress: false, // 任务池不返回进度,页面不臆造百分比
multiActiveTaskResolve: true,
);
@override
Future<WorkScope> resolveScope({required String deviceId}) async {
final site = sl<SiteCubit>().state.selectedSite;
return WorkScope(siteId: site?.id, orgId: site?.orgId);
}
@override
Future<WorkResult<List<WorkRouteOption>>> loadRoutes({
required int siteId,
}) async {
try {
await _devices.loadWorkRecordsBySiteId(siteId);
final records =
_devices.state.workRecords ?? const <Map<String, dynamic>>[];
final routes = <WorkRouteOption>[];
for (final record in records) {
final option = _routeFromRecord(record);
if (option != null) routes.add(option);
}
if (routes.isEmpty) {
final error = _devices.state.errorMessage;
return WorkResult.fail(
(error != null && error.isNotEmpty) ? error : '该场站下暂无作业路线',
);
}
return WorkResult.ok(routes);
} catch (e) {
return WorkResult.fail('路线库加载失败:$e');
}
}
@override
Future<WorkResult<WorkRouteOption>> resolveRouteGeometry({
required String deviceId,
required WorkRouteOption route,
}) async {
// 列表里已经带了几何:不再查(同路径规划:jsonData 有效就不调详情接口)
if (route.hasGeometry) return WorkResult.ok(route);
try {
// 与路径规划完全一致:按作业名回查记录详情,
// selectBySiteId 的 jsonData 可能是空标签,真实 path/outer/planModel 在记录顶层
await _devices.loadSelectedPath(route.name);
final records = _devices.state.pathData;
if (records == null || records.isEmpty) {
return WorkResult.fail('「${route.name}」没有可用的路径数据');
}
final record = records.first;
final hydrated = _routeFromRecord(<String, dynamic>{
'id': route.id,
'workName': route.name,
'imgUrl': route.imageUrl ?? '',
'jsonData': record['jsonData'],
'path': record['path'],
'outer': record['outer'],
'planModel': record['planModel'],
});
if (hydrated == null || !hydrated.hasGeometry) {
return WorkResult.fail('「${route.name}」没有可用的路径数据');
}
return WorkResult.ok(hydrated);
} catch (e) {
return WorkResult.fail('路线详情加载失败:$e');
}
}
@override
Future<WorkResult<List<WorkTaskSnapshot>>> loadTasks({
required String deviceId,
}) async {
try {
await _tasks.fetchAndFilterTask(deviceId);
final error = _tasks.state.errorMessage;
final tasks = _tasks.state.activeTasks
.map((task) => _snapshotFromEntity(task, deviceId))
.toList();
if (tasks.isEmpty && error != null && error.isNotEmpty) {
return WorkResult.fail(error);
}
return WorkResult.ok(tasks);
} catch (e) {
return WorkResult.fail('任务队列加载失败:$e');
}
}
/// 1:1 复刻路径规划「保存地块」:multipart 提交 /iot/workRecord/add。
///
/// 对齐 Web 端:覆盖模式 outer=边界、path=几何、planModel=0、mode=coverage;
/// 自定义模式 outer=[]、path=几何、planModel=2、mode=single_point。
/// file 字段后端强制要求:没有截图也要传一个空 jpg。
@override
Future<WorkResult<bool>> saveRouteRecord({
required String deviceId,
required String name,
required List<LatLng> path,
required List<LatLng> outer,
required int planModel,
String? imageBase64,
}) async {
// 场站与 orgId 必须同源(selectBySiteId 的查询条件),不要取登录用户的 orgId
final site = sl<SiteCubit>().state.selectedSite;
final siteId = site?.id;
if (siteId == null) {
return WorkResult.fail('请先在场站列表中选择一个场站!');
}
final orgId = site?.orgId;
List<Map<String, double>> toWgs(List<LatLng> points) => <Map<String, double>>[
for (final point in points)
{'lng': point.longitude, 'lat': point.latitude},
];
final bool coverage = planModel == 0;
final Map<String, dynamic> savePath = <String, dynamic>{
'outer': coverage ? toWgs(outer) : <dynamic>[],
'path': toWgs(path),
'planModel': planModel,
};
final Map<String, dynamic> workRecord = <String, dynamic>{
'workName': name,
'siteId': siteId,
// jsonData 必须是对象,不能是字符串(后端 PlanPath 类型要求)
'jsonData': savePath,
'mode': coverage ? 'coverage' : 'single_point',
};
if (orgId != null) workRecord['orgId'] = orgId;
final http.MultipartRequest request = http.MultipartRequest(
'POST',
Uri.parse('${HttpApiConsts.baseUrl}/iot/workRecord/add'),
);
final userToken = sl<AppUserCubit>().state.user?.token;
if (userToken != null) {
request.headers['Authorization'] = 'Bearer $userToken';
}
if (imageBase64 != null && imageBase64.isNotEmpty) {
var raw = imageBase64;
if (raw.startsWith('data:image/jpeg;base64,')) {
raw = raw.split(',').last;
}
request.files.add(
http.MultipartFile.fromBytes(
'file',
base64Decode(raw),
filename: 'image.jpg',
contentType: http.MediaType('image', 'jpeg'),
),
);
} else {
request.files.add(
http.MultipartFile.fromBytes(
'file',
<int>[],
filename: 'empty.jpg',
contentType: http.MediaType('image', 'jpeg'),
),
);
}
request.files.add(
http.MultipartFile.fromBytes(
'workRecord',
utf8.encode(jsonEncode(workRecord)),
filename: '', // 与浏览器 Blob 保持一致
contentType: http.MediaType('application', 'json'),
),
);
try {
final http.StreamedResponse response = await request.send();
final String body = await response.stream.bytesToString();
if (response.statusCode != 200) {
return WorkResult.fail('保存失败(HTTP ${response.statusCode}):$body');
}
Map<String, dynamic>? resp;
try {
resp = jsonDecode(body) as Map<String, dynamic>;
} catch (_) {
return WorkResult.fail('保存失败:响应体非 JSON,$body');
}
final code = resp['code'];
if (code != null && code.toString() != '200') {
return WorkResult.fail(
'${resp['msg'] ?? resp['message'] ?? '保存失败'}',
);
}
// 与路径规划一致:保存成功后刷新该场站的作业记录
await _devices.loadWorkRecordsBySiteId(siteId);
return const WorkResult<bool>.ok(true);
} catch (e) {
return WorkResult.fail('保存失败:$e');
}
}
@override
Stream<WorkTaskSnapshot?> watchTask({required String deviceId}) {
return _tasks.stream.map((state) {
final task = state.currentTask;
if (task == null) return null;
if (task.deviceId.isNotEmpty && task.deviceId != deviceId) return null;
return _snapshotFromEntity(task, deviceId);
}).distinct((a, b) {
if (a == null || b == null) return a == b;
return a.taskId == b.taskId &&
a.rawStatus == b.rawStatus &&
a.state == b.state;
});
}
@override
Future<WorkResult<WorkTaskSnapshot>> startWork(
WorkStartRequest request,
) async {
final scope = await resolveScope(deviceId: request.deviceId);
final siteId = request.siteId ?? scope.siteId;
final orgId = request.orgId ?? scope.orgId ?? 0;
if (siteId == null) {
return WorkResult.fail('未选择场站,无法下发作业');
}
// ① 复用设备上已有的活跃任务
final reuseId = request.reuseTaskId;
if (reuseId != null) {
final entity = _findEntity(reuseId);
if (entity != null) {
_tasks.selectTask(entity);
await _devices.startListeningMqttArrive(
deviceId: request.deviceId,
taskId: entity.id,
);
return WorkResult.ok(_snapshotFromEntity(entity, request.deviceId));
}
}
// ② 新建任务
final routeId = int.tryParse(request.route.id);
if (routeId == null) {
return WorkResult.fail('路线 ID 非法:${request.route.id}');
}
final created = await _createTask.execute(
deviceId: request.deviceId,
routeId: routeId,
siteId: siteId,
orgId: orgId,
);
String? failure;
final taskId = created.fold<int?>((f) {
failure = f.message;
return null;
}, (id) => id);
if (taskId == null) {
return WorkResult.fail(failure ?? '任务下发失败');
}
await _devices.startListeningMqttArrive(
deviceId: request.deviceId,
taskId: taskId,
);
// 刷新任务池拿真实状态;拿不到就返回本地快照,交给 watchTask 后续校正
await _tasks.fetchAndFilterTask(request.deviceId);
final entity = _findEntity('$taskId');
if (entity != null) {
_tasks.selectTask(entity);
return WorkResult.ok(_snapshotFromEntity(entity, request.deviceId));
}
_tasks.updateCurrentTaskId(taskId);
return WorkResult.ok(
WorkTaskSnapshot(
taskId: '$taskId',
deviceId: request.deviceId,
state: WorkRunState.queued,
routeId: request.route.id,
routeName: request.route.name,
rawStatus: 'NEW',
),
);
}
@override
Future<WorkResult<WorkTaskSnapshot>> pauseWork({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
_bindTask(task);
await _tasks.pauseTask(deviceId);
final error = _tasks.state.errorMessage;
if (error != null && error.isNotEmpty) return WorkResult.fail(error);
return WorkResult.ok(
task.copyWith(state: WorkRunState.paused, rawStatus: 'PAUSE'),
);
}
@override
Future<WorkResult<WorkTaskSnapshot>> resumeWork({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
_bindTask(task);
await _tasks.recoveryTask(deviceId);
final error = _tasks.state.errorMessage;
if (error != null && error.isNotEmpty) return WorkResult.fail(error);
return WorkResult.ok(
task.copyWith(state: WorkRunState.running, rawStatus: 'EXECUTING'),
);
}
@override
Future<WorkResult<WorkTaskSnapshot>> stopWork({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
_bindTask(task);
await _tasks.cancelTask(deviceId, forceCancel: true);
final error = _tasks.state.errorMessage;
if (error != null && error.isNotEmpty) return WorkResult.fail(error);
await _devices.stopListeningMqttArrive();
return WorkResult.ok(
task.copyWith(state: WorkRunState.finished, rawStatus: 'CANCELED'),
);
}
@override
Future<WorkResult<WorkTaskSnapshot>> cancelQueued({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
_bindTask(task);
await _tasks.cancelTask(deviceId, forceCancel: false);
final error = _tasks.state.errorMessage;
if (error != null && error.isNotEmpty) return WorkResult.fail(error);
_tasks.clearCurrentTask();
return WorkResult.ok(
task.copyWith(state: WorkRunState.finished, rawStatus: 'CANCELED'),
);
}
@override
Future<WorkResult<WorkTaskSnapshot>> activateTask({
required String deviceId,
required WorkTaskSnapshot task,
}) async {
final entity = _findEntity(task.taskId);
if (entity == null) {
return WorkResult.fail('该任务已不在任务池中,请刷新后重试');
}
_tasks.selectTask(entity);
await _devices.startListeningMqttArrive(
deviceId: deviceId,
taskId: entity.id,
);
return WorkResult.ok(_snapshotFromEntity(entity, deviceId));
}
// ===== 内部:状态映射 / 记录解析 =====
/// 让 DeviceTaskCubit 的操作作用在页面选中的那条任务上
void _bindTask(WorkTaskSnapshot task) {
final entity = _findEntity(task.taskId);
if (entity != null) {
_tasks.selectTask(entity);
return;
}
final id = int.tryParse(task.taskId);
if (id != null) _tasks.updateCurrentTaskId(id);
}
DeviceTaskEntity? _findEntity(String taskId) {
for (final entity in _tasks.state.activeTasks) {
if ('${entity.id}' == taskId) return entity;
}
return null;
}
WorkTaskSnapshot _snapshotFromEntity(
DeviceTaskEntity task,
String deviceId,
) {
return WorkTaskSnapshot(
taskId: '${task.id}',
deviceId: task.deviceId.isEmpty ? deviceId : task.deviceId,
state: _stateFromStatus(task.taskStatus),
routeId: task.routeId?.toString(),
rawStatus: task.taskStatus,
createdAt: task.createTime,
extras: <String, dynamic>{
'routeId': task.routeId,
'siteId': task.siteId,
'orgId': task.orgId,
'statusText': task.taskStatusTranslate,
},
);
}
/// 后端状态码 → 统一运行态。新增状态码只改这里。
WorkRunState _stateFromStatus(String status) {
switch (status) {
case 'NEW':
return WorkRunState.queued;
case 'EXECUTING':
return WorkRunState.running;
case 'PAUSE':
return WorkRunState.paused;
case 'FAILED':
return WorkRunState.failed;
case 'CANCELING':
return WorkRunState.finished;
default:
return WorkRunState.queued;
}
}
/// 作业记录 → 路线选项:字段解析集中在这里,
/// 后端返回结构变化(XML / JSON / 另一套字段名)只改这个函数。
WorkRouteOption? _routeFromRecord(Map<String, dynamic> record) {
final id = record['id']?.toString() ?? '';
if (id.isEmpty) return null;
final name = (record['workName']?.toString().isNotEmpty ?? false)
? record['workName'].toString()
: '未命名路线';
final raw = record['jsonData'];
Map<String, dynamic> data = const <String, dynamic>{};
if (raw is String && raw.trim().isNotEmpty) {
try {
final decoded = jsonDecode(raw);
if (decoded is Map) {
data = Map<String, dynamic>.from(decoded);
}
} catch (_) {
data = const <String, dynamic>{};
}
} else if (raw is Map) {
data = Map<String, dynamic>.from(raw);
}
// 与路径规划页一致:jsonData 可能只是空的 <jsonData/>(解析后 {}),
// 真实 path/outer/planModel 也可能直接挂在记录顶层,两处都读。
final path = _points(data['path'] ?? record['path']);
var outer = _points(data['outer'] ?? record['outer']);
final planModel =
int.tryParse('${data['planModel'] ?? record['planModel'] ?? ''}');
final imgUrl = record['imgUrl']?.toString() ?? '';
// 后端可能返回 outer 经度全为 0 的脏数据:覆盖模式下用 path 兜底,
// 否则地图上只剩一条线、看不到作业区域
final coverageMode = planModel == null || planModel == 0;
if (coverageMode && outer.isEmpty && path.isNotEmpty) {
outer = path;
}
final meta = <String>[
if (path.isNotEmpty) '${path.length} 个路径点',
if (outer.isNotEmpty) '${outer.length} 个边界点',
if (planModel != null) (coverageMode ? '覆盖模式' : '自定义模式'),
];
return WorkRouteOption(
id: id,
name: name,
pathPoints: path,
outerPoints: outer,
coverageMode: coverageMode,
planModeLabel:
planModel == null ? null : (coverageMode ? '覆盖模式' : '自定义模式'),
imageUrl: imgUrl.isNotEmpty
? imgUrl
: (data['img'] is String ? data['img'] as String : null),
metaText: meta.isEmpty ? null : meta.join(' · '),
extras: <String, dynamic>{'raw': data},
);
}
/// 坐标解析:兼容 `List<dynamic>` / JSON 字符串 / `{lat,lng}` / `{lat,lon}` 四种形态
List<LatLng> _points(dynamic source) {
dynamic raw = source;
if (raw is String) {
if (raw.trim().isEmpty) return const <LatLng>[];
try {
raw = jsonDecode(raw);
} catch (_) {
return const <LatLng>[];
}
}
if (raw is! List) return const <LatLng>[];
final points = <LatLng>[];
for (final item in raw) {
if (item is! Map) continue;
final lat = double.tryParse('${item['lat'] ?? ''}');
final lng = double.tryParse('${item['lng'] ?? item['lon'] ?? ''}');
if (lat == null || lng == null) continue;
if (lat == 0 || lng == 0) continue;
points.add(LatLng(lat, lng));
}
return points;
}
}

View File

@@ -0,0 +1,240 @@
import 'package:latlong2/latlong.dart';
/// 跨环境统一的作业运行态:UI 只认这一套枚举。
/// 各环境自己的任务状态码(NEW/EXECUTING/PAUSE/… 或别的后端字段)
/// 由各自的 gateway 实现映射到这里,页面不感知原始状态码。
enum WorkRunState {
idle, // 准备:没有任何任务
queued, // 已下发,等待设备接单
running, // 执行中
paused, // 暂停 / 中断
finished, // 正常结束或被终止
failed, // 异常失败
}
extension WorkRunStateX on WorkRunState {
bool get hasTask => this != WorkRunState.idle;
bool get isRunning => this == WorkRunState.running;
bool get isPaused => this == WorkRunState.paused;
bool get isQueued => this == WorkRunState.queued;
bool get isFinished => this == WorkRunState.finished;
/// 顶部 5 段阶段胶囊的分组:failed 归到「暂停/中断」
WorkRunState get chipGroup =>
this == WorkRunState.failed ? WorkRunState.paused : this;
String get label => switch (this) {
WorkRunState.idle => '准备',
WorkRunState.queued => '待执行',
WorkRunState.running => '执行中',
WorkRunState.paused => '暂停/中断',
WorkRunState.finished => '已结束',
WorkRunState.failed => '异常中断',
};
}
/// 路线库中的一条可执行路线(对应路径规划列表里的一条作业记录)
class WorkRouteOption {
const WorkRouteOption({
required this.id,
required this.name,
this.pathPoints = const <LatLng>[],
this.outerPoints = const <LatLng>[],
this.planModeLabel,
this.imageUrl,
this.metaText,
this.coverageMode = true,
this.extras = const <String, dynamic>{},
});
/// 统一用字符串:A 环境是 int routeId,B 环境可能是 uuid / 名称
final String id;
final String name;
final List<LatLng> pathPoints;
final List<LatLng> outerPoints;
final String? planModeLabel;
final String? imageUrl;
final String? metaText;
/// 是否「覆盖模式」(A 环境 planModel == 0)。
/// 与路径规划页一致:覆盖模式画 outer 灰色半透明边界框,自定义模式不画。
final bool coverageMode;
/// 环境专有字段放这里,页面不解析
final Map<String, dynamic> extras;
bool get hasGeometry => pathPoints.isNotEmpty || outerPoints.isNotEmpty;
List<LatLng> get previewPoints =>
pathPoints.isNotEmpty ? pathPoints : outerPoints;
/// 预览时要画的边界框:只有覆盖模式才画(与路径规划选中路线的行为一致)
List<LatLng> get previewOuter =>
coverageMode ? outerPoints : const <LatLng>[];
/// 补齐几何时用:列表接口只给元数据,详情接口才给 path/outer。
WorkRouteOption copyWith({
String? id,
String? name,
List<LatLng>? pathPoints,
List<LatLng>? outerPoints,
String? planModeLabel,
String? imageUrl,
String? metaText,
bool? coverageMode,
Map<String, dynamic>? extras,
}) {
return WorkRouteOption(
id: id ?? this.id,
name: name ?? this.name,
pathPoints: pathPoints ?? this.pathPoints,
outerPoints: outerPoints ?? this.outerPoints,
planModeLabel: planModeLabel ?? this.planModeLabel,
imageUrl: imageUrl ?? this.imageUrl,
metaText: metaText ?? this.metaText,
coverageMode: coverageMode ?? this.coverageMode,
extras: extras ?? this.extras,
);
}
}
/// 任务快照:跨环境统一的只读视图
class WorkTaskSnapshot {
const WorkTaskSnapshot({
required this.taskId,
required this.deviceId,
required this.state,
this.routeId,
this.routeName,
this.rawStatus = '',
this.createdAt,
this.progress,
this.coveredArea,
this.plannedArea,
this.extras = const <String, dynamic>{},
});
final String taskId;
final String deviceId;
final WorkRunState state;
final String? routeId;
final String? routeName;
/// 环境原始状态码,仅用于展示/排障
final String rawStatus;
final String? createdAt;
/// 0~1;null 表示该环境不提供进度(页面显示不确定进度条)
final double? progress;
final double? coveredArea;
final double? plannedArea;
final Map<String, dynamic> extras;
bool get isActive =>
state == WorkRunState.queued ||
state == WorkRunState.running ||
state == WorkRunState.paused;
WorkTaskSnapshot copyWith({
WorkRunState? state,
String? rawStatus,
String? routeId,
String? routeName,
double? progress,
}) {
return WorkTaskSnapshot(
taskId: taskId,
deviceId: deviceId,
state: state ?? this.state,
routeId: routeId ?? this.routeId,
routeName: routeName ?? this.routeName,
rawStatus: rawStatus ?? this.rawStatus,
createdAt: createdAt,
progress: progress ?? this.progress,
coveredArea: coveredArea,
plannedArea: plannedArea,
extras: extras,
);
}
}
/// 环境能力声明:页面据此隐藏/禁用入口,而不是假设「所有环境功能一样」
class WorkSceneCapabilities {
const WorkSceneCapabilities({
this.routeLibrary = true,
this.taskQueue = true,
this.pause = true,
this.resume = true,
this.stop = true,
this.cancelQueued = true,
this.schedule = false,
this.routeEditing = false,
this.progress = false,
this.multiActiveTaskResolve = false,
});
final bool routeLibrary;
final bool taskQueue;
final bool pause;
final bool resume;
final bool stop;
final bool cancelQueued;
final bool schedule;
final bool routeEditing;
/// 是否下发真实进度(false 时页面不臆造百分比)
final bool progress;
/// 是否可能出现「多个活跃任务需要用户选择」
final bool multiActiveTaskResolve;
static const WorkSceneCapabilities none = WorkSceneCapabilities(
routeLibrary: false,
taskQueue: false,
pause: false,
resume: false,
stop: false,
cancelQueued: false,
);
}
/// 作业作用域:场站/组织等环境相关的上下文
class WorkScope {
const WorkScope({this.siteId, this.orgId});
final int? siteId;
final int? orgId;
bool get hasSite => siteId != null;
}
/// 下发作业的入参
class WorkStartRequest {
const WorkStartRequest({
required this.deviceId,
required this.route,
this.siteId,
this.orgId,
this.reuseTaskId,
this.extras = const <String, dynamic>{},
});
final String deviceId;
final WorkRouteOption route;
final int? siteId;
final int? orgId;
/// 复用设备上已存在的活跃任务(不再重复 createDeviceTask)
final String? reuseTaskId;
final Map<String, dynamic> extras;
}
/// 统一返回:不把 Either/Failure 泄漏给 UI,任何环境实现都能套
class WorkResult<T> {
const WorkResult.ok(T this.data) : error = null;
const WorkResult.fail(String this.error) : data = null;
final T? data;
final String? error;
bool get isOk => error == null;
}

View File

@@ -0,0 +1,93 @@
import 'package:latlong2/latlong.dart';
import '../entities/work_session_models.dart';
/// 自主作业的业务门面。
///
/// 一套页面功能,多套环境实现:
/// - A 环境(作业记录 + 任务池接口)→ PathPlanningWorkGateway
/// - B 环境(另一套后端 / 本地离线)→ 新增一个 implements 类即可,页面零改动
///
/// 约定:
/// 1. 所有方法与流都用 [WorkRunState] / [WorkTaskSnapshot] 表达,禁止把各自
/// 后端的原始实体、原始状态码泄漏到表现层;
/// 2. 能力差异通过 [capabilities] 声明,页面据此决定入口/按钮的可见与可用;
/// 3. 失败不抛异常,统一返回 [WorkResult.fail]。
abstract class AutonomousWorkGateway {
/// 环境标识(日志/排障用),如 path_planning / local_demo
String get gatewayId;
/// 当前环境支持哪些能力
WorkSceneCapabilities get capabilities;
/// 解析作业作用域(场站/组织)。不同环境来源不同:
/// A 环境取「当前选中场站」,B 环境可能取设备绑定信息或固定值。
Future<WorkScope> resolveScope({required String deviceId});
/// 路线库:一条记录 = 一条可执行路线
Future<WorkResult<List<WorkRouteOption>>> loadRoutes({required int siteId});
/// 补齐一条路线的完整几何(轨迹 + 作业区域边界),用于「选中即在地图上画线」。
///
/// 列表接口往往只返回元数据(A 环境 selectBySiteId 的 jsonData 可能是空标签),
/// 所以选中后要像路径规划那样按作业名回查一次详情。
/// 实现返回的路线 id 必须与入参一致,页面据此替换当前选中项。
Future<WorkResult<WorkRouteOption>> resolveRouteGeometry({
required String deviceId,
required WorkRouteOption route,
});
/// 任务队列:设备当前的活跃任务
Future<WorkResult<List<WorkTaskSnapshot>>> loadTasks({
required String deviceId,
});
/// 保存圈地结果(1:1 复刻路径规划「保存区域」链路)。
///
/// - [path]:作业几何;[outer]:作业区边界(自定义模式传空)
/// - [planModel]:0 = 覆盖模式、2 = 自定义模式(与 mode 字段同源)
/// - [imageBase64]:地图截图(jpg,不带 data url 前缀),截图失败传 null
///
/// 环境差异(接口地址/鉴权/截图是否必需)全部封在实现里,页面只负责取几何。
Future<WorkResult<bool>> saveRouteRecord({
required String deviceId,
required String name,
required List<LatLng> path,
required List<LatLng> outer,
required int planModel,
String? imageBase64,
});
/// 当前任务实时状态流(null 表示设备上没有活跃任务)
Stream<WorkTaskSnapshot?> watchTask({required String deviceId});
Future<WorkResult<WorkTaskSnapshot>> startWork(WorkStartRequest request);
Future<WorkResult<WorkTaskSnapshot>> pauseWork({
required String deviceId,
required WorkTaskSnapshot task,
});
Future<WorkResult<WorkTaskSnapshot>> resumeWork({
required String deviceId,
required WorkTaskSnapshot task,
});
Future<WorkResult<WorkTaskSnapshot>> stopWork({
required String deviceId,
required WorkTaskSnapshot task,
});
/// 只取消尚未执行的任务
Future<WorkResult<WorkTaskSnapshot>> cancelQueued({
required String deviceId,
required WorkTaskSnapshot task,
});
/// 把某条已有任务切成「当前任务」:任务队列里点选一条作业后,
/// 主窗口状态与地图路线都跟着切到它(对应路径规划点击列表项的行为)。
Future<WorkResult<WorkTaskSnapshot>> activateTask({
required String deviceId,
required WorkTaskSnapshot task,
});
}