自主任务接口接入和bug修复和工作记录页面
This commit is contained in:
41
lib/features/autonomous_work/data/v2_work_store.dart
Normal file
41
lib/features/autonomous_work/data/v2_work_store.dart
Normal file
@@ -0,0 +1,41 @@
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
/// 新版独立命名空间,不读取或覆盖旧路径规划的缓存。
|
||||
class V2WorkStore {
|
||||
V2WorkStore(this.owner);
|
||||
|
||||
final String owner;
|
||||
Future<void> _writes = Future<void>.value();
|
||||
|
||||
String _key(String name) => 'v2_work.${Uri.encodeComponent(owner)}.$name';
|
||||
|
||||
Future<Map<String, dynamic>?> read(String name) async {
|
||||
await _writes;
|
||||
final prefs = await SharedPreferences.getInstance();
|
||||
final raw = prefs.getString(_key(name));
|
||||
if (raw == null) return null;
|
||||
try {
|
||||
final decoded = jsonDecode(raw);
|
||||
return decoded is Map ? Map<String, dynamic>.from(decoded) : null;
|
||||
} on FormatException {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> write(String name, Map<String, dynamic>? value) {
|
||||
// 调用时即拍快照,避免异步写入前列表又被页面清空。
|
||||
final encoded = value == null ? null : jsonEncode(value);
|
||||
final write = _writes.then((_) async {
|
||||
final prefs = await SharedPreferences.getInstance();
|
||||
if (encoded == null) {
|
||||
await prefs.remove(_key(name));
|
||||
} else {
|
||||
await prefs.setString(_key(name), encoded);
|
||||
}
|
||||
});
|
||||
_writes = write.catchError((Object _) {});
|
||||
return write;
|
||||
}
|
||||
}
|
||||
924
lib/features/autonomous_work/data/v2_work_task_tracker.dart
Normal file
924
lib/features/autonomous_work/data/v2_work_task_tracker.dart
Normal file
@@ -0,0 +1,924 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:latlong2/latlong.dart';
|
||||
import '../../../core/logging/work_trace_diagnostics.dart';
|
||||
|
||||
import '../../../core/network/mqtt/data/infrastructure/mqtt_client_impl.dart';
|
||||
import '../../../core/network/mqtt/domain/interfaces/mqtt_client.dart';
|
||||
import '../../../core/network/mqtt/domain/models/mqtt_config.dart';
|
||||
import '../../../core/network/mqtt/domain/models/mqtt_message.dart';
|
||||
import '../../devices/domain/entities/device_task_entity.dart';
|
||||
import '../../devices/domain/repositories/device_task_repository.dart';
|
||||
import '../../devices/domain/usecases/create_device_task_usecase.dart';
|
||||
import '../domain/entities/work_session_models.dart';
|
||||
import 'v2_work_store.dart';
|
||||
|
||||
/// 新版专用任务状态。独立 MQTT 连接和缓存,不修改旧版 Cubit、订阅或完成标记。
|
||||
class V2WorkTaskTracker {
|
||||
V2WorkTaskTracker({
|
||||
required this.repository,
|
||||
required this.createTask,
|
||||
required this.resolveScope,
|
||||
required this.userId,
|
||||
required this.store,
|
||||
MqttClient? mqtt,
|
||||
WorkTraceDiagnostics? diagnostics,
|
||||
}) : mqtt = mqtt ?? MqttClientImpl(clientName: 'v2WorkTaskClient'),
|
||||
diagnostics = diagnostics ?? WorkTraceDiagnostics();
|
||||
|
||||
final DeviceTaskRepository repository;
|
||||
final CreateDeviceTaskUseCase createTask;
|
||||
final Future<WorkScope> Function(String deviceId) resolveScope;
|
||||
final String Function() userId;
|
||||
final V2WorkStore store;
|
||||
final MqttClient mqtt;
|
||||
final WorkTraceDiagnostics diagnostics;
|
||||
Timer? _traceSummaryTimer;
|
||||
final _topicReceived = <String, int>{};
|
||||
final _arriveAccepted = <String, int>{};
|
||||
final _lastTopicAt = <String, DateTime>{};
|
||||
|
||||
final _updates =
|
||||
StreamController<(String, WorkTaskSnapshot?, bool)>.broadcast(sync: true);
|
||||
final _active = <String, Map<String, WorkTaskSnapshot>>{};
|
||||
final _current = <String, WorkTaskSnapshot>{};
|
||||
final _history = <String, WorkTaskSnapshot>{};
|
||||
final _watchers = <String, int>{};
|
||||
final _topics = <String>{};
|
||||
final _pendingPool = <String, DateTime>{};
|
||||
StreamSubscription<MqttMessage>? _messages;
|
||||
Future<void> _mqttWork = Future<void>.value();
|
||||
Future<void>? _restored;
|
||||
int _revision = 0;
|
||||
|
||||
String _id(WorkTaskSnapshot task) => '${task.deviceId}/${task.taskId}';
|
||||
WorkTaskSnapshot? current(String deviceId) => _current[deviceId];
|
||||
|
||||
Stream<WorkTaskSnapshot?> watch(String deviceId, {bool allTasks = false}) {
|
||||
return Stream<WorkTaskSnapshot?>.multi((controller) {
|
||||
_watchers[deviceId] = (_watchers[deviceId] ?? 0) + 1;
|
||||
diagnostics.log('页面监听', {
|
||||
'deviceId': deviceId,
|
||||
'watchers': _watchers[deviceId],
|
||||
'allTasks': allTasks,
|
||||
});
|
||||
final subscription = _updates.stream
|
||||
.where((event) => event.$1 == deviceId && (allTasks || event.$3))
|
||||
.map((event) => event.$2)
|
||||
.listen(controller.add, onError: controller.addError);
|
||||
controller.add(_current[deviceId]);
|
||||
_scheduleMqtt();
|
||||
controller.onCancel = () async {
|
||||
await subscription.cancel();
|
||||
final count = (_watchers[deviceId] ?? 1) - 1;
|
||||
if (count == 0) {
|
||||
_watchers.remove(deviceId);
|
||||
} else {
|
||||
_watchers[deviceId] = count;
|
||||
}
|
||||
diagnostics.log('页面离开', {'deviceId': deviceId, 'watchers': count});
|
||||
_scheduleMqtt();
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
Future<void> _restore() => _restored ??= () async {
|
||||
final data = await store.read('tasks');
|
||||
for (final raw in (data?['history'] as List? ?? const [])) {
|
||||
final task = _decode(raw);
|
||||
if (task != null) _history[_id(task)] = task;
|
||||
}
|
||||
for (final raw in (data?['current'] as List? ?? const [])) {
|
||||
final task = _decode(raw);
|
||||
if (task != null) {
|
||||
_current.putIfAbsent(task.deviceId, () => task);
|
||||
final createdAt = DateTime.tryParse(task.createdAt ?? '');
|
||||
if (task.rawStatus == 'NEW' && createdAt != null) {
|
||||
_pendingPool[_id(task)] = createdAt;
|
||||
}
|
||||
}
|
||||
}
|
||||
}();
|
||||
|
||||
Future<WorkResult<List<WorkTaskSnapshot>>> load(String deviceId) async {
|
||||
try {
|
||||
await _restore();
|
||||
final scope = await resolveScope(deviceId);
|
||||
if (scope.siteId == null) {
|
||||
diagnostics.log('任务加载失败', {
|
||||
'deviceId': deviceId,
|
||||
'reason': '未选择场站,无法取得真实taskId并订阅',
|
||||
});
|
||||
return const WorkResult.fail('未选择场站');
|
||||
}
|
||||
final revision = _revision;
|
||||
final result = await repository.getDeviceTaskPool(
|
||||
userId: userId(),
|
||||
siteId: scope.siteId!,
|
||||
orgId: scope.orgId ?? 0,
|
||||
);
|
||||
return await result.fold(
|
||||
(failure) async {
|
||||
diagnostics.log('任务加载失败', {
|
||||
'deviceId': deviceId,
|
||||
'reason': failure.message,
|
||||
});
|
||||
return WorkResult.fail(failure.message);
|
||||
},
|
||||
(entities) async {
|
||||
// 请求期间若收到了推送,以更新的 MQTT 状态为准,避免慢响应复活已完成任务。
|
||||
final active = <String, WorkTaskSnapshot>{};
|
||||
for (final entity in entities.where((e) => e.deviceId == deviceId)) {
|
||||
final snapshot = _fromEntity(entity);
|
||||
if (snapshot == null) {
|
||||
diagnostics.log('任务池过滤', {
|
||||
'deviceId': deviceId,
|
||||
'taskId': entity.id,
|
||||
'status': entity.taskStatus,
|
||||
'reason': '无法识别任务状态',
|
||||
});
|
||||
continue;
|
||||
}
|
||||
final key = _id(snapshot);
|
||||
_pendingPool.remove(key);
|
||||
if (_history.containsKey(key)) continue;
|
||||
if (snapshot.state == WorkRunState.finished) {
|
||||
final existing =
|
||||
_active[deviceId]?[snapshot.taskId] ?? _current[deviceId];
|
||||
_history[key] = snapshot.copyWith(
|
||||
routeName: existing?.taskId == snapshot.taskId
|
||||
? existing?.routeName
|
||||
: null,
|
||||
completedPoints: existing?.taskId == snapshot.taskId
|
||||
? existing?.completedPoints
|
||||
: null,
|
||||
);
|
||||
diagnostics.log('结束任务池确认', {
|
||||
'deviceId': deviceId,
|
||||
'taskId': snapshot.taskId,
|
||||
'status': snapshot.rawStatus,
|
||||
'source': 'task_pool',
|
||||
'selected': _current[deviceId]?.taskId == snapshot.taskId,
|
||||
'note': '任务池返回结束态;此记录不代表收到了MQTT结束topic',
|
||||
});
|
||||
continue;
|
||||
}
|
||||
final previous =
|
||||
_active[deviceId]?[snapshot.taskId] ?? _current[deviceId];
|
||||
active[snapshot.taskId] = revision == _revision
|
||||
? _preserveStartedExecution(
|
||||
snapshot.copyWith(
|
||||
completedPoints: previous?.taskId == snapshot.taskId
|
||||
? previous?.completedPoints
|
||||
: null,
|
||||
routeName: previous?.taskId == snapshot.taskId
|
||||
? previous?.routeName
|
||||
: null,
|
||||
),
|
||||
previous?.taskId == snapshot.taskId ? previous : null,
|
||||
)
|
||||
: (_active[deviceId]?[snapshot.taskId] ?? snapshot);
|
||||
}
|
||||
if (revision != _revision) {
|
||||
for (final task
|
||||
in _active[deviceId]?.values ?? <WorkTaskSnapshot>[]) {
|
||||
if (!_history.containsKey(_id(task))) active[task.taskId] = task;
|
||||
}
|
||||
}
|
||||
final previous = _current[deviceId];
|
||||
// 新建任务可能尚未进入池,短暂空响应不能丢掉已经确认的 taskId。
|
||||
if (previous != null &&
|
||||
!_history.containsKey(_id(previous)) &&
|
||||
!active.containsKey(previous.taskId)) {
|
||||
final pendingAt = _pendingPool[_id(previous)];
|
||||
if (pendingAt != null &&
|
||||
DateTime.now().difference(pendingAt) <
|
||||
const Duration(seconds: 30)) {
|
||||
active[previous.taskId] = previous;
|
||||
}
|
||||
}
|
||||
_active[deviceId] = active;
|
||||
diagnostics.log('任务池', {
|
||||
'deviceId': deviceId,
|
||||
'poolRows': entities.length,
|
||||
'matchingDeviceRows': entities
|
||||
.where((e) => e.deviceId == deviceId)
|
||||
.length,
|
||||
'activeTasks': [
|
||||
for (final t in active.values)
|
||||
{
|
||||
'taskId': t.taskId,
|
||||
'status': t.rawStatus,
|
||||
'points': t.completedPoints.length,
|
||||
},
|
||||
],
|
||||
});
|
||||
WorkTaskSnapshot? selected = active[previous?.taskId];
|
||||
if (selected == null && active.isNotEmpty) {
|
||||
selected = active.values.firstWhere(
|
||||
(t) => t.state == WorkRunState.running,
|
||||
orElse: () => active.values.first,
|
||||
);
|
||||
}
|
||||
if (selected != null) _publish(selected, select: true);
|
||||
// 空池不复用旧 taskId;完成快照只供结束态展示。
|
||||
if (selected == null &&
|
||||
previous != null &&
|
||||
previous.state != WorkRunState.finished) {
|
||||
final terminal = _history[_id(previous)];
|
||||
if (terminal != null) {
|
||||
_publish(terminal, select: true, source: 'task_pool');
|
||||
} else {
|
||||
_current.remove(deviceId);
|
||||
_updates.add((deviceId, null, true));
|
||||
}
|
||||
}
|
||||
await _save();
|
||||
_scheduleMqtt();
|
||||
return WorkResult.ok(active.values.toList());
|
||||
},
|
||||
);
|
||||
} catch (e) {
|
||||
diagnostics.log('任务加载失败', {'deviceId': deviceId, 'reason': '$e'});
|
||||
return WorkResult.fail('任务加载失败:$e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<WorkResult<WorkTaskSnapshot>> start(WorkStartRequest request) async {
|
||||
try {
|
||||
await _restore();
|
||||
if (request.reuseTaskId != null) {
|
||||
final task = _active[request.deviceId]?[request.reuseTaskId];
|
||||
if (task == null) return const WorkResult.fail('任务已失效,请刷新任务队列');
|
||||
return select(task.copyWith(executionStarted: true));
|
||||
}
|
||||
final routeId = int.tryParse(request.route.id);
|
||||
final scope = await resolveScope(request.deviceId);
|
||||
final siteId = request.siteId ?? scope.siteId;
|
||||
if (routeId == null || siteId == null) {
|
||||
return const WorkResult.fail('路线或场站无效');
|
||||
}
|
||||
final result = await createTask.execute(
|
||||
deviceId: request.deviceId,
|
||||
routeId: routeId,
|
||||
siteId: siteId,
|
||||
orgId: request.orgId ?? scope.orgId ?? 0,
|
||||
);
|
||||
return await result.fold(
|
||||
(failure) async {
|
||||
// 创建响应丢失时先查池,不自动再创建;多条匹配任务交给用户选择。
|
||||
final loaded = await load(request.deviceId);
|
||||
final matches = (loaded.data ?? <WorkTaskSnapshot>[])
|
||||
.where((task) => task.routeId == request.route.id)
|
||||
.toList();
|
||||
if (matches.length == 1) return select(matches.single);
|
||||
return WorkResult.fail(failure.message);
|
||||
},
|
||||
(id) async {
|
||||
final task = WorkTaskSnapshot(
|
||||
taskId: '$id',
|
||||
deviceId: request.deviceId,
|
||||
state: WorkRunState.queued,
|
||||
routeId: request.route.id,
|
||||
routeName: request.route.name,
|
||||
rawStatus: 'NEW',
|
||||
executionStarted: true,
|
||||
createdAt: DateTime.now().toIso8601String(),
|
||||
extras: {
|
||||
'siteId': siteId,
|
||||
'orgId': request.orgId ?? scope.orgId ?? 0,
|
||||
},
|
||||
);
|
||||
_publish(task, select: true);
|
||||
_pendingPool[_id(task)] = DateTime.now();
|
||||
await _save();
|
||||
_scheduleMqtt();
|
||||
return WorkResult.ok(task);
|
||||
},
|
||||
);
|
||||
} catch (e) {
|
||||
return WorkResult.fail('任务下发失败:$e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<WorkResult<WorkTaskSnapshot>> select(WorkTaskSnapshot task) async {
|
||||
if (task.state == WorkRunState.finished ||
|
||||
_history.containsKey(_id(task))) {
|
||||
return const WorkResult.fail('该任务已结束,请刷新任务队列');
|
||||
}
|
||||
_publish(task, select: true);
|
||||
await _save();
|
||||
_scheduleMqtt();
|
||||
return WorkResult.ok(task);
|
||||
}
|
||||
|
||||
Future<WorkResult<WorkTaskSnapshot>> command(
|
||||
String deviceId,
|
||||
WorkTaskSnapshot task,
|
||||
String operation, {
|
||||
bool forceCancel = true,
|
||||
}) async {
|
||||
try {
|
||||
if (task.deviceId != deviceId || _history.containsKey(_id(task))) {
|
||||
return const WorkResult.fail('任务已结束或设备不匹配,请刷新后重试');
|
||||
}
|
||||
if (operation == 'cancel' &&
|
||||
!forceCancel &&
|
||||
task.state != WorkRunState.queued &&
|
||||
task.state != WorkRunState.failed) {
|
||||
return const WorkResult.fail('该任务已开始执行,请使用停止作业');
|
||||
}
|
||||
if (task.rawStatus == 'CANCELING' && operation != 'cancel') {
|
||||
return const WorkResult.fail('任务正在停止,请等待设备确认');
|
||||
}
|
||||
final id = int.tryParse(task.taskId);
|
||||
final scope = await resolveScope(deviceId);
|
||||
final siteId = (task.extras['siteId'] as int?) ?? scope.siteId;
|
||||
final orgId = (task.extras['orgId'] as int?) ?? scope.orgId ?? 0;
|
||||
if (id == null || siteId == null) return const WorkResult.fail('任务或场站无效');
|
||||
String? error;
|
||||
if (operation == 'pause') {
|
||||
final result = await repository.pauseTask(
|
||||
deviceId: deviceId,
|
||||
taskId: id,
|
||||
orgId: orgId,
|
||||
siteId: siteId,
|
||||
);
|
||||
result.fold((f) => error = f.message, (ok) {
|
||||
if (!ok) error = '暂停失败';
|
||||
});
|
||||
} else if (operation == 'resume') {
|
||||
final result = await repository.recoveryTask(
|
||||
deviceId: deviceId,
|
||||
taskId: id,
|
||||
orgId: orgId,
|
||||
siteId: siteId,
|
||||
);
|
||||
result.fold((f) => error = f.message, (_) {});
|
||||
} else {
|
||||
final result = await repository.cancelTask(
|
||||
deviceId: deviceId,
|
||||
taskId: id,
|
||||
orgId: orgId,
|
||||
siteId: siteId,
|
||||
forceCancel: forceCancel,
|
||||
);
|
||||
result.fold((f) => error = f.message, (ok) {
|
||||
if (!ok) error = '取消失败';
|
||||
});
|
||||
}
|
||||
if (error != null) return WorkResult.fail(error!);
|
||||
// API 等待过程中可能先收到 FINISH,不能再被本地乐观态覆盖。
|
||||
final latest =
|
||||
_history[_id(task)] ?? _active[deviceId]?[task.taskId] ?? task;
|
||||
if (latest.state == WorkRunState.finished) return WorkResult.ok(latest);
|
||||
final updated = latest.copyWith(
|
||||
state: operation == 'pause'
|
||||
? WorkRunState.paused
|
||||
: operation == 'resume'
|
||||
? WorkRunState.running
|
||||
: WorkRunState.finished,
|
||||
rawStatus: operation == 'pause'
|
||||
? 'PAUSE'
|
||||
: operation == 'resume'
|
||||
? 'EXECUTING'
|
||||
: 'CANCELED',
|
||||
);
|
||||
_publish(
|
||||
updated,
|
||||
select: _current[deviceId]?.taskId == task.taskId,
|
||||
source: 'http_$operation',
|
||||
);
|
||||
await _save();
|
||||
_scheduleMqtt();
|
||||
return WorkResult.ok(updated);
|
||||
} catch (e) {
|
||||
return WorkResult.fail('任务操作失败:$e');
|
||||
}
|
||||
}
|
||||
|
||||
void _publish(
|
||||
WorkTaskSnapshot task, {
|
||||
bool select = false,
|
||||
String source = 'snapshot',
|
||||
String? topic,
|
||||
}) {
|
||||
if ((task.state == WorkRunState.running ||
|
||||
task.state == WorkRunState.paused) &&
|
||||
!task.executionStarted) {
|
||||
task = task.copyWith(executionStarted: true);
|
||||
}
|
||||
_revision++;
|
||||
final tasks = _active.putIfAbsent(task.deviceId, () => {});
|
||||
if (task.state == WorkRunState.finished) {
|
||||
tasks.remove(task.taskId);
|
||||
_history[_id(task)] = task;
|
||||
} else {
|
||||
tasks[task.taskId] = task;
|
||||
}
|
||||
if (select || _current[task.deviceId]?.taskId == task.taskId) {
|
||||
_current[task.deviceId] = task;
|
||||
}
|
||||
if (task.state == WorkRunState.finished) {
|
||||
diagnostics.log('结束状态落地', {
|
||||
'deviceId': task.deviceId,
|
||||
'taskId': task.taskId,
|
||||
'status': task.rawStatus,
|
||||
'source': source,
|
||||
'topic': topic,
|
||||
'points': task.completedPoints.length,
|
||||
'selected': _current[task.deviceId]?.taskId == task.taskId,
|
||||
'removedFromActive': !tasks.containsKey(task.taskId),
|
||||
'inHistory': _history.containsKey(_id(task)),
|
||||
'note': source.startsWith('http_')
|
||||
? '本地HTTP操作结果,不代表已收到设备结束topic'
|
||||
: source == 'task_pool'
|
||||
? '通过任务池查询确认结束'
|
||||
: '结束快照已写入本地状态,将通知页面',
|
||||
});
|
||||
}
|
||||
diagnostics.log(
|
||||
'任务快照',
|
||||
{
|
||||
'deviceId': task.deviceId,
|
||||
'taskId': task.taskId,
|
||||
'status': task.rawStatus,
|
||||
'state': task.state.name,
|
||||
'executionStarted': task.executionStarted,
|
||||
'canRecordTrace': task.canRecordTrace,
|
||||
'points': task.completedPoints.length,
|
||||
'selected': _current[task.deviceId]?.taskId == task.taskId,
|
||||
},
|
||||
sampleKey:
|
||||
'snapshot/${_id(task)}/${task.state.name}/${task.completedPoints.length < 2 ? task.completedPoints.length : "2+"}',
|
||||
);
|
||||
_updates.add((
|
||||
task.deviceId,
|
||||
task,
|
||||
_current[task.deviceId]?.taskId == task.taskId,
|
||||
));
|
||||
}
|
||||
|
||||
WorkTaskSnapshot _preserveStartedExecution(
|
||||
WorkTaskSnapshot incoming,
|
||||
WorkTaskSnapshot? previous,
|
||||
) {
|
||||
final started =
|
||||
incoming.executionStarted || (previous?.executionStarted ?? false);
|
||||
if (started &&
|
||||
incoming.state == WorkRunState.queued &&
|
||||
previous != null &&
|
||||
previous.state != WorkRunState.queued &&
|
||||
previous.state != WorkRunState.idle) {
|
||||
diagnostics.log('状态合并', {
|
||||
'deviceId': incoming.deviceId,
|
||||
'taskId': incoming.taskId,
|
||||
'receivedStatus': incoming.rawStatus,
|
||||
'keptStatus': previous.rawStatus,
|
||||
'reason': '任务已确认开始,忽略延迟NEW回退,保留暂停/执行状态',
|
||||
});
|
||||
return incoming.copyWith(
|
||||
state: previous.state,
|
||||
rawStatus: previous.rawStatus,
|
||||
executionStarted: true,
|
||||
);
|
||||
}
|
||||
return incoming.copyWith(executionStarted: started);
|
||||
}
|
||||
|
||||
void _scheduleMqtt() {
|
||||
_mqttWork = _mqttWork
|
||||
.then((_) async {
|
||||
final wanted = <String>{};
|
||||
for (final device in _watchers.keys) {
|
||||
for (final task
|
||||
in _active[device]?.values ?? <WorkTaskSnapshot>[]) {
|
||||
wanted.addAll([
|
||||
'task/${task.taskId}/status',
|
||||
'task/${task.taskId}/arrive',
|
||||
]);
|
||||
}
|
||||
}
|
||||
if (wanted.isEmpty) {
|
||||
if (_watchers.isNotEmpty) {
|
||||
diagnostics.log('订阅等待', {
|
||||
'devices': _watchers.keys.toList(),
|
||||
'reason': '当前没有可订阅的活跃taskId,请查看任务池及任务加载失败日志',
|
||||
}, sampleKey: 'waiting-for-task');
|
||||
}
|
||||
_traceSummaryTimer?.cancel();
|
||||
_traceSummaryTimer = null;
|
||||
if (_topics.isNotEmpty) {
|
||||
diagnostics.log('停止订阅', {
|
||||
'reason': '无活跃任务或页面监听',
|
||||
'topics': _topics.toList(),
|
||||
});
|
||||
}
|
||||
for (final topic in _topics.toList()) {
|
||||
await mqtt.unsubscribe(topic);
|
||||
}
|
||||
_topics.clear();
|
||||
_topicReceived.clear();
|
||||
_arriveAccepted.clear();
|
||||
_lastTopicAt.clear();
|
||||
diagnostics.clear();
|
||||
await _messages?.cancel();
|
||||
_messages = null;
|
||||
await mqtt.disconnect();
|
||||
return;
|
||||
}
|
||||
if (!setEquals(wanted, _topics) || !mqtt.isConnected) {
|
||||
diagnostics.log('订阅登记', {
|
||||
'connected': mqtt.isConnected,
|
||||
'topics': wanted.toList(),
|
||||
'messageStreamAvailable': mqtt.messageStream != null,
|
||||
'note': '实际订阅确认请同时查看 v2WorkTaskClient 的订阅确认成功日志',
|
||||
});
|
||||
}
|
||||
_traceSummaryTimer ??= Timer.periodic(
|
||||
const Duration(seconds: 10),
|
||||
(_) => _logTraceSummary(),
|
||||
);
|
||||
_messages ??= mqtt.messageStream?.listen(_onMessage);
|
||||
for (final topic in _topics.difference(wanted).toList()) {
|
||||
await mqtt.unsubscribe(topic);
|
||||
_topics.remove(topic);
|
||||
_topicReceived.remove(topic);
|
||||
_arriveAccepted.remove(topic);
|
||||
_lastTopicAt.remove(topic);
|
||||
}
|
||||
for (final topic in wanted.difference(_topics)) {
|
||||
await mqtt.subscribe(topic);
|
||||
_topics.add(topic);
|
||||
}
|
||||
if (!mqtt.isConnected) {
|
||||
await mqtt.connect(
|
||||
MqttConfig.taskMessage().copyWith(clientId: 'v2_work_task'),
|
||||
);
|
||||
}
|
||||
})
|
||||
.catchError((Object error) {
|
||||
diagnostics.log('连接异常', {
|
||||
'error': '$error',
|
||||
'connected': mqtt.isConnected,
|
||||
'topics': _topics.toList(),
|
||||
});
|
||||
debugPrint('[V2WorkTask] MQTT订阅失败,连接层将重试: $error');
|
||||
});
|
||||
}
|
||||
|
||||
void _logTraceSummary() {
|
||||
for (final device in _watchers.keys) {
|
||||
for (final task in _active[device]?.values ?? <WorkTaskSnapshot>[]) {
|
||||
final topic = 'task/${task.taskId}/arrive';
|
||||
final received = _topicReceived[topic] ?? 0;
|
||||
final accepted = _arriveAccepted[topic] ?? 0;
|
||||
diagnostics.log('接收摘要', {
|
||||
'deviceId': device,
|
||||
'taskId': task.taskId,
|
||||
'topic': topic,
|
||||
'connected': mqtt.isConnected,
|
||||
'registered': _topics.contains(topic),
|
||||
'listening': _messages != null,
|
||||
'statusTopic': 'task/${task.taskId}/status',
|
||||
'statusReceived': _topicReceived['task/${task.taskId}/status'] ?? 0,
|
||||
'status': task.rawStatus,
|
||||
'state': task.state.name,
|
||||
'executionStarted': task.executionStarted,
|
||||
'canRecordTrace': task.canRecordTrace,
|
||||
'received': received,
|
||||
'accepted': accepted,
|
||||
'points': task.completedPoints.length,
|
||||
'lastArriveAt': _lastTopicAt[topic]?.toIso8601String(),
|
||||
'secondsSinceLastArrive': _lastTopicAt[topic] == null
|
||||
? null
|
||||
: DateTime.now().difference(_lastTopicAt[topic]!).inSeconds,
|
||||
'selected': _current[device]?.taskId == task.taskId,
|
||||
'hint': received == 0
|
||||
? '当前订阅周期内未收到此到达点 topic;先检查订阅确认、任务ID和服务端推送'
|
||||
: accepted == 0
|
||||
? '收到过到达点消息但未追加轨迹,请查看过滤原因'
|
||||
: task.completedPoints.length < 2
|
||||
? '已收到到达点,地图会接入车辆最新定位,请核对地图画线日志'
|
||||
: '轨迹已有点,请核对页面和地图日志',
|
||||
});
|
||||
diagnostics.log('结束确认等待', {
|
||||
'deviceId': device,
|
||||
'taskId': task.taskId,
|
||||
'status': task.rawStatus,
|
||||
'connected': mqtt.isConnected,
|
||||
'statusTopic': 'task/${task.taskId}/status',
|
||||
'arriveTopic': topic,
|
||||
'statusReceived': _topicReceived['task/${task.taskId}/status'] ?? 0,
|
||||
'arriveReceived': received,
|
||||
'lastStatusAt': _lastTopicAt['task/${task.taskId}/status']
|
||||
?.toIso8601String(),
|
||||
'lastArriveAt': _lastTopicAt[topic]?.toIso8601String(),
|
||||
'note': '任务仍在活跃列表,尚未确认结束;消息长期不更新需核对连接和服务端状态,不能据此直接判定完成或卡死',
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void _onMessage(MqttMessage message) {
|
||||
diagnostics.log(
|
||||
'MQTT收到',
|
||||
{'topic': message.topic, 'payload': message.payload},
|
||||
sampleKey: message.topic.endsWith('/status')
|
||||
? null
|
||||
: 'raw/${message.topic}',
|
||||
);
|
||||
final parts = message.topic.split('/');
|
||||
if (parts.length != 3 ||
|
||||
parts.first != 'task' ||
|
||||
!_topics.contains(message.topic)) {
|
||||
diagnostics.log('过滤', {
|
||||
'topic': message.topic,
|
||||
'reason': 'topic格式不符或不在当前订阅列表',
|
||||
}, sampleKey: 'topic/${message.topic}');
|
||||
return;
|
||||
}
|
||||
_topicReceived.update(message.topic, (v) => v + 1, ifAbsent: () => 1);
|
||||
_lastTopicAt[message.topic] = DateTime.now();
|
||||
String? terminalSource;
|
||||
void rejected(String reason, [Map<String, Object?> fields = const {}]) {
|
||||
diagnostics.log('过滤', {
|
||||
'topic': message.topic,
|
||||
'reason': reason,
|
||||
...fields,
|
||||
}, sampleKey: 'reject/${message.topic}/$reason');
|
||||
if (terminalSource != null) {
|
||||
diagnostics.log('结束消息过滤', {
|
||||
'topic': message.topic,
|
||||
'topicTaskId': parts[1],
|
||||
'source': terminalSource,
|
||||
'reason': reason,
|
||||
...fields,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
final data = jsonDecode(message.payload) as Map<String, dynamic>;
|
||||
final rawStatus = data['status']?.toString().toUpperCase() ?? '';
|
||||
if (parts[2] == 'status' &&
|
||||
stateFromStatus(rawStatus) == WorkRunState.finished) {
|
||||
terminalSource = 'mqtt_status';
|
||||
} else if (parts[2] == 'arrive' &&
|
||||
data['type'] == 'device_task_arrive_point' &&
|
||||
data['entity'] == null) {
|
||||
terminalSource = 'mqtt_arrive_empty';
|
||||
}
|
||||
if (terminalSource != null) {
|
||||
diagnostics.log('结束消息收到', {
|
||||
'topic': message.topic,
|
||||
'topicTaskId': parts[1],
|
||||
'taskId': data['taskId'],
|
||||
'deviceId': data['deviceId'],
|
||||
'source': terminalSource,
|
||||
'status': rawStatus,
|
||||
'entityPresent': data.containsKey('entity'),
|
||||
'payload': message.payload,
|
||||
'note': '原始结束信号已收到,是否接受还要看后续过滤和结束状态落地日志',
|
||||
});
|
||||
}
|
||||
WorkTaskSnapshot? task;
|
||||
for (final device in _watchers.keys) {
|
||||
final candidate = _active[device]?[parts[1]];
|
||||
if (candidate != null) {
|
||||
task = candidate;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (task == null) {
|
||||
rejected(
|
||||
_history.values.any((t) => t.taskId == parts[1])
|
||||
? '任务已结束,忽略重复或迟到消息'
|
||||
: '未找到此topic对应的活跃任务',
|
||||
);
|
||||
return;
|
||||
}
|
||||
if (data['taskId'] != null && '${data['taskId']}' != task.taskId) {
|
||||
rejected('消息taskId与topic任务不一致', {
|
||||
'expectedTaskId': task.taskId,
|
||||
'receivedTaskId': data['taskId'],
|
||||
});
|
||||
return;
|
||||
}
|
||||
final device = data['deviceId']?.toString() ?? '';
|
||||
if (device.isNotEmpty && device != task.deviceId) {
|
||||
rejected('deviceId不匹配', {
|
||||
'expectedDeviceId': task.deviceId,
|
||||
'receivedDeviceId': device,
|
||||
});
|
||||
return;
|
||||
}
|
||||
WorkTaskSnapshot? updated;
|
||||
if (parts[2] == 'status') {
|
||||
final raw = data['status']?.toString().toUpperCase() ?? '';
|
||||
final state = stateFromStatus(raw);
|
||||
if (state == null) {
|
||||
rejected('无法识别任务状态', {'status': raw});
|
||||
return;
|
||||
}
|
||||
diagnostics.log('状态收到', {
|
||||
'topic': message.topic,
|
||||
'deviceId': task.deviceId,
|
||||
'taskId': task.taskId,
|
||||
'before': task.rawStatus,
|
||||
'after': raw,
|
||||
});
|
||||
updated = _preserveStartedExecution(
|
||||
task.copyWith(state: state, rawStatus: raw),
|
||||
task,
|
||||
);
|
||||
} else if (parts[2] == 'arrive') {
|
||||
if (data['type'] != 'device_task_arrive_point') {
|
||||
rejected('到达点type不匹配', {'type': data['type']});
|
||||
return;
|
||||
}
|
||||
final location = data['entity'];
|
||||
if (location == null) {
|
||||
diagnostics.log('空点结束', {
|
||||
'topic': message.topic,
|
||||
'deviceId': task.deviceId,
|
||||
'taskId': task.taskId,
|
||||
'note': 'entity为空,按原有协议处理为任务结束',
|
||||
});
|
||||
// 与旧版约定一致:空到达点表示任务结束。
|
||||
updated = task.copyWith(
|
||||
state: WorkRunState.finished,
|
||||
rawStatus: 'FINISH',
|
||||
);
|
||||
} else if (location is! Map) {
|
||||
rejected('entity不是坐标对象');
|
||||
return;
|
||||
} else if (task.state != WorkRunState.running &&
|
||||
task.state != WorkRunState.queued) {
|
||||
rejected('任务已暂停或中断,不追加到达点', {
|
||||
'status': task.rawStatus,
|
||||
'state': task.state.name,
|
||||
'note': 'NEW延迟不拦截有效到达点;暂停和中断仍冻结轨迹',
|
||||
});
|
||||
return;
|
||||
} else {
|
||||
final lat = double.tryParse('${location['lat']}');
|
||||
final lng = double.tryParse('${location['lng'] ?? location['lon']}');
|
||||
if (lat == null ||
|
||||
lng == null ||
|
||||
!lat.isFinite ||
|
||||
!lng.isFinite ||
|
||||
lat == 0 ||
|
||||
lng == 0 ||
|
||||
lat.abs() > 90 ||
|
||||
lng.abs() > 180) {
|
||||
rejected('坐标为空、非数值、零或超出范围', {
|
||||
'lat': location['lat'],
|
||||
'lng': location['lng'] ?? location['lon'],
|
||||
});
|
||||
return;
|
||||
}
|
||||
final point = LatLng(lat, lng);
|
||||
if (task.completedPoints.isNotEmpty &&
|
||||
task.completedPoints.last == point) {
|
||||
rejected('与上一轨迹点重复', {'lat': lat, 'lng': lng});
|
||||
return;
|
||||
}
|
||||
updated = task.copyWith(
|
||||
completedPoints: [...task.completedPoints, point],
|
||||
executionStarted: true,
|
||||
);
|
||||
_arriveAccepted.update(
|
||||
message.topic,
|
||||
(v) => v + 1,
|
||||
ifAbsent: () => 1,
|
||||
);
|
||||
diagnostics.log(
|
||||
'轨迹追加',
|
||||
{
|
||||
'topic': message.topic,
|
||||
'deviceId': task.deviceId,
|
||||
'taskId': task.taskId,
|
||||
'lat': lat,
|
||||
'lng': lng,
|
||||
'points': updated.completedPoints.length,
|
||||
'selected': _current[task.deviceId]?.taskId == task.taskId,
|
||||
},
|
||||
sampleKey:
|
||||
'accept/${message.topic}/${updated.completedPoints.length < 2 ? "1" : "2+"}',
|
||||
);
|
||||
}
|
||||
}
|
||||
if (updated == null) return;
|
||||
_publish(
|
||||
updated,
|
||||
source: terminalSource ?? 'mqtt_update',
|
||||
topic: message.topic,
|
||||
);
|
||||
unawaited(
|
||||
_save().catchError((Object error) {
|
||||
debugPrint('[V2WorkTask] 缓存失败: $error');
|
||||
}),
|
||||
);
|
||||
_scheduleMqtt();
|
||||
} catch (e) {
|
||||
diagnostics.log('解析失败', {
|
||||
'topic': message.topic,
|
||||
'error': '$e',
|
||||
}, sampleKey: 'parse/${message.topic}');
|
||||
debugPrint('[V2WorkTask] 忽略无效任务消息: $e');
|
||||
}
|
||||
}
|
||||
|
||||
Future<List<WorkTaskSnapshot>> history(String deviceId) async {
|
||||
await _restore();
|
||||
return _history.values
|
||||
.where((t) => t.deviceId == deviceId)
|
||||
.toList()
|
||||
.reversed
|
||||
.toList();
|
||||
}
|
||||
|
||||
Future<void> _save() => store
|
||||
.write('tasks', {
|
||||
'current': [
|
||||
for (final task in _current.values.where(
|
||||
(t) => t.state != WorkRunState.finished,
|
||||
))
|
||||
_encode(task),
|
||||
],
|
||||
'history': [for (final task in _history.values) _encode(task)],
|
||||
})
|
||||
.catchError((Object error) {
|
||||
debugPrint('[V2WorkTask] 缓存失败,不影响任务订阅: $error');
|
||||
});
|
||||
|
||||
static Map<String, dynamic> _encode(WorkTaskSnapshot task) => {
|
||||
'taskId': task.taskId,
|
||||
'deviceId': task.deviceId,
|
||||
'state': task.state.name,
|
||||
'rawStatus': task.rawStatus,
|
||||
'executionStarted': task.executionStarted,
|
||||
'routeId': task.routeId,
|
||||
'routeName': task.routeName,
|
||||
'createdAt': task.createdAt,
|
||||
'extras': task.extras,
|
||||
'completedPoints': [
|
||||
for (final p in task.completedPoints)
|
||||
{'lat': p.latitude, 'lng': p.longitude},
|
||||
],
|
||||
};
|
||||
|
||||
static WorkTaskSnapshot? _decode(dynamic raw) {
|
||||
if (raw is! Map || raw['taskId'] == null || raw['deviceId'] == null) {
|
||||
return null;
|
||||
}
|
||||
return WorkTaskSnapshot(
|
||||
taskId: '${raw['taskId']}',
|
||||
deviceId: '${raw['deviceId']}',
|
||||
state: stateFromStatus('${raw['rawStatus']}') ?? WorkRunState.queued,
|
||||
executionStarted:
|
||||
raw['executionStarted'] == true ||
|
||||
raw['rawStatus'] == 'EXECUTING' ||
|
||||
raw['rawStatus'] == 'PAUSE' ||
|
||||
(raw['completedPoints'] is List &&
|
||||
(raw['completedPoints'] as List).isNotEmpty),
|
||||
rawStatus: '${raw['rawStatus']}',
|
||||
routeId: raw['routeId'] as String?,
|
||||
routeName: raw['routeName'] as String?,
|
||||
createdAt: raw['createdAt'] as String?,
|
||||
extras: Map<String, dynamic>.from(raw['extras'] as Map? ?? {}),
|
||||
completedPoints: [
|
||||
for (final p in raw['completedPoints'] as List? ?? [])
|
||||
LatLng((p['lat'] as num).toDouble(), (p['lng'] as num).toDouble()),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
static WorkRunState? stateFromStatus(String status) => switch (status) {
|
||||
'NEW' => WorkRunState.queued,
|
||||
'EXECUTING' => WorkRunState.running,
|
||||
'PAUSE' => WorkRunState.paused,
|
||||
'FAILED' || 'CANCELING' => WorkRunState.failed,
|
||||
'FINISH' || 'CANCELED' || 'CANCELLED' => WorkRunState.finished,
|
||||
_ => null,
|
||||
};
|
||||
|
||||
static WorkTaskSnapshot? _fromEntity(DeviceTaskEntity task) {
|
||||
final state = stateFromStatus(task.taskStatus);
|
||||
if (state == null) return null;
|
||||
return WorkTaskSnapshot(
|
||||
taskId: '${task.id}',
|
||||
deviceId: task.deviceId,
|
||||
state: state,
|
||||
executionStarted:
|
||||
state == WorkRunState.running || state == WorkRunState.paused,
|
||||
rawStatus: task.taskStatus,
|
||||
routeId: task.routeId?.toString(),
|
||||
createdAt: task.createTime,
|
||||
extras: {'siteId': task.siteId, 'orgId': task.orgId},
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user