sky/app-starlock
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix:完善各个对讲状态下的逻辑

Browse Source
This commit is contained in:
liyi 2025-01-02 10:30:07 +08:00
parent 01885f8a7c
commit ff9564b55a
7 changed files with 72 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
lib/talk/startChart/handle/impl/udp_talk_accept_handler.dart
View File

@ -12,6 +12,7 @@ import 'package:star_lock/talk/startChart/handle/scp_message_handle.dart';
import 'package:star_lock/talk/startChart/proto/gateway_reset.pb.dart';
import 'package:star_lock/talk/startChart/proto/generic.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_accept.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_expect.pb.dart';
import '../../start_chart_manage.dart';
@ -25,26 +26,21 @@ class UdpTalkAcceptHandler extends ScpMessageBaseHandle
@override
void handleResp(ScpMessage scpMessage) {
if (talkStatus.status != TalkStatus.waitingAnswer) {
// 如果不是等待接听状态，则不处理
return;
}
// 收到同意接听回复
final GenericResp genericResp = scpMessage.Payload;
if (checkGenericRespSuccess(genericResp)) {
// 启动通话保持定时器
_handleStartTalkPing();
// 启动发送预期数据请求
_handleStartSendTalkExpectDataRequest();
// 启动通话数据检查的定时器
// _handleCheckTalkDataTimer();
print('收到同意接听的回复');
// 停止同意接听的重发
startChartManage.stopTalkAcceptTimer();
// 接听之后增加期望音频的接收
_handleSendExpect();
// 停止播放铃声
stopRingtone();
// 设置状态为接听成功
talkStatus.setAnsweredSuccessfully();
// // 同意接听之后，停止对讲请求超时监听定时器
// talkeRequestOverTimeTimerManager.renewTimer();
// talkeRequestOverTimeTimerManager.dispose();
// 同意接听之后，停止对讲请求超时监听定时器
talkeRequestOverTimeTimerManager.renew();
talkeRequestOverTimeTimerManager.cancel();
}
}
@ -78,23 +74,8 @@ class UdpTalkAcceptHandler extends ScpMessageBaseHandle
}
}
// 启动通话保持，判断x秒内是否收到通话保持
void _handleStartTalkPing() {
// 启动通话保持
startChartManage.startTalkPingMessageTimer();
// 启动通话保持监听定时器（用来判断如果x秒内没有收到通话保持则执行的操作）
talkePingOverTimeTimerManager.start();
}
/// 启动通话数据的检查，判断x秒内是否收到通话数据
void _handleCheckTalkDataTimer() {
// 启动通话保持监听定时器（用来判断如果x秒内没有收到通话保持则执行的操作）
talkDataOverTimeTimerManager.start();
}
/// 启动发送预期数据请求
void _handleStartSendTalkExpectDataRequest() {
// 启动发送预期数据定时器
startChartManage.startTalkExpectTimer();
void _handleSendExpect() {
// 修改预期数据并启动发送预期数据定时器，在收到回复时停止
startChartManage.sendImageVideoAndG711AudioTalkExpectData();
}
}

12
lib/talk/startChart/handle/impl/udp_talk_data_handler.dart
View File

@ -8,6 +8,7 @@ import 'package:path_provider/path_provider.dart';
import 'package:star_lock/app_settings/app_settings.dart';
import 'package:star_lock/talk/call/g711.dart';
import 'package:star_lock/talk/startChart/constant/message_type_constant.dart';
import 'package:star_lock/talk/startChart/constant/talk_status.dart';
import 'package:star_lock/talk/startChart/entity/scp_message.dart';
import 'package:star_lock/talk/startChart/handle/scp_message_base_handle.dart';
import 'package:star_lock/talk/startChart/handle/scp_message_handle.dart';
@ -15,6 +16,7 @@ import 'package:star_lock/talk/startChart/proto/gateway_reset.pb.dart';
import 'package:star_lock/talk/startChart/proto/generic.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_data.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_data.pbserver.dart';
import 'package:star_lock/talk/startChart/proto/talk_data_h264_frame.pb.dart';
class UdpTalkDataHandler extends ScpMessageBaseHandle
implements ScpMessageHandler {
@ -105,7 +107,10 @@ class UdpTalkDataHandler extends ScpMessageBaseHandle
/// 处理h264协议的数据
void _handleVideoH264(TalkData talkData) {
// talkDataRepository.addTalkData(talkData);
final TalkDataH264Frame talkDataH264Frame = TalkDataH264Frame();
talkDataH264Frame.mergeFromBuffer(talkData.content);
AppLog.log('H264 TalkData :$talkDataH264Frame');
talkDataRepository.addTalkData(talkData);
}
/// 处理图片数据
@ -113,11 +118,10 @@ class UdpTalkDataHandler extends ScpMessageBaseHandle
final List<Uint8List> processCompletePayload =
await _processCompletePayload(Uint8List.fromList(talkData.content));
// AppLog.log('得到完整的帧：${processCompletePayload.length}'); // 循环发送每一帧的数据
processCompletePayload.forEach((element) {
talkData.content = element;
talkDataRepository.addTalkData(talkData);
// 设置状态为接听中
talkStatus.setDuringCall();
});
}
@ -129,8 +133,6 @@ class UdpTalkDataHandler extends ScpMessageBaseHandle
List<int> pcmBytes = G711().convertList(g711Data);
talkData.content = pcmBytes;
talkDataRepository.addTalkData(talkData);
// 设置状态为接听中
talkStatus.setDuringCall();
} catch (e) {
print('Error decoding G.711 to PCM: $e');
}

