liwei1dao
/
deepvoice_client
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge branch 'new_dev' of https://github.com/deepcloud2048/deep_voice into new_dev

newdev_shunjiawei
fdp 1 year ago
parent
45d08531aa 96e1cb8dae
commit
f2feeec4b7
6 changed files with 164 additions and 173 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 122
      lib/data/services/ble_manager.dart
  2. 81
      lib/data/services/qq_music.dart
  3. 123
      lib/modules/home/controllers/home_controller.dart
  4. 4
      lib/modules/home/views/home_view.dart
  5. 5
      lib/modules/qqmusic/controllers/qqmusic_playlist_controller.dart
  6. 2
      pubspec.yaml

122
lib/data/services/ble_manager.dart
View File

@ -156,16 +156,21 @@ class BleManager extends GetxService {
/// 设置BLE事件监听 /// 设置BLE事件监听
void _setupBleListener() { void _setupBleListener() {
Logger.info('lxm--_setupBleListener被调用，开始设置BLE事件监听');
_statusSubscription?.cancel(); _statusSubscription?.cancel();
_dataSubscription?.cancel(); _dataSubscription?.cancel();
try { try {
Logger.info('lxm--开始监听BLE状态更新流');
// 监听BLE状态更新 // 监听BLE状态更新
_statusSubscription = _bleService.onStatusUpdated.listen( _statusSubscription = _bleService.onStatusUpdated.listen(
(event) { (event) {
Logger.info('lxm--收到BLE状态更新事件: $event');
if (event is Map) { if (event is Map) {
Logger.info('lxm--事件是Map类型，开始处理');
// 处理连接状态更新 // 处理连接状态更新
if (event['type'] == 'connectionStateChanged') { if (event['type'] == 'connectionStateChanged') {
Logger.info('lxm--处理连接状态变化事件');
final state = event['state'] as int; final state = event['state'] as int;
final oldState = _connectionState.value; final oldState = _connectionState.value;
_connectionState.value = state; _connectionState.value = state;
@ -175,21 +180,23 @@ class BleManager extends GetxService {
// 连接状态转换 // 连接状态转换
if (state == BleConnectionState.connected) { if (state == BleConnectionState.connected) {
Logger.info('BLE设备已连接'); Logger.info('lxm--BLE设备已连接');
_isConnected.value = true; _isConnected.value = true;
// 在连接成功后延迟 300 毫秒获取设备信息（可根据需要调整时间） // 在连接成功后延迟 300 毫秒获取设备信息（可根据需要调整时间）
Future.delayed(const Duration(milliseconds: 300), () { Future.delayed(const Duration(milliseconds: 300), () {
// 可选：检查是否仍处于连接状态 // 可选：检查是否仍处于连接状态
if (_isConnected.value) { if (_isConnected.value) {
Logger.info('lxm--连接后延迟获取设备信息（当前被注释）');
// fetchDeviceInfo(); // fetchDeviceInfo();
} }
}); });
} else if (state == BleConnectionState.disconnected || } else if (state == BleConnectionState.disconnected ||
state == BleConnectionState.error) { state == BleConnectionState.error) {
Logger.info('BLE设备已断开或发生错误'); Logger.info('lxm--BLE设备已断开或发生错误');
_isConnected.value = false; _isConnected.value = false;
// 更新设备信息Add commentMore actions // 更新设备信息Add commentMore actions
Logger.info('lxm--断开连接时重置设备信息为0');
_updateDeviceInfoIfNeeded( _updateDeviceInfoIfNeeded(
batteryLevel: 0, batteryLevel: 0,
leftEarBattery: 0, leftEarBattery: 0,
@ -207,71 +214,99 @@ class BleManager extends GetxService {
} }
} }
Logger.info('lxm--准备调用_processDeviceInfo处理设备信息');
// 处理设备信息 // 处理设备信息
_processDeviceInfo(event); _processDeviceInfo(event);
} else {
Logger.info('lxm--事件不是Map类型: ${event.runtimeType}');
} }
}, },
onError: (error) { onError: (error) {
Logger.error('BLE状态事件流错误: $error'); Logger.error('lxm--BLE状态事件流错误: $error');
}, },
); );
Logger.info('lxm--BLE状态监听器设置完成');
// 监听BLE数据流 // 监听BLE数据流
} catch (e) { } catch (e) {
Logger.error('设置BLE事件监听器失败: ${e.toString()}'); Logger.error('lxm--设置BLE事件监听器失败: ${e.toString()}');
} }
} }
/// 处理来自原生层的设备信息 /// 处理来自原生层的设备信息
void _processDeviceInfo(Map<dynamic, dynamic> event) { void _processDeviceInfo(Map<dynamic, dynamic> event) {
try { try {
Logger.info('lxm--_processDeviceInfo被调用');
Logger.info('lxm--接收到的事件数据: $event');
// 检查是否是设备信息响应 // 检查是否是设备信息响应
if (event.containsKey('command') && event.containsKey('success')) { if (event.containsKey('command') && event.containsKey('success')) {
Logger.info('lxm--事件包含command和success字段');
final bool success = event['success'] as bool; final bool success = event['success'] as bool;
Logger.info('lxm--命令执行成功状态: $success');
if (!success) { if (!success) {
Logger.warning('设备命令执行失败: ${event['command']}'); Logger.warning('lxm--设备命令执行失败: ${event['command']}');
return; return;
} }
// 根据命令类型处理不同信息 // 根据命令类型处理不同信息
final command = event['command']; final command = event['command'];
Logger.info('lxm--命令类型: $command (${command.runtimeType})');
if (command is int) { if (command is int) {
Logger.info('lxm--基于命令ID处理: $command');
// 基于命令ID处理 // 基于命令ID处理
_processDeviceInfoByCommandId(command, event); _processDeviceInfoByCommandId(command, event);
} else if (command is String) { } else if (command is String) {
Logger.info('lxm--基于命令名称处理: $command');
// 基于命令名称处理 // 基于命令名称处理
_processDeviceInfoByCommandName(command, event); _processDeviceInfoByCommandName(command, event);
} else {
Logger.warning('lxm--未知的命令类型: ${command.runtimeType}');
} }
} else {
Logger.info('lxm--事件不包含command或success字段，跳过处理');
Logger.info('lxm--事件包含的键: ${event.keys.toList()}');
} }
} catch (e) { } catch (e) {
Logger.error('处理设备信息异常: ${e.toString()}'); Logger.error('lxm--处理设备信息异常: ${e.toString()}');
Logger.error('lxm--异常堆栈: ${StackTrace.current}');
} }
} }
/// 根据命令ID处理设备信息 /// 根据命令ID处理设备信息
void _processDeviceInfoByCommandId( void _processDeviceInfoByCommandId(
int commandId, Map<dynamic, dynamic> data) { int commandId, Map<dynamic, dynamic> data) {
Logger.info('lxm--_processDeviceInfoByCommandId被调用，命令ID: $commandId');
Logger.info('lxm--命令数据: $data');
switch (commandId) { switch (commandId) {
case BleCommands.GET_VERSION: case BleCommands.GET_VERSION:
Logger.info('lxm--处理版本信息命令');
_updateVersionInfoFromData(data); _updateVersionInfoFromData(data);
break; break;
case BleCommands.GET_PRODUCT_ID: case BleCommands.GET_PRODUCT_ID:
Logger.info('lxm--处理产品ID命令');
_updateProductIdFromData(data); _updateProductIdFromData(data);
break; break;
case BleCommands.GET_PRODUCT_COLOR: case BleCommands.GET_PRODUCT_COLOR:
Logger.info('lxm--处理产品颜色命令（暂未实现）');
break; break;
case BleCommands.GET_BATTERY_INFO: case BleCommands.GET_BATTERY_INFO:
Logger.info('lxm--处理电池信息命令，准备调用_updateBatteryInfoFromData');
_updateBatteryInfoFromData(data); _updateBatteryInfoFromData(data);
Logger.info('lxm--电池信息处理完成');
break; break;
case BleCommands.CONTROL_CODEC: case BleCommands.CONTROL_CODEC:
Logger.info('lxm--处理编解码控制命令');
// 处理通话状态 // 处理通话状态
print(" CONTROL_CODEC: $commandId,$data"); print(" CONTROL_CODEC: $commandId,$data");
//_isCall.value = data['callStatus'] as bool? ?? false; //_isCall.value = data['callStatus'] as bool? ?? false;
break; break;
default: default:
Logger.warning('lxm--未处理的命令ID: $commandId，数据: $data');
print(" 未处理的命令ID: $commandId,$data"); print(" 未处理的命令ID: $commandId,$data");
Logger.info('未处理的命令ID: $commandId');
} }
} }
@ -302,14 +337,34 @@ class BleManager extends GetxService {
/// 更新电池信息 /// 更新电池信息
void _updateBatteryInfoFromData(Map<dynamic, dynamic> data) { void _updateBatteryInfoFromData(Map<dynamic, dynamic> data) {
try { try {
Logger.info('lxm--_updateBatteryInfoFromData被调用');
Logger.info('lxm--接收到的原始数据: $data');
// 确保数据中包含电池信息 // 确保数据中包含电池信息
if (!data.containsKey('leftEarBattery') || if (!data.containsKey('leftEarBattery') ||
!data.containsKey('rightEarBattery') || !data.containsKey('rightEarBattery') ||
!data.containsKey('caseBattery')) { !data.containsKey('caseBattery')) {
Logger.warning('电池信息数据不完整'); Logger.warning('lxm--电池信息数据不完整，缺少必要字段');
Logger.warning('lxm--数据包含的键: ${data.keys.toList()}');
return; return;
} }
Logger.info('lxm--原始电池数据解析:');
Logger.info(
'lxm-- leftEarBattery原始值: ${data['leftEarBattery']} (类型: ${data['leftEarBattery'].runtimeType})');
Logger.info(
'lxm-- rightEarBattery原始值: ${data['rightEarBattery']} (类型: ${data['rightEarBattery'].runtimeType})');
Logger.info(
'lxm-- caseBattery原始值: ${data['caseBattery']} (类型: ${data['caseBattery'].runtimeType})');
Logger.info(
'lxm-- leftEarCharging原始值: ${data['leftEarCharging']} (类型: ${data['leftEarCharging'].runtimeType})');
Logger.info(
'lxm-- rightEarCharging原始值: ${data['rightEarCharging']} (类型: ${data['rightEarCharging'].runtimeType})');
Logger.info(
'lxm-- caseCharging原始值: ${data['caseCharging']} (类型: ${data['caseCharging'].runtimeType})');
Logger.info(
'lxm-- batteryLevel原始值: ${data['batteryLevel']} (类型: ${data['batteryLevel']?.runtimeType})');
// 提取电池信息 // 提取电池信息
final int leftBattery = (data['leftEarBattery'] as int? ?? 0) > 100 final int leftBattery = (data['leftEarBattery'] as int? ?? 0) > 100
? 0 ? 0
@ -329,6 +384,16 @@ class BleManager extends GetxService {
// 获取整体电量（原生层使用左耳电量作为主要指示） // 获取整体电量（原生层使用左耳电量作为主要指示）
final int overallBattery = data['batteryLevel'] as int? ?? leftBattery; final int overallBattery = data['batteryLevel'] as int? ?? leftBattery;
Logger.info('lxm--处理后的电池数据:');
Logger.info('lxm-- leftBattery: $leftBattery');
Logger.info('lxm-- rightBattery: $rightBattery');
Logger.info('lxm-- caseBattery: $caseBattery');
Logger.info('lxm-- leftCharging: $leftCharging');
Logger.info('lxm-- rightCharging: $rightCharging');
Logger.info('lxm-- caseCharging: $caseCharging');
Logger.info('lxm-- overallBattery: $overallBattery');
Logger.info('lxm--准备调用_updateDeviceInfoIfNeeded');
// 更新设备信息 // 更新设备信息
_updateDeviceInfoIfNeeded( _updateDeviceInfoIfNeeded(
batteryLevel: overallBattery, batteryLevel: overallBattery,
@ -341,9 +406,10 @@ class BleManager extends GetxService {
); );
Logger.info( Logger.info(
'设备电池信息已更新: 电量=$overallBattery%, 左耳=$leftBattery%, 右耳=$rightBattery%, 充电仓=$caseBattery%'); 'lxm--设备电池信息已更新: 电量=$overallBattery%, 左耳=$leftBattery%, 右耳=$rightBattery%, 充电仓=$caseBattery%');
} catch (e) { } catch (e) {
Logger.error('更新电池信息失败: ${e.toString()}'); Logger.error('lxm--更新电池信息失败: ${e.toString()}');
Logger.error('lxm--错误堆栈: ${StackTrace.current}');
} }
} }
@ -406,8 +472,18 @@ class BleManager extends GetxService {
String? firmwareProductId, String? firmwareProductId,
String? firmwareProductColor, String? firmwareProductColor,
}) { }) {
Logger.info('lxm--_updateDeviceInfoIfNeeded被调用');
Logger.info(
'lxm--传入参数: batteryLevel=$batteryLevel, leftEarBattery=$leftEarBattery, rightEarBattery=$rightEarBattery, caseBattery=$caseBattery');
Logger.info(
'lxm--充电状态: leftEarCharging=$leftEarCharging, rightEarCharging=$rightEarCharging, caseCharging=$caseCharging');
Logger.info('lxm--当前deviceInfo.value是否为null: ${deviceInfo.value == null}');
// 如果设备信息已存在，则更新 // 如果设备信息已存在，则更新
if (deviceInfo.value != null) { if (deviceInfo.value != null) {
Logger.info('lxm--设备信息已存在，进行更新操作');
Logger.info('lxm--更新前的设备信息: ${deviceInfo.value}');
deviceInfo.value = deviceInfo.value!.copyWith( deviceInfo.value = deviceInfo.value!.copyWith(
batteryLevel: batteryLevel ?? deviceInfo.value?.batteryLevel, batteryLevel: batteryLevel ?? deviceInfo.value?.batteryLevel,
leftEarBattery: leftEarBattery ?? deviceInfo.value?.leftEarBattery, leftEarBattery: leftEarBattery ?? deviceInfo.value?.leftEarBattery,
@ -423,17 +499,20 @@ class BleManager extends GetxService {
firmwareProductColor: firmwareProductColor:
firmwareProductColor ?? deviceInfo.value!.firmwareProductColor, firmwareProductColor ?? deviceInfo.value!.firmwareProductColor,
); );
Logger.info('lxm--更新后的设备信息: ${deviceInfo.value}');
} }
// 创建设备信息 // 创建设备信息
// 如果设备信息不存在，但有地址和名称，则创建新的设备信息 // 如果设备信息不存在，但有地址和名称，则创建新的设备信息
else if (deviceInfo.value == null && else if (deviceInfo.value == null &&
_isConnected.value && _isConnected.value &&
(firmwareVersion != null || batteryLevel != null)) { (firmwareVersion != null || batteryLevel != null)) {
Logger.info('lxm--设备信息不存在，创建新的设备信息对象');
// 使用保存的设备信息创建新的DeviceInfo对象 // 使用保存的设备信息创建新的DeviceInfo对象
String deviceAddress = _currentDeviceAddress ?? ""; String deviceAddress = _currentDeviceAddress ?? "";
String deviceName = _currentDeviceName ?? ""; String deviceName = _currentDeviceName ?? "";
Logger.info('创建新的设备信息对象: address=$deviceAddress, name=$deviceName'); Logger.info('lxm--创建新的设备信息对象: address=$deviceAddress, name=$deviceName');
deviceInfo.value = DeviceInfo( deviceInfo.value = DeviceInfo(
address: deviceAddress, address: deviceAddress,
name: deviceName, name: deviceName,
@ -448,6 +527,11 @@ class BleManager extends GetxService {
firmwareProductId: firmwareProductId ?? '', firmwareProductId: firmwareProductId ?? '',
firmwareProductColor: firmwareProductColor ?? '', firmwareProductColor: firmwareProductColor ?? '',
); );
Logger.info('lxm--新创建的设备信息: ${deviceInfo.value}');
} else {
Logger.info(
'lxm--不满足更新条件: deviceInfo.value == null: ${deviceInfo.value == null}, _isConnected.value: ${_isConnected.value}, firmwareVersion: $firmwareVersion, batteryLevel: $batteryLevel');
} }
} }
@ -639,21 +723,28 @@ class BleManager extends GetxService {
} }
} }
Logger.info('lxm--准备调用AgentService.startAgentService启动BLE服务');
final result = await AgentService.startAgentService(config); final result = await AgentService.startAgentService(config);
Logger.info('lxm--AgentService.startAgentService调用结果: $result');
if (result) { if (result) {
Logger.info('BLE服务启动成功'); Logger.info('lxm--BLE服务启动成功');
// 添加延迟以等待设备连接 // 添加延迟以等待设备连接
Logger.info('lxm--等待2秒让设备连接');
await Future.delayed(const Duration(seconds: 2)); await Future.delayed(const Duration(seconds: 2));
// 检查连接状态 // 检查连接状态
Logger.info('lxm--检查设备连接状态');
final isConnected = await _bleService.isConnected(); final isConnected = await _bleService.isConnected();
Logger.info('lxm--设备连接状态检查结果: $isConnected');
if (isConnected) { if (isConnected) {
Logger.info('lxm--设备已连接，更新连接状态');
_isConnected.value = true; _isConnected.value = true;
_connectionState.value = BleConnectionState.connected; _connectionState.value = BleConnectionState.connected;
// 如果设备信息存在，则获取详细信息 // 如果设备信息存在，则获取详细信息
Logger.info('lxm--准备获取设备详细信息');
if (deviceInfo.value != null) { if (deviceInfo.value != null) {
// 获取详细设备信息 // 获取详细设备信息
// fetchDeviceInfo(); // fetchDeviceInfo();
@ -705,9 +796,12 @@ class BleManager extends GetxService {
/// 主动获取电池信息 /// 主动获取电池信息
Future<bool> fetchBatteryInfo() async { Future<bool> fetchBatteryInfo() async {
try { try {
return await _bleService.getBatteryInfo(); Logger.info('lxm--fetchBatteryInfo被调用，准备向设备发送获取电池信息指令');
final result = await _bleService.getBatteryInfo();
Logger.info('lxm--getBatteryInfo指令发送结果: $result');
return result;
} catch (e) { } catch (e) {
Logger.error('获取电池信息失败: ${e.toString()}'); Logger.error('lxm--获取电池信息失败: ${e.toString()}');
return false; return false;
} }
} }

81
lib/data/services/qq_music.dart
View File

@ -1,5 +1,4 @@
import 'dart:async'; import 'dart:async';
import 'dart:ffi';
import 'package:get/get.dart'; import 'package:get/get.dart';
import 'package:qq_music/qq_music.dart'; import 'package:qq_music/qq_music.dart';
import '../models/song_model.dart'; import '../models/song_model.dart';
@ -17,36 +16,10 @@ class QqMusicService extends GetxService {
final currentPosition = 0.obs; // 毫秒 final currentPosition = 0.obs; // 毫秒
final totalDuration = 0.obs; // 毫秒 final totalDuration = 0.obs; // 毫秒
final currentSong = Rxn<SongModel>(); final currentSong = Rxn<SongModel>();
// final playlist = <SongModel>[].obs;
// final currentIndex = 0.obs;
// 状态监听定时器 // 状态监听定时器
Timer? _stateMonitorTimer; Timer? _stateMonitorTimer;
// 监听器列表 - 用于通知页面状态变化
final List<Function()> _listeners = [];
/// 初始化插件并尝试自动登录
Future<void> initializePlugin() async {
try {
// 先触发插件注册
// await _qqMusic.getPlatformVersion();
// 尝试自动登录
final result = await _qqMusic.login();
if (result['success'] == true) {
print('QQ音乐自动登录成功: ${result['openId']}');
Future.delayed(Duration(milliseconds: 1000), () {
syncCurrentPlayInfo();
});
} else {
print('QQ音乐自动登录失败: ${result['error']}');
}
} catch (e) {
print('QQ音乐插件初始化失败: $e');
}
}
@override @override
void onInit() { void onInit() {
super.onInit(); super.onInit();
@ -58,32 +31,11 @@ class QqMusicService extends GetxService {
@override @override
void onClose() { void onClose() {
_stateMonitorTimer?.cancel(); _stateMonitorTimer?.cancel();
_listeners.clear();
print('🎵 [QQMusicService] 全局音乐服务销毁'); print('🎵 [QQMusicService] 全局音乐服务销毁');
super.onClose(); super.onClose();
} }
/// 添加状态监听器
void addListener(Function() listener) {
_listeners.add(listener);
}
/// 移除状态监听器
void removeListener(Function() listener) {
_listeners.remove(listener);
}
/// 通知所有监听器
void _notifyListeners() {
for (final listener in _listeners) {
try {
listener();
} catch (e) {
print('🔥 [QQMusicService] 监听器回调异常: $e');
}
}
}
/// 启动播放状态监控 /// 启动播放状态监控
void startPlaybackStateMonitor() { void startPlaybackStateMonitor() {
// 取消之前的定时器 // 取消之前的定时器
@ -141,7 +93,6 @@ class QqMusicService extends GetxService {
if (wasPlaying && !newIsPlaying) { if (wasPlaying && !newIsPlaying) {
print('⏹️ [QQMusicService] 检测到播放停止，自动停止全局监听'); print('⏹️ [QQMusicService] 检测到播放停止，自动停止全局监听');
stopPlaybackStateMonitor(); stopPlaybackStateMonitor();
_notifyListeners();
return; return;
} }
@ -149,7 +100,6 @@ class QqMusicService extends GetxService {
if (!newIsPlaying) { if (!newIsPlaying) {
print('⏸️ [QQMusicService] 当前未在播放，停止全局监听以节省资源'); print('⏸️ [QQMusicService] 当前未在播放，停止全局监听以节省资源');
stopPlaybackStateMonitor(); stopPlaybackStateMonitor();
_notifyListeners();
return; return;
} }
@ -185,9 +135,6 @@ class QqMusicService extends GetxService {
currentSong.value = newSong; currentSong.value = newSong;
} }
} }
// 通知所有监听器
_notifyListeners();
} else { } else {
// 同步失败时停止监听 // 同步失败时停止监听
print('❌ [QQMusicService] 全局同步失败，停止监听'); print('❌ [QQMusicService] 全局同步失败，停止监听');
@ -276,7 +223,6 @@ class QqMusicService extends GetxService {
Future.delayed(Duration(seconds: 1), () { Future.delayed(Duration(seconds: 1), () {
syncCurrentPlayInfo(); syncCurrentPlayInfo();
}); });
_notifyListeners();
} else { } else {
isPlaying.value = false; isPlaying.value = false;
currentPosition.value = 0; currentPosition.value = 0;
@ -300,8 +246,6 @@ class QqMusicService extends GetxService {
Future.delayed(Duration(milliseconds: 500), () { Future.delayed(Duration(milliseconds: 500), () {
syncCurrentPlayInfo(); syncCurrentPlayInfo();
}); });
_notifyListeners();
} }
return result; return result;
} catch (e) { } catch (e) {
@ -315,7 +259,6 @@ class QqMusicService extends GetxService {
final result = await _qqMusic.pauseMusic(); final result = await _qqMusic.pauseMusic();
if (result['success'] == true) { if (result['success'] == true) {
isPlaying.value = false; isPlaying.value = false;
_notifyListeners();
} }
return result; return result;
} catch (e) { } catch (e) {
@ -330,7 +273,6 @@ class QqMusicService extends GetxService {
if (result['success'] == true) { if (result['success'] == true) {
isPlaying.value = true; isPlaying.value = true;
startPlaybackStateMonitor(); startPlaybackStateMonitor();
_notifyListeners();
} }
return result; return result;
} catch (e) { } catch (e) {
@ -346,7 +288,6 @@ class QqMusicService extends GetxService {
isPlaying.value = false; isPlaying.value = false;
currentPosition.value = 0; currentPosition.value = 0;
stopPlaybackStateMonitor(); stopPlaybackStateMonitor();
_notifyListeners();
} }
return result; return result;
} catch (e) { } catch (e) {
@ -358,14 +299,7 @@ class QqMusicService extends GetxService {
Future<Map<String, dynamic>> skipToNext() async { Future<Map<String, dynamic>> skipToNext() async {
try { try {
final result = await _qqMusic.skipToNext(); final result = await _qqMusic.skipToNext();
if (result['success'] == true) { if (result['success'] == true) {}
// 更新当前索引
// if (currentIndex.value < playlist.length - 1) {
// currentIndex.value++;
// currentSong.value = playlist[currentIndex.value];
// }
_notifyListeners();
}
return result; return result;
} catch (e) { } catch (e) {
return {'success': false, 'error': '下一首失败: ${e.toString()}'}; return {'success': false, 'error': '下一首失败: ${e.toString()}'};
@ -376,14 +310,7 @@ class QqMusicService extends GetxService {
Future<Map<String, dynamic>> skipToPrevious() async { Future<Map<String, dynamic>> skipToPrevious() async {
try { try {
final result = await _qqMusic.skipToPrevious(); final result = await _qqMusic.skipToPrevious();
if (result['success'] == true) { if (result['success'] == true) {}
// 更新当前索引
// if (currentIndex.value > 0) {
// currentIndex.value--;
// currentSong.value = playlist[currentIndex.value];
// }
_notifyListeners();
}
return result; return result;
} catch (e) { } catch (e) {
return {'success': false, 'error': '上一首失败: ${e.toString()}'}; return {'success': false, 'error': '上一首失败: ${e.toString()}'};
@ -480,8 +407,6 @@ class QqMusicService extends GetxService {
}); });
} }
} }
// 通知所有监听器
_notifyListeners();
} }
return result; return result;

123
lib/modules/home/controllers/home_controller.dart
View File

@ -1,5 +1,5 @@
import 'package:get/get.dart'; import 'package:get/get.dart';
import 'dart:async'; // 移除了dart:async导入，因为不再使用Timer
import '../../../data/services/novice_guide_service.dart'; import '../../../data/services/novice_guide_service.dart';
import '../../../routes/app_routes.dart'; import '../../../routes/app_routes.dart';
import '../../../core/utils/logger.dart'; import '../../../core/utils/logger.dart';
@ -24,10 +24,7 @@ class HomeController extends GetxController {
final _isFullyConnected = false.obs; final _isFullyConnected = false.obs;
String? _lastConnectedDeviceName; String? _lastConnectedDeviceName;
// 添加电池信息定时刷新相关变量 // 移除了电池信息定时刷新相关变量
Timer? _batteryRefreshTimer;
static const Duration _batteryRefreshInterval =
Duration(seconds: 2); // 2秒刷新一次
// OTA检查服务 // OTA检查服务
late final OtaCheckService _otaCheckService; late final OtaCheckService _otaCheckService;
@ -37,21 +34,51 @@ class HomeController extends GetxController {
BluetoothDevice? get currentDevice => _bluetoothManager.currentDevice; BluetoothDevice? get currentDevice => _bluetoothManager.currentDevice;
Rx<DeviceInfo?> get deviceInfo => _bleManager.deviceInfo; Rx<DeviceInfo?> get deviceInfo => _bleManager.deviceInfo;
final leftEarBattery = 0.obs; static final leftEarBattery = 0.obs;
final rightEarBattery = 0.obs; static final rightEarBattery = 0.obs;
final caseBattery = 0.obs; final caseBattery = 0.obs;
final leftEarCharging = false.obs; final leftEarCharging = false.obs;
final rightEarCharging = false.obs; final rightEarCharging = false.obs;
final caseCharging = false.obs; final caseCharging = false.obs;
final firmwareVersion = ''.obs; final firmwareVersion = ''.obs;
void updateDeviceInfo(DeviceInfo? newDeviceInfo) { void updateDeviceInfo(DeviceInfo? newDeviceInfo) {
leftEarBattery.value = newDeviceInfo?.leftEarBattery ?? 0; Logger.d(_tag, 'lxm--updateDeviceInfo被调用');
rightEarBattery.value = newDeviceInfo?.rightEarBattery ?? 0; Logger.d(_tag, 'lxm--接收到的DeviceInfo: $newDeviceInfo');
if (newDeviceInfo != null) {
Logger.d(_tag, 'lxm--原始数据 - 左耳电量: ${newDeviceInfo.leftEarBattery}');
Logger.d(_tag, 'lxm--原始数据 - 右耳电量: ${newDeviceInfo.rightEarBattery}');
Logger.d(_tag, 'lxm--原始数据 - 充电仓电量: ${newDeviceInfo.caseBattery}');
Logger.d(_tag, 'lxm--原始数据 - 左耳充电: ${newDeviceInfo.leftEarCharging}');
Logger.d(_tag, 'lxm--原始数据 - 右耳充电: ${newDeviceInfo.rightEarCharging}');
Logger.d(_tag, 'lxm--原始数据 - 充电仓充电: ${newDeviceInfo.caseCharging}');
Logger.d(_tag, 'lxm--原始数据 - 固件版本: ${newDeviceInfo.firmwareVersion}');
} else {
Logger.d(_tag, 'lxm--接收到的DeviceInfo为null');
}
// 只有当新数据不为0时才更新电池值，否则保持原值
if ((newDeviceInfo?.leftEarBattery ?? 0) != 0) {
Logger.d(_tag, 'lxm--更新左耳电量: ${newDeviceInfo!.leftEarBattery}');
leftEarBattery.value = newDeviceInfo.leftEarBattery;
}
if ((newDeviceInfo?.rightEarBattery ?? 0) != 0) {
Logger.d(_tag, 'lxm--更新右耳电量: ${newDeviceInfo!.rightEarBattery}');
rightEarBattery.value = newDeviceInfo.rightEarBattery;
}
caseBattery.value = newDeviceInfo?.caseBattery ?? 0; caseBattery.value = newDeviceInfo?.caseBattery ?? 0;
leftEarCharging.value = newDeviceInfo?.leftEarCharging ?? false; leftEarCharging.value = newDeviceInfo?.leftEarCharging ?? false;
rightEarCharging.value = newDeviceInfo?.rightEarCharging ?? false; rightEarCharging.value = newDeviceInfo?.rightEarCharging ?? false;
caseCharging.value = newDeviceInfo?.caseCharging ?? false; caseCharging.value = newDeviceInfo?.caseCharging ?? false;
firmwareVersion.value = newDeviceInfo?.firmwareVersion ?? ''; firmwareVersion.value = newDeviceInfo?.firmwareVersion ?? '';
Logger.d(_tag, 'lxm--更新后的值 - 左耳电量: ${leftEarBattery.value}');
Logger.d(_tag, 'lxm--更新后的值 - 右耳电量: ${rightEarBattery.value}');
Logger.d(_tag, 'lxm--更新后的值 - 充电仓电量: ${caseBattery.value}');
Logger.d(_tag, 'lxm--更新后的值 - 左耳充电: ${leftEarCharging.value}');
Logger.d(_tag, 'lxm--更新后的值 - 右耳充电: ${rightEarCharging.value}');
Logger.d(_tag, 'lxm--更新后的值 - 充电仓充电: ${caseCharging.value}');
Logger.d(_tag, 'lxm--更新后的值 - 固件版本: ${firmwareVersion.value}');
} }
Worker? _deviceInfoWorker; Worker? _deviceInfoWorker;
@ -68,7 +95,7 @@ class HomeController extends GetxController {
super.onInit(); super.onInit();
_otaCheckService = Get.find<OtaCheckService>(); _otaCheckService = Get.find<OtaCheckService>();
_initWithCachedInfo(); _initWithCachedInfo();
// _startBatteryRefreshTimer(); // 启动电池信息定时刷新 // 移除了电池信息定时刷新的启动
} }
@override @override
@ -76,7 +103,7 @@ class HomeController extends GetxController {
_deviceInfoWorker?.dispose(); _deviceInfoWorker?.dispose();
_classicBluetoothWorker?.dispose(); _classicBluetoothWorker?.dispose();
_bleConnectionWorker?.dispose(); _bleConnectionWorker?.dispose();
_stopBatteryRefreshTimer(); // 停止定时器 // 移除了定时器停止逻辑
super.onClose(); super.onClose();
} }
@ -87,8 +114,13 @@ class HomeController extends GetxController {
void _setupStateListeners() { void _setupStateListeners() {
_deviceInfoWorker = ever(_bleManager.deviceInfo, (DeviceInfo? info) { _deviceInfoWorker = ever(_bleManager.deviceInfo, (DeviceInfo? info) {
Logger.d(_tag, 'lxm--_deviceInfoWorker监听器被触发');
Logger.d(_tag, 'lxm--从BleManager接收到的DeviceInfo: $info');
if (info != null) { if (info != null) {
Logger.d(_tag, 'lxm--DeviceInfo不为null，调用updateDeviceInfo');
updateDeviceInfo(info); updateDeviceInfo(info);
} else {
Logger.d(_tag, 'lxm--DeviceInfo为null，跳过更新');
} }
update(); update();
}); });
@ -108,10 +140,7 @@ class HomeController extends GetxController {
Future<void> refreshDeviceConnection() async { Future<void> refreshDeviceConnection() async {
await _checkConnectionStatus(); await _checkConnectionStatus();
// 如果设备已连接，立即刷新电池信息 // 移除了立即刷新电池信息的逻辑
if (_isFullyConnected.value) {
await _refreshBatteryInfo();
}
} }
void rescanDevices() { void rescanDevices() {
@ -149,24 +178,15 @@ class HomeController extends GetxController {
Future.delayed(const Duration(seconds: 1), () async { Future.delayed(const Duration(seconds: 1), () async {
await _bleManager.fetchDeviceInfo(); await _bleManager.fetchDeviceInfo();
}); });
// 连接成功后立即刷新一次电池信息 // 移除了连接成功后的电池信息刷新
Future.delayed(const Duration(milliseconds: 500), () {
_refreshBatteryInfo();
});
// 连接成功后检查OTA升级 // 连接成功后检查OTA升级
Future.delayed(const Duration(seconds: 2), () { Future.delayed(const Duration(seconds: 2), () {
_checkOtaUpgrade(); _checkOtaUpgrade();
}); });
} }
// 根据连接状态控制定时器 // 移除了根据连接状态控制定时器的逻辑
// if (isNowConnected) {
// _startBatteryRefreshTimer(); // 连接时启动定时器
// } else {
// _stopBatteryRefreshTimer(); // 断开时停止定时器
// // 注意：不再重置OTA检查状态，因为现在由全局服务管理
// }
} }
update(); update();
@ -175,7 +195,7 @@ class HomeController extends GetxController {
if (_isFullyConnected.value) { if (_isFullyConnected.value) {
_isFullyConnected.value = false; _isFullyConnected.value = false;
_isFullyConnected.refresh(); _isFullyConnected.refresh();
_stopBatteryRefreshTimer(); // 发生错误时停止定时器 // 移除了发生错误时停止定时器的逻辑
// 注意：不再重置OTA检查状态，因为现在由全局服务管理 // 注意：不再重置OTA检查状态，因为现在由全局服务管理
update(); update();
} }
@ -299,50 +319,7 @@ class HomeController extends GetxController {
: 'unknown'.tr; : 'unknown'.tr;
} }
/// 启动电池信息定时刷新 // 移除了电池信息定时刷新相关方法
void _startBatteryRefreshTimer() {
_stopBatteryRefreshTimer(); // 先停止现有定时器
_batteryRefreshTimer = Timer.periodic(_batteryRefreshInterval, (timer) {
// 只有在设备完全连接时才刷新电池信息
if (_isFullyConnected.value) {
_refreshBatteryInfo();
}
});
Logger.d(_tag, '电池信息定时刷新已启动，间隔: ${_batteryRefreshInterval.inSeconds}秒');
}
/// 停止电池信息定时刷新
void _stopBatteryRefreshTimer() {
if (_batteryRefreshTimer != null) {
_batteryRefreshTimer!.cancel();
_batteryRefreshTimer = null;
Logger.d(_tag, '电池信息定时刷新已停止');
}
}
/// 刷新电池信息
Future<void> _refreshBatteryInfo() async {
try {
if (!_isFullyConnected.value) {
return;
}
//Logger.d(_tag, '开始刷新电池信息...');
// 通过BLE管理器获取最新的电池信息
final success = await _bleManager.fetchBatteryInfo();
if (success) {
//Logger.d(_tag, '电池信息刷新请求发送成功');
} else {
//Logger.w(_tag, '电池信息刷新请求发送失败');
}
} catch (e) {
//Logger.e(_tag, '刷新电池信息时发生错误: $e');
}
}
/// 检查OTA固件升级 /// 检查OTA固件升级
/// 在BLE连接成功后调用，检查是否需要升级 /// 在BLE连接成功后调用，检查是否需要升级

4
lib/modules/home/views/home_view.dart
View File

@ -450,8 +450,8 @@ class HomeView extends GetView<HomeController> {
Widget _buildBatteryInfoGrid(bool isDarkMode) { Widget _buildBatteryInfoGrid(bool isDarkMode) {
return Obx(() { return Obx(() {
// 获取各部分电池电量 // 获取各部分电池电量
final leftBattery = controller.leftEarBattery; final leftBattery = HomeController.leftEarBattery;
final rightBattery = controller.rightEarBattery; final rightBattery = HomeController.rightEarBattery;
final caseBattery = controller.caseBattery; final caseBattery = controller.caseBattery;
// 获取充电状态 // 获取充电状态
final leftEarCharging = controller.leftEarCharging; final leftEarCharging = controller.leftEarCharging;

5
lib/modules/qqmusic/controllers/qqmusic_playlist_controller.dart
View File

@ -49,10 +49,6 @@ class QQMusicPlaylistController extends GetxController {
Logger.w('QQMusicPlaylist', '未接收到播放列表参数'); Logger.w('QQMusicPlaylist', '未接收到播放列表参数');
_setDefaultDisplayState(); _setDefaultDisplayState();
} }
// 添加状态监听器
_qqMusicService.addListener(_onMusicStateChanged);
// 界面初始化时同步播放状态和进度 // 界面初始化时同步播放状态和进度
_qqMusicService.syncCurrentPlayInfo(); _qqMusicService.syncCurrentPlayInfo();
} }
@ -117,7 +113,6 @@ class QQMusicPlaylistController extends GetxController {
@override @override
void onClose() { void onClose() {
// 移除状态监听器 // 移除状态监听器
_qqMusicService.removeListener(_onMusicStateChanged);
super.onClose(); super.onClose();
} }

2
pubspec.yaml
View File

@ -1,7 +1,7 @@
name: voitrans name: voitrans
description: "Voitrans - AI Voice Assistant." description: "Voitrans - AI Voice Assistant."
publish_to: "none" publish_to: "none"
version: 1.0.10+25 version: 1.0.12+29
environment: environment:
sdk: ">=3.3.0 <4.0.0" sdk: ">=3.3.0 <4.0.0"

Write Preview
Loading…
Cancel
Save