747 lines
27 KiB
Dart
747 lines
27 KiB
Dart
import 'dart:convert';
|
||
import 'dart:collection';
|
||
|
||
import 'package:flutter/rendering.dart';
|
||
import 'package:flutter_bloc/flutter_bloc.dart';
|
||
import 'package:get_it/get_it.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/entities/device_entity.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/repositories/device_repository.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/usecases/generate_path_usecase.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/usecases/get_user_device_usecase.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/data/models/work_record_entity.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/usecases/save_work_record_usecase.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/usecases/select_work_record_usecase.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/usecases/unbind_device_usecase.dart';
|
||
import 'package:maibu_satabot_v2/features/devices/domain/usecases/update_devicename_usecase.dart';
|
||
|
||
import '../../../../core/consts/tcp_consts.dart';
|
||
import '../../../../core/logging/i_logger_service.dart';
|
||
import '../../../../core/logging/log_time.dart';
|
||
import '../../../../core/network/tcp/tcp_client.dart';
|
||
import '../../../../core/network/mqtt/domain/repositories/task_message_repository.dart';
|
||
import '../../data/models/device_add_path_point_model.dart';
|
||
import '../../data/models/device_work_area_param_model.dart';
|
||
import '../../domain/usecases/bind_device_usecase.dart';
|
||
import '../../domain/usecases/delete_work_record_usecase.dart';
|
||
import '../../domain/usecases/get_device_location_usecase.dart';
|
||
import '../../domain/usecases/get_work_record_usecase.dart';
|
||
import '../../domain/usecases/get_work_records_by_site_id_usecase.dart';
|
||
import '../../domain/usecases/route_planning_usecase.dart';
|
||
import '../../services/path_planning_service.dart';
|
||
import 'device_status_bloc.dart';
|
||
import 'device_status_event.dart';
|
||
import 'devices_state.dart';
|
||
|
||
// 定义全局的TaskMessageRepository获取方式
|
||
TaskMessageRepository get _taskMessageRepo => GetIt.I<TaskMessageRepository>();
|
||
|
||
class DevicesCubit extends Cubit<DevicesState> {
|
||
final GetUserDeviceUseCase _getUserDeviceUseCase;
|
||
final GetDeviceLocationUseCase _getDeviceLocationUseCase;
|
||
final DeviceRepository repository;
|
||
final GetWorkRecordUseCase _getWorkRecordUseCase;
|
||
final GetWorkRecordsBySiteIdUseCase _getWorkRecordsBySiteIdUseCase;
|
||
final DeleteWorkRecordUseCase _deleteWorkRecordUseCase;
|
||
final BindDeviceUseCase _bindDeviceUseCase;
|
||
final UnbindDeviceUseCase _unbindDeviceUseCase;
|
||
final UpdateDevicenameUsecase _updateDevicename;
|
||
final SelectWorkRecordUseCase _selectWorkRecordUseCase;
|
||
final SaveWorkRecordUseCase _saveWorkRecordUseCase;
|
||
final GeneratePathUseCase _generatePathUseCase;
|
||
final RoutePlanningUseCase _routePlanningUseCase; //
|
||
final DeviceStatusBloc _deviceStatusBloc; // 🔥 新增字段
|
||
final TcpClient _tcpClient;
|
||
// 🔥 关键：注入全局服务
|
||
final PathPlanningService _pathPlanningService;
|
||
|
||
final ILoggerService _logger = GetIt.I<ILoggerService>();
|
||
|
||
DevicesCubit(
|
||
this.repository,
|
||
this._getUserDeviceUseCase,
|
||
this._getDeviceLocationUseCase,
|
||
this._getWorkRecordUseCase,
|
||
this._getWorkRecordsBySiteIdUseCase,
|
||
this._deleteWorkRecordUseCase,
|
||
this._unbindDeviceUseCase,
|
||
this._updateDevicename,
|
||
this._selectWorkRecordUseCase,
|
||
this._saveWorkRecordUseCase,
|
||
this._generatePathUseCase,
|
||
this._routePlanningUseCase,
|
||
this._bindDeviceUseCase,
|
||
this._deviceStatusBloc,
|
||
this._tcpClient,
|
||
this._pathPlanningService,
|
||
) : super(const DevicesState());
|
||
|
||
Future<void> unbindDevice(String deviceId, String deviceName) async {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: true,
|
||
errorMessage: '',
|
||
operationType: DeviceOperationType.unbind,
|
||
),
|
||
);
|
||
|
||
try {
|
||
final params = UnbindDeviceParams(deviceId, deviceName);
|
||
final result = await _unbindDeviceUseCase.call(params);
|
||
|
||
result.fold(
|
||
(failure) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '解绑设备失败',
|
||
operationType: DeviceOperationType.none, // 操作结束重置
|
||
),
|
||
),
|
||
(successCode) {
|
||
// 核心修复：int 转 bool 条件判断
|
||
final isSuccess = successCode == 1; // 显式转为 bool
|
||
if (isSuccess) {
|
||
final updatedDevices = state.devices?.where((device) {
|
||
return device.deviceName != deviceId;
|
||
}).toList();
|
||
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
devices: updatedDevices,
|
||
selectedDevice: state.selectedDevice?.deviceName == deviceId
|
||
? null
|
||
: state.selectedDevice,
|
||
errorMessage: '',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
);
|
||
} else {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: '解绑失败：状态码 $successCode',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
);
|
||
}
|
||
},
|
||
);
|
||
} catch (e) {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: '解绑异常：${e.toString()}',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
Future<void> updateDeviceName(String deviceId, String deviceName) async {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: true,
|
||
errorMessage: '',
|
||
operationType: DeviceOperationType.updateName,
|
||
),
|
||
);
|
||
|
||
try {
|
||
final params = UpdateDevicenameParams(deviceId, deviceName);
|
||
final result = await _updateDevicename.call(params);
|
||
|
||
result.fold(
|
||
(failure) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '更新设备名称失败',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
),
|
||
(successCode) {
|
||
// 核心修复：int 转 bool 条件判断
|
||
//print('更新设备名称结果代码: $successCode'); // 调试输出结果代码
|
||
_logger.logWithLevel('更新设备名称结果代码: $successCode');
|
||
final isSuccess = successCode == 1; // 显式转为 bool
|
||
if (isSuccess) {
|
||
//final updatedDevices = state.devices?.map((device) {
|
||
// return device.deviceName == deviceId ? device.copyWith(deviceName: deviceName) : device;
|
||
//}).toList();
|
||
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
//devices: updatedDevices,
|
||
//selectedDevice: state.selectedDevice?.deviceName == deviceId ? state.selectedDevice?.copyWith(deviceName: deviceName) : state.selectedDevice,
|
||
errorMessage: '',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
);
|
||
} else {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: '更新设备名称失败：状态码 $successCode',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
);
|
||
}
|
||
},
|
||
);
|
||
} catch (e) {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: '更新设备名称异常：${e.toString()}',
|
||
operationType: DeviceOperationType.none,
|
||
),
|
||
);
|
||
}
|
||
}
|
||
|
||
// 获取所有设备列表
|
||
// 获取所有设备列表
|
||
Future<void> fetchAllDevices(String username) async {
|
||
emit(state.copyWith(isLoading: true));
|
||
|
||
try {
|
||
// 🔥 关键步骤1：记录刷新前的选中设备标识（用 deviceName 作为唯一标识）
|
||
final String? oldSelectedDeviceName = state.selectedDevice?.deviceName;
|
||
|
||
// 网络请求获取新列表
|
||
var resultEither = await _getUserDeviceUseCase.call(
|
||
GetUserDeviceParams(username),
|
||
);
|
||
|
||
resultEither.fold(
|
||
(failure) => emit(
|
||
state.copyWith(isLoading: false, errorMessage: failure.message),
|
||
),
|
||
(deviceList) {
|
||
// 🔥 关键步骤2：匹配新列表中对应的旧选中设备
|
||
DeviceEntity? newSelectedDevice;
|
||
if (oldSelectedDeviceName != null && deviceList.isNotEmpty) {
|
||
// 在新列表中查找和旧选中设备名称一致的设备
|
||
newSelectedDevice = deviceList.firstWhere(
|
||
(device) => device.deviceName == oldSelectedDeviceName,
|
||
// 如果找不到（如设备已解绑），返回 null
|
||
orElse: () => deviceList.first, // 兜底：选中第一个
|
||
);
|
||
} else {
|
||
// 无旧选中设备，默认选中第一个
|
||
newSelectedDevice = deviceList.isNotEmpty ? deviceList.first : null;
|
||
}
|
||
|
||
// 🔥 关键步骤3：更新状态，使用匹配后的选中设备
|
||
emit(
|
||
state.copyWith(
|
||
devices: deviceList,
|
||
selectedDevice: newSelectedDevice, // 保留旧选中设备
|
||
isLoading: false,
|
||
),
|
||
);
|
||
},
|
||
);
|
||
} catch (e) {
|
||
emit(state.copyWith(isLoading: false, errorMessage: e.toString()));
|
||
}
|
||
}
|
||
|
||
// 切换当前选中的设备
|
||
void selectDevice(DeviceEntity device) {
|
||
emit(state.copyWith(selectedDevice: device));
|
||
}
|
||
|
||
// 更新单个设备的状态（例如从 Tcp 收到实时电量更新）
|
||
void updateDeviceStatus(DeviceEntity updatedDevice) {
|
||
final newList = state.devices.map((d) {
|
||
return d.deviceName == updatedDevice.deviceName ? updatedDevice : d;
|
||
}).toList();
|
||
|
||
// 如果更新的是当前选中的设备，也要同步更新 selectedDevice
|
||
final newSelected =
|
||
state.selectedDevice?.deviceName == updatedDevice.deviceName
|
||
? updatedDevice
|
||
: state.selectedDevice;
|
||
|
||
emit(state.copyWith(devices: newList, selectedDevice: newSelected));
|
||
}
|
||
|
||
/// 切换设备
|
||
Future<void> switchDevice(DeviceEntity device) async {
|
||
debugPrint('${LogTime.now()} 👆 [DevicesCubit] 开始切换设备: ${device.deviceName}');
|
||
// 保持现有列表，只改 loading
|
||
emit(state.copyWith(isLoading: true));
|
||
|
||
final result = await repository.switchDevice("app", device.deviceName);
|
||
|
||
result.fold(
|
||
// 失败处理
|
||
(l) {
|
||
debugPrint('${LogTime.now()} ❌ [DevicesCubit] 切换设备失败: ${device.deviceName}, 原因: ${l.message}');
|
||
emit(state.copyWith(isLoading: false, errorMessage: l.message));
|
||
selectDevice(device);
|
||
},
|
||
// 成功处理：改为 async 函数块
|
||
(r) async {
|
||
// 🔥 关键修复：不再断开 TCP 并重新连接
|
||
// TCP 已在登录时建立，设备切换只用 HTTP
|
||
// 避免创建新 TCP 连接发送 0x03 触发服务端推送 have_logged_in
|
||
|
||
// 重置设备状态 Bloc，清除旧设备图表数据
|
||
_deviceStatusBloc.add(DeviceStatusReset());
|
||
|
||
// 🔥 机器状态数据源已切换为MQTT：用与TCP相同的方式获取设备号（deviceName），
|
||
// 订阅 mower/{sn}/property/* 主题（内部自动退订旧设备、同SN去重）
|
||
debugPrint('${LogTime.now()} 📡 [DevicesCubit] HTTP切换成功，开始MQTT订阅: ${device.deviceName}');
|
||
_deviceStatusBloc.startMqttRealtimeListening(device.deviceName);
|
||
|
||
debugPrint('${LogTime.now()} ✅ 新设备切换完成（HTTP-only，无新TCP连接）: ${device.deviceName}');
|
||
|
||
emit(state.copyWith(isLoading: false, selectedDevice: device));
|
||
},
|
||
);
|
||
}
|
||
|
||
/// 绑定设备
|
||
Future<void> bindDevice(String deviceId, String deviceAlias) async {
|
||
emit(state.copyWith(isLoading: true, errorMessage: ''));
|
||
try {
|
||
final params = BindDeviceParams(deviceId, deviceAlias);
|
||
final result = await _bindDeviceUseCase.call(params);
|
||
result.fold(
|
||
// 失败处理
|
||
(failure) {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '绑定设备失败',
|
||
),
|
||
);
|
||
// 抛出异常，携带后端返回的错误消息（如“设备不存在”）
|
||
throw Exception(failure.message ?? '绑定设备失败');
|
||
},
|
||
// 成功处理（返回 int 状态码）
|
||
(successCode) {
|
||
if (successCode == 1) {
|
||
emit(state.copyWith(isLoading: false, errorMessage: ''));
|
||
// 绑定成功后刷新设备列表
|
||
//fetchAllDevices(state.?.username ?? '');
|
||
} else {
|
||
emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: '绑定失败：状态码 $successCode',
|
||
),
|
||
);
|
||
}
|
||
},
|
||
);
|
||
} catch (e) {
|
||
// emit(state.copyWith(
|
||
// isLoading: false,
|
||
// errorMessage: '绑定异常：${e.toString()}',
|
||
// ));
|
||
// 🔥 重新抛出，传递给 UI
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
/// 获取设备位置
|
||
Future<void> getDeviceLocation(DeviceEntity device) async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _getDeviceLocationUseCase.call(device.deviceName);
|
||
result.fold(
|
||
(failure) =>
|
||
emit(state.copyWith(isLoading: false, errorMessage: failure.message)),
|
||
(location) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
deviceLatitude: location.latitude,
|
||
deviceLongitude: location.longitude,
|
||
),
|
||
),
|
||
);
|
||
}
|
||
|
||
///获取记录
|
||
Future<void> loadWorkRecords(String userId) async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _getWorkRecordUseCase(userId);
|
||
result.fold(
|
||
(failure) =>
|
||
emit(state.copyWith(isLoading: false, errorMessage: failure.message)),
|
||
(records) => emit(state.copyWith(isLoading: false, workRecords: records)),
|
||
);
|
||
}
|
||
|
||
/// 根据场站ID获取工作记录（XML格式接口）
|
||
Future<void> loadWorkRecordsBySiteId(int siteId) async {
|
||
print('🔍 [DevicesCubit] 开始加载场站ID=$siteId的工作记录');
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _getWorkRecordsBySiteIdUseCase(siteId);
|
||
result.fold(
|
||
(failure) {
|
||
print('❌ [DevicesCubit] 加载失败: ${failure.message}');
|
||
emit(state.copyWith(isLoading: false, errorMessage: failure.message));
|
||
},
|
||
(records) {
|
||
print('🔍 [DevicesCubit] selectBySiteId 加载成功，记录数: ${records.length}');
|
||
// 将 WorkRecordEntity 转换为 Map<String, dynamic> 以兼容现有UI
|
||
final mappedRecords = records.map((record) {
|
||
// 🔥 核心修复：根据 jsonData 类型决定存储方式
|
||
// XML接口返回的已是 JSON 字符串，直接使用，避免二次序列化丢失路径数据
|
||
// JSON接口返回的 WorkRecordJsonData 对象，仍需序列化
|
||
String? jsonDataStr;
|
||
if (record.jsonData is String) {
|
||
jsonDataStr = record.jsonData as String;
|
||
} else if (record.jsonData is WorkRecordJsonData) {
|
||
jsonDataStr = _workRecordJsonDataToJson(record.jsonData as WorkRecordJsonData);
|
||
}
|
||
final mapped = <String, dynamic>{
|
||
'id': record.id.toString(),
|
||
'workName': record.workName,
|
||
'imgUrl': record.imgUrl ?? '',
|
||
'jsonData': jsonDataStr,
|
||
};
|
||
print(' ├─ [${record.workName}] id=${record.id}, jsonData长度=${jsonDataStr?.length ?? "null"}');
|
||
// 打印 jsonData 内部的 path/outer 信息
|
||
if (jsonDataStr != null && jsonDataStr.isNotEmpty) {
|
||
try {
|
||
final decoded = jsonDecode(jsonDataStr);
|
||
if (decoded is Map) {
|
||
print(' │ path类型=${decoded['path']?.runtimeType}, outer类型=${decoded['outer']?.runtimeType}, planModel=${decoded['planModel']}');
|
||
if (decoded['path'] is List) print(' │ path长度=${(decoded['path'] as List).length}');
|
||
if (decoded['outer'] is List) print(' │ outer长度=${(decoded['outer'] as List).length}');
|
||
}
|
||
} catch (_) {}
|
||
}
|
||
return mapped;
|
||
}).toList();
|
||
print('🔍 [DevicesCubit] 转换完成，emit workRecords 数量: ${mappedRecords.length}');
|
||
emit(state.copyWith(isLoading: false, workRecords: mappedRecords));
|
||
},
|
||
);
|
||
}
|
||
|
||
/// 将 WorkRecordJsonData 转换为 JSON 字符串
|
||
String _workRecordJsonDataToJson(dynamic jsonData) {
|
||
// 将 jsonData 对象序列化为 JSON 字符串供UI使用
|
||
if (jsonData is WorkRecordJsonData) {
|
||
return jsonEncode({
|
||
'name': jsonData.name,
|
||
'path': jsonData.path,
|
||
'outer': jsonData.outer,
|
||
'img': jsonData.img,
|
||
'planModel': jsonData.planModel,
|
||
});
|
||
}
|
||
return jsonData.toString();
|
||
}
|
||
|
||
/// 删除工作记录
|
||
Future<void> deleteWorkRecord(String workName) async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _deleteWorkRecordUseCase(workName);
|
||
result.fold(
|
||
(failure) =>
|
||
emit(state.copyWith(isLoading: false, errorMessage: failure.message)),
|
||
(_) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
workRecords: state.workRecords
|
||
?.where((record) => record != workName)
|
||
.toList(),
|
||
),
|
||
),
|
||
);
|
||
}
|
||
|
||
/// 加载指定作业名的路径数据
|
||
Future<void> loadSelectedPath(String workName) async {
|
||
emit(state.copyWith(isLoading: true));
|
||
debugPrint('📡 [loadSelectedPath] 开始查询, workName=$workName');
|
||
try {
|
||
final result = await _selectWorkRecordUseCase.call(workName);
|
||
result.fold(
|
||
(failure) {
|
||
debugPrint('❌ [loadSelectedPath] 接口失败: ${failure.message}');
|
||
emit(
|
||
state.copyWith(isLoading: false, errorMessage: failure.message),
|
||
);
|
||
},
|
||
(data) {
|
||
debugPrint('✅ [loadSelectedPath] 接口成功, 记录数: ${data.length}');
|
||
if (data.isNotEmpty) {
|
||
final first = data.first;
|
||
debugPrint(' ├─ 第一条记录 keys: ${first.keys.toList()}');
|
||
debugPrint(' ├─ path 类型: ${first['path']?.runtimeType}, 长度: ${(first['path'] as List?)?.length ?? "null"}');
|
||
debugPrint(' ├─ outer 类型: ${first['outer']?.runtimeType}, 长度: ${(first['outer'] as List?)?.length ?? "null"}');
|
||
debugPrint(' └─ planModel: ${first['planModel']}');
|
||
if (first['path'] is List && (first['path'] as List).isNotEmpty) {
|
||
debugPrint(' └─ path[0]: ${(first['path'] as List).first}');
|
||
}
|
||
if (first['outer'] is List && (first['outer'] as List).isNotEmpty) {
|
||
debugPrint(' └─ outer[0]: ${(first['outer'] as List).first}');
|
||
}
|
||
}
|
||
emit(state.copyWith(isLoading: false, pathData: data));
|
||
},
|
||
);
|
||
} catch (e) {
|
||
debugPrint('❌ [loadSelectedPath] 异常: $e');
|
||
emit(state.copyWith(isLoading: false, errorMessage: e.toString()));
|
||
}
|
||
}
|
||
|
||
/// 保存路径数据
|
||
Future<void> saveWorkRecord(
|
||
String workName,
|
||
String userId,
|
||
String jsonData,
|
||
) async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _saveWorkRecordUseCase.call(
|
||
workName: workName,
|
||
userId: userId,
|
||
jsonData: jsonData,
|
||
);
|
||
result.fold(
|
||
(failure) =>
|
||
emit(state.copyWith(isLoading: false, errorMessage: failure.message)),
|
||
(data) => emit(state.copyWith(isLoading: false)),
|
||
);
|
||
}
|
||
|
||
/// generatePath
|
||
Future<void> generatePath({
|
||
required ReferencePoint reference,
|
||
required int heading,
|
||
required OuterBoundary outer,
|
||
required Map<String, HoleBoundary> holes,
|
||
required int workType,
|
||
}) async {
|
||
//holes.asMap().forEach((index, hole) {
|
||
// final pointsStr = hole.position.map((p) => "(${p.lat.toStringAsFixed(6)}, ${p.lon.toStringAsFixed(6)})").join(', ');
|
||
// debugPrint('第${index + 1}组holes：$pointsStr');
|
||
//});
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _generatePathUseCase.execute(
|
||
reference: reference,
|
||
heading: heading,
|
||
outer: outer,
|
||
holes: holes,
|
||
workType: workType,
|
||
);
|
||
|
||
result.fold(
|
||
(failure) => emit(state.copyWith(errorMessage: failure.message)),
|
||
(pathData) => emit(state.copyWith(generatedPath: pathData)),
|
||
);
|
||
}
|
||
|
||
// 开始路径规划
|
||
Future<void> startRoutePlanning(
|
||
Queue<DeviceAddPathPointModel> locationQueue,
|
||
) async {
|
||
/// print("cubit层开始路径规划");
|
||
_logger.logWithLevel('开始路径规划');
|
||
// 清空全局 Service 中的队列
|
||
// _routePlanningUseCase.clearLocationQueue();
|
||
final List<DeviceAddPathPointModel> pathList = locationQueue.toList();
|
||
// print('✅ 队列转换为 List，长度：${pathList.length}');
|
||
_logger.logWithLevel('队列转换为 List，长度：${pathList.length}');
|
||
|
||
_pathPlanningService.updateQueue(pathList);
|
||
//print('✅ 队列更新成功');
|
||
_logger.logWithLevel('队列更新成功');
|
||
|
||
// 开始路径规划
|
||
emit(state.copyWith(isLoading: true));
|
||
//传入全局的Service 中路径规划队列
|
||
Queue<DeviceAddPathPointModel> queue = _pathPlanningService.getQueue();
|
||
//print('📦 从 Service 获取的队列长度：${queue.length}');
|
||
_logger.logWithLevel('从 Service 获取的队列长度：${queue.length}');
|
||
final result = await _routePlanningUseCase.startRoutePlanning(queue);
|
||
result.fold(
|
||
(failure) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '路径规划启动失败',
|
||
),
|
||
),
|
||
(_) => emit(state.copyWith(isLoading: false, errorMessage: '')),
|
||
);
|
||
}
|
||
|
||
// 暂停
|
||
Future<void> pauseRoutePlanning() async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _routePlanningUseCase.pauseRPWork();
|
||
result.fold(
|
||
(failure) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '暂停失败',
|
||
),
|
||
),
|
||
(_) => emit(state.copyWith(isLoading: false)),
|
||
);
|
||
}
|
||
|
||
// 恢复
|
||
Future<void> resumeRoutePlanning() async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _routePlanningUseCase.resumeRPWork();
|
||
result.fold(
|
||
(failure) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '恢复失败',
|
||
),
|
||
),
|
||
(_) => emit(state.copyWith(isLoading: false)),
|
||
);
|
||
}
|
||
|
||
// 停止
|
||
Future<void> stopRoutePlanning() async {
|
||
emit(state.copyWith(isLoading: true));
|
||
final result = await _routePlanningUseCase.stopRoutePlanning();
|
||
|
||
// 🔥 重置 PathPlanningService 中的全局的队列
|
||
_pathPlanningService.clear();
|
||
result.fold(
|
||
(failure) => emit(
|
||
state.copyWith(
|
||
isLoading: false,
|
||
errorMessage: failure.message ?? '停止失败',
|
||
),
|
||
),
|
||
(_) => emit(state.copyWith(isLoading: false)),
|
||
);
|
||
}
|
||
|
||
void updateAppState(AppState appState) {
|
||
emit(state.copyWith(appState: appState));
|
||
(_routePlanningUseCase as dynamic).repository.setAppState(appState);
|
||
}
|
||
|
||
void finishWork() {
|
||
emit(state.copyWith(isFinshWork: true));
|
||
}
|
||
|
||
/// 重置完成状态
|
||
void resetWorkStatus() {
|
||
emit(state.copyWith(isFinshWork: false));
|
||
}
|
||
|
||
void setArrivedLocation(double latitude, double longitude) {
|
||
emit(state.copyWith(arriLatitude: latitude, arriLongitude: longitude));
|
||
// print('✅ [DevicesCubit] 监听更新已完成到达位置：Lat=$latitude, Lng=$longitude');
|
||
_logger.logWithLevel(
|
||
'✅ [DevicesCubit] 监听更新已完成到达位置：Lat=$latitude, Lng=$longitude',
|
||
);
|
||
}
|
||
|
||
//获取已到达的点的经纬度
|
||
(double, double) getArrivedLocation() {
|
||
return (state.arriLatitude ?? 0.0, state.arriLongitude ?? 0.0);
|
||
}
|
||
|
||
// 重置已到达记录
|
||
void resetArrivedLocation() {
|
||
emit(state.copyWith(arriLatitude: null, arriLongitude: null));
|
||
//print('🔄 [DevicesCubit] 已重置到达位置');
|
||
_logger.logWithLevel('🔄 [DevicesCubit] 已重置到达位置');
|
||
}
|
||
|
||
/// 🔥 获取当前选中的设备
|
||
DeviceEntity? getSelectedDevice() {
|
||
return state.selectedDevice;
|
||
}
|
||
|
||
/// 🔥 异步获取当前选中的设备（兼容 RemoteControlCubit 接口）
|
||
Future<DeviceEntity?> getDevice() async {
|
||
return state.selectedDevice;
|
||
}
|
||
|
||
/// 🔥 判断是否有选中设备
|
||
bool hasSelectedDevice() {
|
||
return state.selectedDevice != null;
|
||
}
|
||
|
||
/// 🔥 获取选中设备名称（安全获取，返回空字符串而非null）
|
||
String getSelectedDeviceName() {
|
||
return state.selectedDevice?.deviceName ?? '';
|
||
}
|
||
|
||
/// 🔥 获取选中设备ID（安全获取，返回空字符串而非null）
|
||
String getSelectedDeviceId() {
|
||
return state.selectedDevice?.deviceName ?? '';
|
||
}
|
||
|
||
/// 🔥 清除选中设备
|
||
void clearSelectedDevice() {
|
||
debugPrint('🧹 [DevicesCubit] 清除选中设备');
|
||
_logger.logWithLevel('🧹 [DevicesCubit] 清除选中设备');
|
||
emit(state.copyWith(selectedDevice: null));
|
||
}
|
||
|
||
/// 🔥 检查设备是否在列表中
|
||
bool isDeviceInList(String deviceName) {
|
||
return state.devices.any((device) => device.deviceName == deviceName);
|
||
}
|
||
|
||
/// 🔥 根据设备名称查找设备
|
||
DeviceEntity? findDeviceByName(String deviceName) {
|
||
try {
|
||
return state.devices.firstWhere(
|
||
(device) => device.deviceName == deviceName,
|
||
orElse: () => throw Exception('Device not found'),
|
||
);
|
||
} catch (e) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// 🔥 启动MQTT到达点监听（用于路径规划动画）
|
||
/// [deviceId] - 目标设备ID，即targetDevice的deviceId
|
||
/// [taskId] - 任务ID，用于订阅 task/{taskId}/status 和 task/{taskId}/arrive
|
||
Future<void> startListeningMqttArrive({required String deviceId, required int taskId}) async {
|
||
debugPrint('📡 [DevicesCubit] 启动MQTT到达点监听 - deviceId: $deviceId, taskId: $taskId');
|
||
_logger.logWithLevel('📡 [DevicesCubit] 启动MQTT到达点监听 - deviceId: $deviceId, taskId: $taskId');
|
||
|
||
try {
|
||
// 启动MQTT订阅
|
||
await _taskMessageRepo.startListening(deviceId: deviceId, taskId: taskId);
|
||
|
||
// 设置DeviceStatusBloc监听的设备ID
|
||
_deviceStatusBloc.setListeningDeviceId(deviceId);
|
||
|
||
debugPrint('✅ [DevicesCubit] MQTT到达点监听已启动');
|
||
_logger.logWithLevel('✅ [DevicesCubit] MQTT到达点监听已启动');
|
||
} catch (e) {
|
||
debugPrint('❌ [DevicesCubit] 启动MQTT监听失败: $e');
|
||
_logger.logWithLevel('❌ [DevicesCubit] 启动MQTT监听失败: $e');
|
||
rethrow;
|
||
}
|
||
}
|
||
|
||
/// 🔥 停止MQTT到达点监听
|
||
Future<void> stopListeningMqttArrive() async {
|
||
debugPrint('🛑 [DevicesCubit] 停止MQTT到达点监听');
|
||
_logger.logWithLevel('🛑 [DevicesCubit] 停止MQTT到达点监听');
|
||
|
||
try {
|
||
await _taskMessageRepo.stopListening();
|
||
_deviceStatusBloc.setListeningDeviceId('');
|
||
debugPrint('✅ [DevicesCubit] MQTT到达点监听已停止');
|
||
_logger.logWithLevel('✅ [DevicesCubit] MQTT到达点监听已停止');
|
||
} catch (e) {
|
||
debugPrint('❌ [DevicesCubit] 停止MQTT监听失败: $e');
|
||
_logger.logWithLevel('❌ [DevicesCubit] 停止MQTT监听失败: $e');
|
||
}
|
||
}
|
||
}
|