27
lib/talk/startChart/handle/impl/udp_talk_hangup_handler.dart
View File

@ -9,40 +9,35 @@ import 'package:star_lock/talk/startChart/handle/scp_message_handle.dart';
import 'package:star_lock/talk/startChart/proto/generic.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_hangup.pb.dart';
import '../../start_chart_manage.dart';
class UdpTalkHangUpHandler extends ScpMessageBaseHandle
implements ScpMessageHandler {
@override
void handleReq(ScpMessage scpMessage) {
if (talkStatus.status != TalkStatus.duringCall) {
if (talkStatus.status != TalkStatus.answeredSuccessfully) {
// 如果不是接听中，不处理通话中挂断请求
return;
}
startChartManage.sendGenericRespSuccessMessage(
ToPeerId: scpMessage.FromPeerId!,
FromPeerId: scpMessage.ToPeerId!,
PayloadType: scpMessage.PayloadType!,
);
// 停止发送通话保持的命令
startChartManage.stopTalkPingMessageTimer();
startChartManage.stopTalkExpectMessageTimer();
// 回复请求
replySuccessMessage(scpMessage);
talkStatus.setHangingUpDuring();
stopRingtone();
StartChartManage().stopTalkExpectMessageTimer();
StartChartManage().stopTalkPingMessageTimer();
}
@override
void handleResp(ScpMessage scpMessage) {
// 停止发送通话保持的命令
startChartManage.stopTalkPingMessageTimer();
startChartManage.stopTalkExpectMessageTimer();
talkStatus.setHangingUpDuring();
stopRingtone();
// 拒绝接听之后，停止对讲请求超时监听定时器
// talkeRequestOverTimeTimerManager.renewTimer();
// talkeRequestOverTimeTimerManager.dispose();
// 挂断之后，停止对讲请求超时监听定时器
talkeRequestOverTimeTimerManager.renew();
talkeRequestOverTimeTimerManager.cancel();
talkePingOverTimeTimerManager.renew();
talkePingOverTimeTimerManager.cancel();
}
@override

10
lib/talk/startChart/handle/impl/udp_talk_reject_handler.dart
View File

@ -22,9 +22,10 @@ class UdpTalkRejectHandler extends ScpMessageBaseHandle
replySuccessMessage(scpMessage);
// 停止铃声
stopRingtone();
StartChartManage().stopTalkExpectMessageTimer();
StartChartManage().stopTalkPingMessageTimer();
// 收到接听拒绝回复
talkStatus.setRejected();
}
@override
@ -33,10 +34,11 @@ class UdpTalkRejectHandler extends ScpMessageBaseHandle
startChartManage.stopTalkExpectMessageTimer();
stopRingtone();
// 拒绝接听之后，停止对讲请求超时监听定时器
// talkeRequestOverTimeTimerManager.renewTimer();
// talkeRequestOverTimeTimerManager.dispose();
talkeRequestOverTimeTimerManager.renew();
talkeRequestOverTimeTimerManager.cancel();
talkePingOverTimeTimerManager.renew();
talkePingOverTimeTimerManager.cancel();
}
@override

56
lib/talk/startChart/handle/impl/udp_talk_request_handler.dart
View File

