李勇 / McuClient

转到一个项目
Toggle navigation Toggle navigation pinning
李勇
135bcf0b 1 parent f3d3eb25

1.Emiter.js 中eimt的时候增加参数 

2.录制回放中音视频消息增加seek时间(秒),在APE处理中增加这个seek字段
内嵌 并排对比
正在显示 5 个修改的文件 包含 126 行增加 和 102 行删除
@@ -23,13 +23,13 @@ export default class Emiter { @@ -23,13 +23,13 @@ export default class Emiter {
23 } 23 }
24 } 24 }
25 } 25 }
26 - _emit(eid, data) { 26 + _emit(eid, data,data2) {
27 if (eid) { 27 if (eid) {
28 //eid=* broadcast 28 //eid=* broadcast
29 let asteriskStub =this.MAPS['*']; 29 let asteriskStub =this.MAPS['*'];
30 if (asteriskStub && asteriskStub.length) { 30 if (asteriskStub && asteriskStub.length) {
31 asteriskStub.forEach(function (elistener) { 31 asteriskStub.forEach(function (elistener) {
32 - elistener(eid, data); 32 + elistener(eid, data,data2);
33 }) 33 })
34 } 34 }
35 35
@@ -37,7 +37,7 @@ export default class Emiter { @@ -37,7 +37,7 @@ export default class Emiter {
37 let stub = this.MAPS[eid]; 37 let stub = this.MAPS[eid];
38 if (stub && stub.length) { 38 if (stub && stub.length) {
39 stub.forEach(function (elistener) { 39 stub.forEach(function (elistener) {
40 - elistener(data); 40 + elistener(data,data2);
41 }); 41 });
42 } 42 }
43 } 43 }
@@ -34,7 +34,7 @@ class RecordPlayBackParse extends Emiter { @@ -34,7 +34,7 @@ class RecordPlayBackParse extends Emiter {
34 this._recordPlaybackMaxTime = 0;//录制回放的总时间 34 this._recordPlaybackMaxTime = 0;//录制回放的总时间
35 this._isReady = false;//录制回放是否已经准备完成 35 this._isReady = false;//录制回放是否已经准备完成
36 this._apes = {}; 36 this._apes = {};
37 - this._messages = {}; 37 + //this._messages = {};
38 38
39 this._conferApeMssages = {};//会议数据 39 this._conferApeMssages = {};//会议数据
40 this._chatApeMssages = {};//聊天数据 40 this._chatApeMssages = {};//聊天数据
@@ -53,10 +53,8 @@ class RecordPlayBackParse extends Emiter { @@ -53,10 +53,8 @@ class RecordPlayBackParse extends Emiter {
53 this._apes[ape._session_id] = ape; 53 this._apes[ape._session_id] = ape;
54 } 54 }
55 55
56 - // 录制回放EverSocket底层消息处理 data-数据；timestamp-数据对应的时间戳  
57 - // 1.如果第二个参数timestamp不为空，数据就不往外发送，只做解析和储存  
58 - // 2.如果第二个参数timestamp为空，数据就发送给各个ape处理；  
59 - _everSocketMsgReceivedHandler(data, timestamp) { 56 + //发送数据个各个APE模块处理,data是数据，seekTime是当前数据需要seek的时间长度（针对音视频的seek）
  57 + _everSocketMsgReceivedHandler(data, seekTime) {
60 let pduMsg = pdu.decode_pdu(data); 58 let pduMsg = pdu.decode_pdu(data);
61 let pduType = pduMsg.get("type"); 59 let pduType = pduMsg.get("type");
62 let pduData = pduMsg.get("data"); 60 let pduData = pduMsg.get("data");
@@ -67,7 +65,7 @@ class RecordPlayBackParse extends Emiter { @@ -67,7 +65,7 @@ class RecordPlayBackParse extends Emiter {
67 pduMsg.type = PduType.RCPDU_SEND_DATA_REQUEST; 65 pduMsg.type = PduType.RCPDU_SEND_DATA_REQUEST;
68 pduType = PduType.RCPDU_SEND_DATA_REQUEST; 66 pduType = PduType.RCPDU_SEND_DATA_REQUEST;
69 } 67 }
70 - loger.log('pduType', pduType); 68 + loger.log('_everSocketMsgReceivedHandler->pduType', pduType,"seekTime->",seekTime);
71 switch (pduType) { 69 switch (pduType) {
72 case PduType.RCPDU_CONNECT_PROVIDER_RESPONSE: 70 case PduType.RCPDU_CONNECT_PROVIDER_RESPONSE:
73 //加入课堂请求返回数据处理 71 //加入课堂请求返回数据处理
@@ -77,7 +75,7 @@ class RecordPlayBackParse extends Emiter { @@ -77,7 +75,7 @@ class RecordPlayBackParse extends Emiter {
77 switch (pduResultCode) { 75 switch (pduResultCode) {
78 case PduConsts.RET_SUCCESS: 76 case PduConsts.RET_SUCCESS:
79 //加入成功 77 //加入成功
80 - this._updateMCUConfInfoDescription(joinConfPdu.classDescription); 78 + //this._updateMCUConfInfoDescription(joinConfPdu.classDescription);
81 this._emit(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this.classInfo); 79 this._emit(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this.classInfo);
82 break; 80 break;
83 case PduConsts.RET_FULL_CAPACITY: 81 case PduConsts.RET_FULL_CAPACITY:
@@ -92,41 +90,14 @@ class RecordPlayBackParse extends Emiter { @@ -92,41 +90,14 @@ class RecordPlayBackParse extends Emiter {
92 //先判断当前消息属于哪个APE 根据 sessionId来判断 90 //先判断当前消息属于哪个APE 根据 sessionId来判断
93 let ape = this._apes[pduMsg.sessionId]; 91 let ape = this._apes[pduMsg.sessionId];
94 let sessionLabel = ApeConsts(pduMsg.sessionId); 92 let sessionLabel = ApeConsts(pduMsg.sessionId);
95 - if (timestamp) {  
96 - //只做解析存储，不对外发送  
97 - loger.log('解析数据-timestamp->', timestamp, 'sessionId->', pduMsg.sessionId, 'sessionLabel->', sessionLabel);  
98 - switch (pduMsg.sessionId) {  
99 - case ApeConsts.CONFERENCE_SESSION_ID:  
100 - this.saveParseData(data, timestamp, this._conferApeMssages);  
101 - break;  
102 - case ApeConsts.CHAT_SESSION_ID:  
103 - this.saveParseData(data, timestamp, this._chatApeMssages);  
104 - break;  
105 - case ApeConsts.DOCSHARING_SESSION_ID:  
106 - this.saveParseData(data, timestamp, this._docApeMssages);  
107 - break;  
108 - case ApeConsts.WHITEBOARD_SESSION_ID:  
109 - this.saveParseData(data, timestamp, this._whiteApeMssages);  
110 - break;  
111 - case ApeConsts.VIDEO_SESSION_ID:  
112 - this.saveParseData(data, timestamp, this._videoApeMssages);  
113 - break;  
114 - case ApeConsts.AUDIO_SESSION_ID:  
115 - this.saveParseData(data, timestamp, this._audioApeMssages);  
116 - break;  
117 - default:  
118 - break;  
119 - } 93 + //对方发送消息
  94 + if (ape) {
  95 + let subTypeLabel = pdu.id2type(pduMsg.subType);
  96 + //loger.log('MCU-SecondLayer封装消息', 'sessionId', sessionLabel, pduMsg.sessionId, 'subtype', subTypeLabel, pduMsg.subType);
  97 + //ape广播事件，只要ape中监听就能收到
  98 + ape._emit(pduMsg.subType, pduMsg.data,seekTime);//seekTime是音视频模块seek的时间长度
120 } else { 99 } else {
121 - //对方发送消息  
122 - if (ape) {  
123 - let subTypeLabel = pdu.id2type(pduMsg.subType);  
124 - //loger.log('MCU-SecondLayer封装消息', 'sessionId', sessionLabel, pduMsg.sessionId, 'subtype', subTypeLabel, pduMsg.subType);  
125 - //ape广播事件，只要ape中监听就能收到  
126 - ape._emit(pduMsg.subType, pduMsg.data);  
127 - } else {  
128 - loger.warn(sessionLabel + '尚未注册');  
129 - } 100 + loger.warn(sessionLabel + '尚未注册');
130 } 101 }
131 break; 102 break;
132 default: 103 default:
@@ -134,6 +105,74 @@ class RecordPlayBackParse extends Emiter { @@ -134,6 +105,74 @@ class RecordPlayBackParse extends Emiter {
134 } 105 }
135 } 106 }
136 107
  108 + //解析和储存，录制回放EverSocket底层消息处理 data-数据；timestamp-数据对应的时间戳
  109 + _parseSaveSocketMsgReceivedHandler(data, timestamp) {
  110 + let pduMsg = pdu.decode_pdu(data);
  111 + let pduType = pduMsg.get("type");
  112 + let pduData = pduMsg.get("data");
  113 + //*************非常重要******************
  114 + //客户端发送的所有125消息，MCU收到之后会痛120把消息返回给客户端，
  115 + //所以需要把125消息type转换为120，因为MCU在录制的时候是直接录制客户端发送的消息而不是MCU转换之后的
  116 + if (pduType == PduType.RCPDU_UNIFORM_SEND_DATA_REQUEST) {
  117 + pduMsg.type = PduType.RCPDU_SEND_DATA_REQUEST;
  118 + pduType = PduType.RCPDU_SEND_DATA_REQUEST;
  119 + }
  120 + loger.log('pduType', pduType);
  121 + switch (pduType) {
  122 + case PduType.RCPDU_CONNECT_PROVIDER_RESPONSE:
  123 + //加入课堂请求返回数据处理
  124 + let joinConfPdu = pdu['RCConferenceJoinResponsePdu'].decode(pduData);
  125 + let pduResultCode = joinConfPdu.result;
  126 + loger.warn('RCPDU_CONNECT_PROVIDER_RESPONSE ->pduResultCode:' + pduResultCode);
  127 + switch (pduResultCode) {
  128 + case PduConsts.RET_SUCCESS:
  129 + //加入成功
  130 + //this._updateMCUConfInfoDescription(joinConfPdu.classDescription);
  131 + this._emit(MessageTypes.CLASS_JOIN_MCU_SUCCESS, this.classInfo);
  132 + break;
  133 + case PduConsts.RET_FULL_CAPACITY:
  134 + this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_CLASS_JOIN_FULL);
  135 + break;
  136 + default:
  137 + loger.warn('JoinConfPdu-未知类型-等待处理.', pduResultCode);
  138 + break
  139 + }
  140 + break;
  141 + case PduType.RCPDU_SEND_DATA_REQUEST:
  142 + //先判断当前消息属于哪个APE 根据 sessionId来判断
  143 + let ape = this._apes[pduMsg.sessionId];
  144 + let sessionLabel = ApeConsts(pduMsg.sessionId);
  145 + //只做解析存储，不对外发送
  146 + loger.log('解析数据-timestamp->', timestamp, 'sessionId->', pduMsg.sessionId, 'sessionLabel->', sessionLabel);
  147 + switch (pduMsg.sessionId) {
  148 + case ApeConsts.CONFERENCE_SESSION_ID:
  149 + this.saveParseData(data, timestamp, this._conferApeMssages);
  150 + break;
  151 + case ApeConsts.CHAT_SESSION_ID:
  152 + this.saveParseData(data, timestamp, this._chatApeMssages);
  153 + break;
  154 + case ApeConsts.DOCSHARING_SESSION_ID:
  155 + this.saveParseData(data, timestamp, this._docApeMssages);
  156 + break;
  157 + case ApeConsts.WHITEBOARD_SESSION_ID:
  158 + this.saveParseData(data, timestamp, this._whiteApeMssages);
  159 + break;
  160 + case ApeConsts.VIDEO_SESSION_ID:
  161 + this.saveParseData(data, timestamp, this._videoApeMssages);
  162 + break;
  163 + case ApeConsts.AUDIO_SESSION_ID:
  164 + this.saveParseData(data, timestamp, this._audioApeMssages);
  165 + break;
  166 + default:
  167 + break;
  168 + }
  169 +
  170 + break;
  171 + default:
  172 + loger.warn('PDU-未知类型-等待处理.', pduType);
  173 + }
  174 + }
  175 +
137 //保存数据 176 //保存数据
138 saveParseData(data, timestamp, apeMessages) { 177 saveParseData(data, timestamp, apeMessages) {
139 let messageItem = apeMessages[timestamp]; 178 let messageItem = apeMessages[timestamp];
@@ -223,7 +262,7 @@ class RecordPlayBackParse extends Emiter { @@ -223,7 +262,7 @@ class RecordPlayBackParse extends Emiter {
223 262
224 //解析数据 263 //解析数据
225 parseArrayBuf() { 264 parseArrayBuf() {
226 - this._messages = {}; 265 + //this._messages = {};
227 let byteLength = parseBuffer.offset; 266 let byteLength = parseBuffer.offset;
228 parseBuffer.byteOffset = 0; 267 parseBuffer.byteOffset = 0;
229 var position = 0; 268 var position = 0;
@@ -236,14 +275,14 @@ class RecordPlayBackParse extends Emiter { @@ -236,14 +275,14 @@ class RecordPlayBackParse extends Emiter {
236 position += byteLen; 275 position += byteLen;
237 console.log(timestamp, byteLen, byteData); 276 console.log(timestamp, byteLen, byteData);
238 277
239 - let messageItem = this._messages[timestamp];  
240 - if (!messageItem) {  
241 - this._messages[timestamp] = [];//数组存数据，因为有1秒内收到多个消息的情况，timestamp是按秒记录的  
242 - messageItem = this._messages[timestamp];  
243 - }  
244 - messageItem.push({"timestamp": timestamp, "byteData": byteData}); 278 + /* let messageItem = this._messages[timestamp];
  279 + if (!messageItem) {
  280 + this._messages[timestamp] = [];//数组存数据，因为有1秒内收到多个消息的情况，timestamp是按秒记录的
  281 + messageItem = this._messages[timestamp];
  282 + }
  283 + messageItem.push({"timestamp": timestamp, "byteData": byteData});*/
245 284
246 - this._everSocketMsgReceivedHandler(byteData, timestamp); 285 + this._parseSaveSocketMsgReceivedHandler(byteData, timestamp);
247 //记录最后一个数据的时间戳作为整个录制回放的总时间戳 286 //记录最后一个数据的时间戳作为整个录制回放的总时间戳
248 this._recordPlaybackMaxTime = timestamp; 287 this._recordPlaybackMaxTime = timestamp;
249 } 288 }
@@ -253,7 +292,7 @@ class RecordPlayBackParse extends Emiter { @@ -253,7 +292,7 @@ class RecordPlayBackParse extends Emiter {
253 292
254 GlobalConfig.recordPlaybackMaxTime = this._recordPlaybackMaxTime; 293 GlobalConfig.recordPlaybackMaxTime = this._recordPlaybackMaxTime;
255 loger.log("录制回放数据解析完成,录制回放的总时间长为->", this._recordPlaybackMaxTime); 294 loger.log("录制回放数据解析完成,录制回放的总时间长为->", this._recordPlaybackMaxTime);
256 - console.log("_messages", this._messages); 295 + //console.log("_messages", this._messages);
257 console.log("_conferApeMssages", this._conferApeMssages); 296 console.log("_conferApeMssages", this._conferApeMssages);
258 console.log("_chatApeMssages", this._chatApeMssages); 297 console.log("_chatApeMssages", this._chatApeMssages);
259 console.log("_docApeMssages", this._docApeMssages); 298 console.log("_docApeMssages", this._docApeMssages);
@@ -272,7 +311,7 @@ class RecordPlayBackParse extends Emiter { @@ -272,7 +311,7 @@ class RecordPlayBackParse extends Emiter {
272 } else { 311 } else {
273 //把时间点对应的数据发送,同一秒内有存在多个数据的情况 312 //把时间点对应的数据发送,同一秒内有存在多个数据的情况
274 for (let i = 0; i < msgDataArr.length; i++) { 313 for (let i = 0; i < msgDataArr.length; i++) {
275 - this._everSocketMsgReceivedHandler(msgDataArr[i].byteData); 314 + this._everSocketMsgReceivedHandler(msgDataArr[i].byteData,0);
276 } 315 }
277 } 316 }
278 } 317 }
@@ -331,14 +370,14 @@ class RecordPlayBackParse extends Emiter { @@ -331,14 +370,14 @@ class RecordPlayBackParse extends Emiter {
331 370
332 _searchKeyfram() { 371 _searchKeyfram() {
333 //查找关键帧，找到关键帧后再继续播放 372 //查找关键帧，找到关键帧后再继续播放
334 - this._searchApeMessageKeyfram(this._conferApeMssages,ApeConsts.CONFERENCE_SESSION_ID);  
335 - this._searchApeMessageKeyfram(this._docApeMssages,ApeConsts.DOCSHARING_SESSION_ID);  
336 - this._searchApeMessageKeyfram(this._whiteApeMssages,ApeConsts.WHITEBOARD_SESSION_ID);  
337 - this._searchApeMessageKeyfram(this._videoApeMssages,ApeConsts.VIDEO_SESSION_ID);  
338 - this._searchApeMessageKeyfram(this._audioApeMssages,ApeConsts.AUDIO_SESSION_ID); 373 + this._searchApeMessageKeyfram(this._conferApeMssages, ApeConsts.CONFERENCE_SESSION_ID);
  374 + this._searchApeMessageKeyfram(this._docApeMssages, ApeConsts.DOCSHARING_SESSION_ID);
  375 + this._searchApeMessageKeyfram(this._whiteApeMssages, ApeConsts.WHITEBOARD_SESSION_ID);
  376 + this._searchApeMessageKeyfram(this._videoApeMssages, ApeConsts.VIDEO_SESSION_ID);
  377 + this._searchApeMessageKeyfram(this._audioApeMssages, ApeConsts.AUDIO_SESSION_ID);
339 378
340 //聊天模块的比较特殊，消息是累计的 379 //聊天模块的比较特殊，消息是累计的
341 - this._searchChatApeMessageKeyfram(this._chatApeMssages,ApeConsts.CHAT_SESSION_ID); 380 + this._searchChatApeMessageKeyfram(this._chatApeMssages, ApeConsts.CHAT_SESSION_ID);
342 381
343 382
344 //各个ape模块无论有没有找到关键帧数据，都继续播放 383 //各个ape模块无论有没有找到关键帧数据，都继续播放
@@ -346,25 +385,25 @@ class RecordPlayBackParse extends Emiter { @@ -346,25 +385,25 @@ class RecordPlayBackParse extends Emiter {
346 } 385 }
347 386
348 //查找ape关键帧数据 387 //查找ape关键帧数据
349 - _searchApeMessageKeyfram(_apeMessages,_apeId) { 388 + _searchApeMessageKeyfram(_apeMessages, _apeId) {
350 let messageItem; 389 let messageItem;
351 - let keyFrameSeek = 0; 390 + let keyFrameSeekTime = 0;
352 for (let i = this._recordPlaybackTimestamp; i > 0; i--) { 391 for (let i = this._recordPlaybackTimestamp; i > 0; i--) {
353 messageItem = _apeMessages[i]; 392 messageItem = _apeMessages[i];
354 if (messageItem) { 393 if (messageItem) {
355 - keyFrameSeek = (this._recordPlaybackTimestamp - i)  
356 - loger.log("SEEK->APE",_apeId, this._recordPlaybackTimestamp, "查找到相连的数据, messageItem.timestamp->",i, this._recordPlaybackTimestamp,keyFrameSeek, "秒"); 394 + keyFrameSeekTime = (this._recordPlaybackTimestamp - i)
  395 + loger.log("SEEK->APE", ApeConsts(_apeId), this._recordPlaybackTimestamp, "查找到相连的timestamp->", i, '需要seek->', keyFrameSeekTime, "秒");
357 //把时间点对应的数据发送,同一秒内有存在多个数据的情况 396 //把时间点对应的数据发送,同一秒内有存在多个数据的情况
358 for (let k = 0; k < messageItem.length; k++) { 397 for (let k = 0; k < messageItem.length; k++) {
359 - this._everSocketMsgReceivedHandler(messageItem[k].byteData); 398 + this._everSocketMsgReceivedHandler(messageItem[k].byteData,keyFrameSeekTime);
360 } 399 }
361 - if(_apeId==ApeConsts.AUDIO_SESSION_ID||_apeId==ApeConsts.VIDEO_SESSION_ID){  
362 - this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE, {"status": SEEK, "keyFrameSeek": keyFrameSeek}); 400 + if (_apeId == ApeConsts.AUDIO_SESSION_ID || _apeId == ApeConsts.VIDEO_SESSION_ID) {
  401 + this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE, {"status": SEEK, "keyFrameSeekTime": keyFrameSeekTime});
363 } 402 }
364 return; 403 return;
365 } 404 }
366 } 405 }
367 - loger.log("SEEK->APE",_apeId, this._recordPlaybackTimestamp, "没有查找到相连的数据"); 406 + loger.log("SEEK->APE", ApeConsts(_apeId), this._recordPlaybackTimestamp, "没有查找到相连的数据");
368 //this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE,{"status":SEEK,"keyFrameSeek":keyFrameSeek}); 407 //this._emit(MessageTypes.RECORD_PLAYBACK_UPDATE,{"status":SEEK,"keyFrameSeek":keyFrameSeek});
369 } 408 }
370 409
@@ -377,7 +416,7 @@ class RecordPlayBackParse extends Emiter { @@ -377,7 +416,7 @@ class RecordPlayBackParse extends Emiter {
377 if (messageItem) { 416 if (messageItem) {
378 //把时间点对应的数据发送,同一秒内有存在多个数据的情况 417 //把时间点对应的数据发送,同一秒内有存在多个数据的情况
379 for (let i = 0; i < messageItem.length; i++) { 418 for (let i = 0; i < messageItem.length; i++) {
380 - this._everSocketMsgReceivedHandler(messageItem[i].byteData); 419 + this._everSocketMsgReceivedHandler(messageItem[i].byteData,0);
381 } 420 }
382 } 421 }
383 } 422 }
@@ -73,46 +73,27 @@ export default class Ape extends Emiter { @@ -73,46 +73,27 @@ export default class Ape extends Emiter {
73 } 73 }
74 74
75 // 消息处理 75 // 消息处理
76 - _pduMessageHandler(regBuffer) {  
77 - //loger.log("RCPDU_REG_ADAPTER=============================="); 76 + _pduMessageHandler(regBuffer,_seekTime) {
  77 + let seekTime=_seekTime||0;//这个只有在录制回放的时候才有
  78 + //loger.log("RCPDU_REG_ADAPTER============seekTime",seekTime);
78 if (this._apeDelayed) { 79 if (this._apeDelayed) {
79 // this._apeDelayedMsgs.push(regBuffer); 80 // this._apeDelayedMsgs.push(regBuffer);
80 // this._apeDelayedStart(); 81 // this._apeDelayedStart();
81 setTimeout(() => { 82 setTimeout(() => {
82 - this._pduRegAdapterHandler(regBuffer); 83 + this._pduRegAdapterHandler(regBuffer,seekTime);
83 }, GlobalConfig.mcuDelay || 2000); 84 }, GlobalConfig.mcuDelay || 2000);
84 return; 85 return;
85 } 86 }
86 - this._pduRegAdapterHandler(regBuffer); 87 + this._pduRegAdapterHandler(regBuffer,seekTime);
87 } 88 }
88 89
89 - // _apeDelayedStart() {  
90 - // if (this._apeDelayed && !this._apeDelayedTimer) {  
91 - // this._apeDelayedTimer = setInterval(this._delayedMsgHandler.bind(this), this._classInfo['mcuDelay'] || 10000);  
92 - // }  
93 - // }  
94 -  
95 - // _apeDelayedStop() {  
96 - // clearInterval(this._apeDelayedTimer);  
97 - // this._apeDelayedTimer = 0;  
98 - // }  
99 -  
100 - // // 延迟消息处理  
101 - // _delayedMsgHandler() {  
102 - // if (this._apeDelayedMsgs.length) {  
103 - // this._pduRegAdapterHandler(this._apeDelayedMsgs.pop());  
104 - // if (!this._apeDelayedMsgs.length) this._apeDelayedStop();  
105 - // }  
106 - // }  
107 -  
108 // 数据同步处理 90 // 数据同步处理
109 - _pduRegAdapterHandler(regBuffer) { 91 + _pduRegAdapterHandler(regBuffer,seekTime) {
110 let regPdu = pdu['RCAdapterPdu'].decode(regBuffer); 92 let regPdu = pdu['RCAdapterPdu'].decode(regBuffer);
111 let regItems = regPdu.item; 93 let regItems = regPdu.item;
112 let regItemSize = regItems.length; 94 let regItemSize = regItems.length;
113 //loger.log(this._session_name + '数据同步消息'); 95 //loger.log(this._session_name + '数据同步消息');
114 - loger.log(this._session_name + '数据同步消息.同步条数', regItemSize);  
115 - //console.log(regPdu); 96 + loger.log(this._session_name + '数据同步消息.同步条数', regItemSize,"seekTime->",seekTime);
116 97
117 for (var i = 0; i < regItemSize; ++i) { 98 for (var i = 0; i < regItemSize; ++i) {
118 let regItem = regItems[i]; 99 let regItem = regItems[i];
@@ -188,7 +169,7 @@ export default class Ape extends Emiter { @@ -188,7 +169,7 @@ export default class Ape extends Emiter {
188 169
189 for (let i = 0; i < tableUpdateItemsLen; ++i) { 170 for (let i = 0; i < tableUpdateItemsLen; ++i) {
190 let tableItem = tableUpdateItems[i]; 171 let tableItem = tableUpdateItems[i];
191 - this.tableUpdateHandler(tableItem.owner, tableItem.itemIdx, tableItem.itemData); 172 + this.tableUpdateHandler(tableItem.owner, tableItem.itemIdx, tableItem.itemData,seekTime);
192 } 173 }
193 break; 174 break;
194 case pdu.RCPDU_REG_QUEUE_UPDATE_PDU: 175 case pdu.RCPDU_REG_QUEUE_UPDATE_PDU:
@@ -217,7 +198,7 @@ export default class Ape extends Emiter { @@ -217,7 +198,7 @@ export default class Ape extends Emiter {
217 loger.warn(this._session_name + ' tableInsertHandler 应有子类具体覆盖处理.'); 198 loger.warn(this._session_name + ' tableInsertHandler 应有子类具体覆盖处理.');
218 } 199 }
219 200
220 - tableUpdateHandler(ownerId, recordId, recordData) { 201 + tableUpdateHandler(ownerId, recordId, recordData,seekTime) {
221 loger.warn(this._session_name + ' tableUpdateHandler 应有子类具体覆盖处理.'); 202 loger.warn(this._session_name + ' tableUpdateHandler 应有子类具体覆盖处理.');
222 } 203 }
223 204
@@ -299,10 +299,9 @@ class AudioApe extends Ape { @@ -299,10 +299,9 @@ class AudioApe extends Ape {
299 } 299 }
300 } 300 }
301 301
302 - tableUpdateHandler(owner, itemIdx, itemData) { 302 + tableUpdateHandler(owner, itemIdx, itemData,seek) {
303 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData); 303 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData);
304 - loger.log("tableUpdateHandler,channel",itemIdx);  
305 - 304 + loger.log("tableUpdateHandler->channel",itemIdx,'status->',unpackChannelInfo.status,"seek->",seek);
306 //****很重要******** 305 //****很重要********
307 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0) 306 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0)
308 if(owner==0){ 307 if(owner==0){
@@ -324,6 +323,9 @@ class AudioApe extends Ape { @@ -324,6 +323,9 @@ class AudioApe extends Ape {
324 receiveChannelInfo.m3u8Url=""; 323 receiveChannelInfo.m3u8Url="";
325 receiveChannelInfo.rtmpUrl=""; 324 receiveChannelInfo.rtmpUrl="";
326 receiveChannelInfo.replay=""; 325 receiveChannelInfo.replay="";
  326 +
  327 + receiveChannelInfo.seek=seek||0;//这个是录制回放时使用的seek
  328 +
327 let m3u8Stream=this.mediaModule.getMediaPlayPath({"type":"m3u8","streamId": unpackChannelInfo.streamId}); 329 let m3u8Stream=this.mediaModule.getMediaPlayPath({"type":"m3u8","streamId": unpackChannelInfo.streamId});
328 let rtmpStream=this.mediaModule.getMediaPlayPath({"type":"rtmp","streamId": unpackChannelInfo.streamId}); 330 let rtmpStream=this.mediaModule.getMediaPlayPath({"type":"rtmp","streamId": unpackChannelInfo.streamId});
329 let replay=this.mediaModule.getMediaRecordPlaybackPath({"type":"m3u8","streamId": unpackChannelInfo.streamId}); 331 let replay=this.mediaModule.getMediaRecordPlaybackPath({"type":"m3u8","streamId": unpackChannelInfo.streamId});
@@ -302,10 +302,10 @@ class VideoApe extends Ape { @@ -302,10 +302,10 @@ class VideoApe extends Ape {
302 } 302 }
303 } 303 }
304 304
305 - tableUpdateHandler(owner, itemIdx, itemData) { 305 + tableUpdateHandler(owner, itemIdx, itemData,seek) {
306 // debugger; 306 // debugger;
307 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData); 307 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData);
308 - loger.log("tableUpdateHandler,channel",itemIdx); 308 + loger.log("tableUpdateHandler->channel",itemIdx,'status->',unpackChannelInfo.status,"seek->",seek);
309 309
310 //****很重要******** 310 //****很重要********
311 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0) 311 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0)
@@ -328,6 +328,8 @@ class VideoApe extends Ape { @@ -328,6 +328,8 @@ class VideoApe extends Ape {
328 receiveChannelInfo.rtmpUrl=""; 328 receiveChannelInfo.rtmpUrl="";
329 receiveChannelInfo.replay=""; 329 receiveChannelInfo.replay="";
330 330
  331 + receiveChannelInfo.seek=seek||0;//这个是录制回放时使用的seek
  332 +
331 let m3u8Stream=this.mediaModule.getMediaPlayPath({"type":"m3u8","streamId": unpackChannelInfo.streamId}); 333 let m3u8Stream=this.mediaModule.getMediaPlayPath({"type":"m3u8","streamId": unpackChannelInfo.streamId});
332 let rtmpStream=this.mediaModule.getMediaPlayPath({"type":"rtmp","streamId": unpackChannelInfo.streamId}); 334 let rtmpStream=this.mediaModule.getMediaPlayPath({"type":"rtmp","streamId": unpackChannelInfo.streamId});
333 let replay=this.mediaModule.getMediaRecordPlaybackPath({"type":"m3u8","streamId": unpackChannelInfo.streamId}); 335 let replay=this.mediaModule.getMediaRecordPlaybackPath({"type":"m3u8","streamId": unpackChannelInfo.streamId});