@ -12,38 +12,31 @@ import 'package:star_lock/talk/startChart/handle/scp_message_base_handle.dart';
import 'package:star_lock/talk/startChart/handle/scp_message_handle.dart';
import 'package:star_lock/talk/startChart/proto/gateway_reset.pb.dart';
import 'package:star_lock/talk/startChart/proto/generic.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_expect.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_request.pb.dart';
import 'package:star_lock/tools/storage.dart';
class UdpTalkRequestHandler extends ScpMessageBaseHandle
implements ScpMessageHandler {
@override
void handleReq(ScpMessage scpMessage) {
if (talkStatus == TalkStatus.waitingAnswer) {
void handleReq(ScpMessage scpMessage) async {
// 判断是否登录账户
final loginData = await Storage.getLoginData();
if (loginData == null ||
talkStatus.status == TalkStatus.waitingAnswer ||
talkStatus.status == TalkStatus.answeredSuccessfully) {
// 如果已经是等待接听了，就不在处理剩下的请求
return;
}
// 回复成功
replySuccessMessage(scpMessage);
// 收到对讲请求
final TalkReq talkReq = scpMessage.Payload;
// 回复收到对讲成功的消息
startChartManage.sendGenericRespSuccessMessage(
ToPeerId: scpMessage.FromPeerId!,
FromPeerId: scpMessage.ToPeerId!,
PayloadType: scpMessage.PayloadType!,
);
startChartManage.FromPeerId = scpMessage.ToPeerId!;
startChartManage.ToPeerId = scpMessage.FromPeerId!;
// 处理收到接听请求后的事件
_talkRequestEvent(talkObjectName: talkReq.callerName);
// 启动对讲请求超时定时器
// talkeRequestOverTimeTimerManager.startTimer();
// talkeRequestOverTimeTimerManager.setOnTimeout(() {
// if (talkStatus.status == TalkStatus.waitingAnswer) {
// // 超时未接听，发送挂断请求
// startChartManage.sendTalkRejectMessage();
// Get.back();
// }
// });
}
@override
@ -63,16 +56,22 @@ class UdpTalkRequestHandler extends ScpMessageBaseHandle
// 来电事件的处理
void _talkRequestEvent({required String talkObjectName}) {
// 发送预期数据、通知锁板需要获取视频数据
_handleSendExpect();
// 播放铃声
playRingtone();
// 显示状态栏弹窗
_showTalkRequestNotification(talkObjectName: talkObjectName);
// 设置为等待接听状态
talkStatus.setWaitingAnswer();
// 启动通话保持
_handleStartTalkPing();
// 启动对讲请求超时定时器
talkeRequestOverTimeTimerManager.start();
// 收到呼叫请求，跳转到接听页面
Get.toNamed(
Routers.starChartTalkView,
);
// 触发震动反馈
HapticFeedback.vibrate();
// 设置为等待接听状态
talkStatus.setWaitingAnswer();
}
// 收到来电请求时进行本地通知
@ -119,4 +118,17 @@ class UdpTalkRequestHandler extends ScpMessageBaseHandle
return payload;
}
}
void _handleSendExpect() {
// 修改预期数据并启动发送预期数据定时器，在收到回复时停止
startChartManage.sendOnlyImageVideoTalkExpectData();
}
// 启动通话保持，判断x秒内是否收到通话保持
void _handleStartTalkPing() {
// 启动通话保持
startChartManage.startTalkPingMessageTimer();
// 启动通话保持监听定时器（用来判断如果x秒内没有收到通话保持则执行的操作）
talkePingOverTimeTimerManager.start();
}
}

2
lib/talk/startChart/handle/other/talke_ping_over_time_timer_manager.dart
View File

@ -27,7 +27,7 @@ class TalkePingOverTimeTimerManager {
// 超时处理函数
static void _handleTalkePingOverTime() {
if (talkStatus.status == TalkStatus.duringCall) {
if (talkStatus.status == TalkStatus.answeredSuccessfully) {
EasyLoading.showToast('通话异常中断', duration: 2000.milliseconds);
// 停止发送通话保持的命令
StartChartManage().stopTalkPingMessageTimer();

1
lib/talk/startChart/handle/other/talke_request_over_time_timer_manager.dart
View File

@ -28,6 +28,7 @@ class TalkeRequestOverTimeTimerManager {
// 超时处理函数
static void _handleTalkeRequestOverTime() {
if (talkStatus.status == TalkStatus.waitingAnswer) {
EasyLoading.showToast('通话未接通,以挂断', duration: 2000.milliseconds);
// 超时未接听，发送挂断请求
StartChartManage().sendTalkRejectMessage();
Get.back();