李勇 / McuClient

转到一个项目
Toggle navigation Toggle navigation pinning
李勇
d333c312 1 parent ee8cdea7

1.音视频模块推流接口增加optionJsonData:{"bufferTime":0}} 用于设置播放流的时候的bufferTime

内嵌 并排对比
正在显示 3 个修改的文件 包含 485 行增加 和 403 行删除
@@ -58,7 +58,7 @@ export default class MessageEntrance extends Emiter { @@ -58,7 +58,7 @@ export default class MessageEntrance extends Emiter {
58 constructor() { 58 constructor() {
59 super(); 59 super();
60 //sdk 信息 60 //sdk 信息
61 - GlobalConfig.sdkVersion = "v1.79.4.20170821"; 61 + GlobalConfig.sdkVersion = "v1.79.5.20170821";
62 loger.warn("sdkVersion:" + GlobalConfig.sdkVersion); 62 loger.warn("sdkVersion:" + GlobalConfig.sdkVersion);
63 63
64 //设置 64 //设置
@@ -1796,7 +1796,6 @@ export default class MessageEntrance extends Emiter { @@ -1796,7 +1796,6 @@ export default class MessageEntrance extends Emiter {
1796 return {"code": ApeConsts.RETURN_FAILED, "data": ""}; 1796 return {"code": ApeConsts.RETURN_FAILED, "data": ""};
1797 } 1797 }
1798 if (_video_ape) { 1798 if (_video_ape) {
1799 - GlobalConfig.optionJsonData=_param.optionJsonData||"";  
1800 return _video_ape.publishVideo(_param); 1799 return _video_ape.publishVideo(_param);
1801 } 1800 }
1802 } 1801 }
@@ -1853,7 +1852,6 @@ export default class MessageEntrance extends Emiter { @@ -1853,7 +1852,6 @@ export default class MessageEntrance extends Emiter {
1853 return {"code": ApeConsts.RETURN_FAILED, "data": ""}; 1852 return {"code": ApeConsts.RETURN_FAILED, "data": ""};
1854 } 1853 }
1855 if (_audio_ape) { 1854 if (_audio_ape) {
1856 - GlobalConfig.optionJsonData=_param.optionJsonData||"";  
1857 return _audio_ape.publishAudio(_param); 1855 return _audio_ape.publishAudio(_param);
1858 } 1856 }
1859 } 1857 }
@@ -21,11 +21,11 @@ class AudioApe extends Ape { @@ -21,11 +21,11 @@ class AudioApe extends Ape {
21 ApeConsts.AUDIO_SESSION_TAG 21 ApeConsts.AUDIO_SESSION_TAG
22 ); 22 );
23 23
24 - this.releaseTimeId=0  
25 - this.mediaModule=new MediaModule();  
26 - this.mediaModule.MEDIA_OBJ_TABLE_ID=ApeConsts.AUDIO_OBJ_TABLE_ID;  
27 - this.mediaModule.mediaChannels={};  
28 - this.mediaModule.mediaType=ApeConsts.MEDIA_TYPE_AUDIO; 24 + this.releaseTimeId = 0
  25 + this.mediaModule = new MediaModule();
  26 + this.mediaModule.MEDIA_OBJ_TABLE_ID = ApeConsts.AUDIO_OBJ_TABLE_ID;
  27 + this.mediaModule.mediaChannels = {};
  28 + this.mediaModule.mediaType = ApeConsts.MEDIA_TYPE_AUDIO;
29 // Ape Models 29 // Ape Models
30 this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer); 30 this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer);
31 this.registerObj(pdu.RCPDU_REG_REGISTER_TABLE, ApeConsts.AUDIO_OBJ_TABLE_ID, ApeConsts.AUDIO_OBJ_TABLE_NAME, ApeConsts.AUDIO_OBJ_TABLE_TAG, 0, new ArrayBuffer); 31 this.registerObj(pdu.RCPDU_REG_REGISTER_TABLE, ApeConsts.AUDIO_OBJ_TABLE_ID, ApeConsts.AUDIO_OBJ_TABLE_NAME, ApeConsts.AUDIO_OBJ_TABLE_TAG, 0, new ArrayBuffer);
@@ -33,10 +33,11 @@ class AudioApe extends Ape { @@ -33,10 +33,11 @@ class AudioApe extends Ape {
33 // 广播消息，用户之间的消息传递 33 // 广播消息，用户之间的消息传递
34 this.on(pdu.RCPDU_SEND_AUDIO_DATA_REQUEST, this.receiveAudiooCommandHandler.bind(this)); 34 this.on(pdu.RCPDU_SEND_AUDIO_DATA_REQUEST, this.receiveAudiooCommandHandler.bind(this));
35 } 35 }
  36 +
36 //ape加入成功 37 //ape加入成功
37 - onJoinChannelHandlerSuccess(){ 38 + onJoinChannelHandlerSuccess() {
38 //这个设置很重要，因为只有Sass流程完成之后，APE才能取得GlobalConfig中的数据 39 //这个设置很重要，因为只有Sass流程完成之后，APE才能取得GlobalConfig中的数据
39 - this.mediaModule.maxMediaChannel=GlobalConfig.maxAudioChannels; 40 + this.mediaModule.maxMediaChannel = GlobalConfig.maxAudioChannels;
40 } 41 }
41 42
42 /////////////发送数据操作//////////////////////////////////////////// 43 /////////////发送数据操作////////////////////////////////////////////
@@ -49,66 +50,77 @@ class AudioApe extends Ape { @@ -49,66 +50,77 @@ class AudioApe extends Ape {
49 //获取推流地址 50 //获取推流地址
50 getAudioPublishPath(_param) { 51 getAudioPublishPath(_param) {
51 loger.log('获取推流地址->'); 52 loger.log('获取推流地址->');
52 - if(!this.mcu.connected){ 53 + if (!this.mcu.connected) {
53 loger.warn(GlobalConfig.getCurrentStatus()); 54 loger.warn(GlobalConfig.getCurrentStatus());
54 - return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};; 55 + return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
  56 + ;
55 } 57 }
56 //监课比较特殊，不占用课堂内的音视频路数，额外创建 58 //监课比较特殊，不占用课堂内的音视频路数，额外创建
57 - if(GlobalConfig.userRole==ApeConsts.invisible){  
58 - let result=this.mediaModule.getMediaPublishPathForInVisible(_param);  
59 - this._emit( MessageTypes.AUDIO_GET_PUBLISH_PATH,result); 59 + if (GlobalConfig.userRole == ApeConsts.invisible) {
  60 + let result = this.mediaModule.getMediaPublishPathForInVisible(_param);
  61 + this._emit(MessageTypes.AUDIO_GET_PUBLISH_PATH, result);
60 return result; 62 return result;
61 } 63 }
62 64
63 //非监课的身份，需要判断是否可以继续推流 65 //非监课的身份，需要判断是否可以继续推流
64 //需要判断当前已经使用的流路数 66 //需要判断当前已经使用的流路数
65 - let openChannel=0;  
66 - let allChannels= MediaModule.allMediaChannelsList;  
67 - for(let i in allChannels){  
68 - let channel=allChannels[i];  
69 - if(channel&&channel.status==ApeConsts.CHANNEL_STATUS_OPENING&&channel.userRole!=ApeConsts.invisible){ 67 + let openChannel = 0;
  68 + let allChannels = MediaModule.allMediaChannelsList;
  69 + for (let i in allChannels) {
  70 + let channel = allChannels[i];
  71 + if (channel && channel.status == ApeConsts.CHANNEL_STATUS_OPENING && channel.userRole != ApeConsts.invisible) {
70 //正在开启的才计数，监课开启的不计算在内 72 //正在开启的才计数，监课开启的不计算在内
71 openChannel++; 73 openChannel++;
72 } 74 }
73 } 75 }
74 //如果已经开启的数量大于等于最大允许开启的数量，不允许再推流 76 //如果已经开启的数量大于等于最大允许开启的数量，不允许再推流
75 - if(openChannel>=GlobalConfig.maxMediaChannels){  
76 - loger.warn('不能再打开设备->当前开启的设备数量->',openChannel); 77 + if (openChannel >= GlobalConfig.maxMediaChannels) {
  78 + loger.warn('不能再打开设备->当前开启的设备数量->', openChannel);
77 return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开设备,当前开启的设备数量"}; 79 return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开设备,当前开启的设备数量"};
78 } 80 }
79 81
80 - let result=this.mediaModule.getMediaPublishPath(_param);  
81 - this._emit( MessageTypes.AUDIO_GET_PUBLISH_PATH,result); 82 + let result = this.mediaModule.getMediaPublishPath(_param);
  83 + this._emit(MessageTypes.AUDIO_GET_PUBLISH_PATH, result);
82 return result; 84 return result;
83 } 85 }
84 86
85 //获取当前所有频道信息 87 //获取当前所有频道信息
86 - getAllChannelInfo(_param){ 88 + getAllChannelInfo(_param) {
87 loger.log('获取当前所有频道信息->'); 89 loger.log('获取当前所有频道信息->');
88 return this.mediaModule.getAllMediaChannelInfo(); 90 return this.mediaModule.getAllMediaChannelInfo();
89 } 91 }
90 92
91 //推流 93 //推流
92 publishAudio(_param) { 94 publishAudio(_param) {
93 - if(!this.mcu.connected){ 95 + if (!this.mcu.connected) {
94 loger.warn(GlobalConfig.getCurrentStatus()); 96 loger.warn(GlobalConfig.getCurrentStatus());
95 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"已经断开连接!","mediaId":0});  
96 - return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接","mediaId":0}; 97 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接!", "mediaId": 0});
  98 + return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接", "mediaId": 0};
97 } 99 }
98 100
99 - if (_param == null||_param.publishUrl == null)  
100 - { 101 + if (_param == null || _param.publishUrl == null) {
101 loger.warn('推流->参数错误', _param); 102 loger.warn('推流->参数错误', _param);
102 this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG); 103 this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
103 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"参数错误!","mediaId":0}); 104 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "参数错误!", "mediaId": 0});
104 return {"code": ApeConsts.RETURN_FAILED, "data": "参数错误"}; 105 return {"code": ApeConsts.RETURN_FAILED, "data": "参数错误"};
105 } 106 }
106 107
  108 + //获取可选参数,转换为JSON字符串
  109 + try {
  110 + GlobalConfig.optionJsonData = JSON.stringify(_param.optionJsonData) || ""
  111 + } catch (err) {
  112 + GlobalConfig.optionJsonData = "";
  113 + }
  114 +
107 //根据推流的地址获取对应的频道信息 115 //根据推流的地址获取对应的频道信息
108 - let needPublishChannelInfo=this.mediaModule.getNeedPublishMediaChannel(_param.publishUrl);  
109 - if(needPublishChannelInfo==null){ 116 + let needPublishChannelInfo = this.mediaModule.getNeedPublishMediaChannel(_param.publishUrl);
  117 + if (needPublishChannelInfo == null) {
110 loger.warn('推流->推流数据已经无效', _param); 118 loger.warn('推流->推流数据已经无效', _param);
111 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"推流数据已经无效!","mediaId":0}); 119 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {
  120 + "code": ApeConsts.RETURN_FAILED,
  121 + "data": "推流数据已经无效!",
  122 + "mediaId": 0
  123 + });
112 return {"code": ApeConsts.RETURN_FAILED, "data": "推流数据已经无效"}; 124 return {"code": ApeConsts.RETURN_FAILED, "data": "推流数据已经无效"};
113 } 125 }
114 126
@@ -116,90 +128,111 @@ class AudioApe extends Ape { @@ -116,90 +128,111 @@ class AudioApe extends Ape {
116 let freeChannel = this.mediaModule.getFreeMediaChannel(); 128 let freeChannel = this.mediaModule.getFreeMediaChannel();
117 if (freeChannel == 0) { 129 if (freeChannel == 0) {
118 loger.warn("推流->不能再打开更多的设备"); 130 loger.warn("推流->不能再打开更多的设备");
119 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备","mediaId":0});  
120 - return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备","mediaChannels":this.mediaModule.mediaChannels}; 131 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {
  132 + "code": ApeConsts.RETURN_FAILED,
  133 + "data": "不能再打开更多的设备",
  134 + "mediaId": 0
  135 + });
  136 + return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备", "mediaChannels": this.mediaModule.mediaChannels};
121 } 137 }
122 138
123 //判断当前的频道是否已经占用 139 //判断当前的频道是否已经占用
124 - if(this.mediaModule.checkChannelIsOpening(needPublishChannelInfo.channelId)){  
125 - if(needPublishChannelInfo.nodeId==GlobalConfig.nodeId){  
126 - loger.warn(needPublishChannelInfo.channelId,"已经推送过消息，不需要再次推送!");  
127 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_SUCCESS, "data":"已经推送过消息，不需要再次推送!","mediaId":needPublishChannelInfo.channelId});  
128 - return {"code": ApeConsts.RETURN_SUCCESS, "data":"已经推送过消息，不需要再次推送!","mediaId":needPublishChannelInfo.channelId};  
129 - }else {  
130 - loger.warn(needPublishChannelInfo.channelId,"频道已经被占用");  
131 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"频道已经被占用!","mediaId":0});  
132 - return {"code": ApeConsts.RETURN_FAILED, "data":"频道已经被占用!"}; 140 + if (this.mediaModule.checkChannelIsOpening(needPublishChannelInfo.channelId)) {
  141 + if (needPublishChannelInfo.nodeId == GlobalConfig.nodeId) {
  142 + loger.warn(needPublishChannelInfo.channelId, "已经推送过消息，不需要再次推送!");
  143 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {
  144 + "code": ApeConsts.RETURN_SUCCESS,
  145 + "data": "已经推送过消息，不需要再次推送!",
  146 + "mediaId": needPublishChannelInfo.channelId
  147 + });
  148 + return {
  149 + "code": ApeConsts.RETURN_SUCCESS,
  150 + "data": "已经推送过消息，不需要再次推送!",
  151 + "mediaId": needPublishChannelInfo.channelId
  152 + };
  153 + } else {
  154 + loger.warn(needPublishChannelInfo.channelId, "频道已经被占用");
  155 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {
  156 + "code": ApeConsts.RETURN_FAILED,
  157 + "data": "频道已经被占用!",
  158 + "mediaId": 0
  159 + });
  160 + return {"code": ApeConsts.RETURN_FAILED, "data": "频道已经被占用!"};
133 } 161 }
134 162
135 163
136 } 164 }
137 165
138 - let channelInfo=this.mediaModule.getDefaultChannelInfo();  
139 - channelInfo.owner=GlobalConfig.nodeId;  
140 - channelInfo.status=ApeConsts.CHANNEL_STATUS_OPENING;  
141 - channelInfo.channelId=needPublishChannelInfo.channelId;//freeChannel  
142 - channelInfo.streamId=needPublishChannelInfo.streamId;//按规则拼接的流名称  
143 - channelInfo.timestamp=needPublishChannelInfo.timestamp;//EngineUtils.creatTimestamp();  
144 - channelInfo.mediaType=ApeConsts.MEDIA_TYPE_AUDIO; 166 + let channelInfo = this.mediaModule.getDefaultChannelInfo();
  167 + channelInfo.owner = GlobalConfig.nodeId;
  168 + channelInfo.status = ApeConsts.CHANNEL_STATUS_OPENING;
  169 + channelInfo.channelId = needPublishChannelInfo.channelId;//freeChannel
  170 + channelInfo.streamId = needPublishChannelInfo.streamId;//按规则拼接的流名称
  171 + channelInfo.timestamp = needPublishChannelInfo.timestamp;//EngineUtils.creatTimestamp();
  172 + channelInfo.mediaType = ApeConsts.MEDIA_TYPE_AUDIO;
145 this.sendTableUpdateHandler(channelInfo); 173 this.sendTableUpdateHandler(channelInfo);
146 - this._emit( MessageTypes.AUDIO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_SUCCESS, "data":"推流成功!","mediaId":needPublishChannelInfo.channelId});  
147 - return {"code": ApeConsts.RETURN_SUCCESS, "data":"推流成功!","mediaId":needPublishChannelInfo.channelId}; 174 + this._emit(MessageTypes.AUDIO_PUBLISH_RESULT, {
  175 + "code": ApeConsts.RETURN_SUCCESS,
  176 + "data": "推流成功!",
  177 + "mediaId": needPublishChannelInfo.channelId
  178 + });
  179 + return {"code": ApeConsts.RETURN_SUCCESS, "data": "推流成功!", "mediaId": needPublishChannelInfo.channelId};
148 } 180 }
149 181
150 //停止推流， 182 //停止推流，
151 stopPublishAudio(_param) { 183 stopPublishAudio(_param) {
152 - loger.log('停止推流 ->',_param);  
153 - if(!this.mcu.connected){ 184 + loger.log('停止推流 ->', _param);
  185 + if (!this.mcu.connected) {
154 loger.warn(GlobalConfig.getCurrentStatus()); 186 loger.warn(GlobalConfig.getCurrentStatus());
155 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 187 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
156 } 188 }
157 189
158 //默认为自己的nodeId，_param如果为空，那么默认就是当前自己的nodeId，否则用_param 190 //默认为自己的nodeId，_param如果为空，那么默认就是当前自己的nodeId，否则用_param
159 - let nodeId=GlobalConfig.nodeId;  
160 - if(_param&&parseInt(_param.nodeId)>0){  
161 - nodeId=parseInt(_param.nodeId); 191 + let nodeId = GlobalConfig.nodeId;
  192 + if (_param && parseInt(_param.nodeId) > 0) {
  193 + nodeId = parseInt(_param.nodeId);
162 } 194 }
163 195
164 //默认为0,如果releaseChannelId 存在就释放releaseChannelId通道 196 //默认为0,如果releaseChannelId 存在就释放releaseChannelId通道
165 - let releaseChannelId=0;  
166 - if(_param&&parseInt(_param.mediaId)>0){  
167 - releaseChannelId=parseInt(_param.mediaId); 197 + let releaseChannelId = 0;
  198 + if (_param && parseInt(_param.mediaId) > 0) {
  199 + releaseChannelId = parseInt(_param.mediaId);
168 } 200 }
169 201
170 //释放channelId 的占用 202 //释放channelId 的占用
171 - if(releaseChannelId>0){ 203 + if (releaseChannelId > 0) {
172 //第一种情况，释放nodeId占用的指定mediaId (channelId) 204 //第一种情况，释放nodeId占用的指定mediaId (channelId)
173 - this._releaseChannelForNodeId(nodeId,releaseChannelId);  
174 - }else { 205 + this._releaseChannelForNodeId(nodeId, releaseChannelId);
  206 + } else {
175 //第二种情况，释放nodeId占用的所有channelId 207 //第二种情况，释放nodeId占用的所有channelId
176 this._releaseNodeIdAllChannel(nodeId); 208 this._releaseNodeIdAllChannel(nodeId);
177 } 209 }
178 } 210 }
179 211
180 //释放nodeId占用的指定的channelId频道 212 //释放nodeId占用的指定的channelId频道
181 - _releaseChannelForNodeId(nodeId,channelId){  
182 - loger.log(nodeId,"释放占用的频道-->",channelId);  
183 - let channelInfo=this.mediaModule.mediaChannels[channelId];  
184 - if(channelInfo&&channelInfo.status==ApeConsts.CHANNEL_STATUS_OPENING){  
185 - if(channelInfo.fromNodeId==nodeId){ 213 + _releaseChannelForNodeId(nodeId, channelId) {
  214 + loger.log(nodeId, "释放占用的频道-->", channelId);
  215 + let channelInfo = this.mediaModule.mediaChannels[channelId];
  216 + if (channelInfo && channelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
  217 + if (channelInfo.fromNodeId == nodeId) {
186 218
187 - let channelInfo=this.mediaModule.getDefaultChannelInfo();  
188 - channelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED;  
189 - channelInfo.channelId=channelId; 219 + let channelInfo = this.mediaModule.getDefaultChannelInfo();
  220 + channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
  221 + channelInfo.channelId = channelId;
190 222
191 this.sendTableUpdateHandler(channelInfo); 223 this.sendTableUpdateHandler(channelInfo);
192 - }else {  
193 - loger.warn(channelId,"不属于nodeId",nodeId,"不能释放",channelInfo); 224 + } else {
  225 + loger.warn(channelId, "不属于nodeId", nodeId, "不能释放", channelInfo);
194 } 226 }
195 - }else {  
196 - loger.warn(nodeId,"要释放的频道不存在或者已经释放-->channelId",channelInfo); 227 + } else {
  228 + loger.warn(nodeId, "要释放的频道不存在或者已经释放-->channelId", channelInfo);
197 } 229 }
198 } 230 }
  231 +
199 //释放nodeId占用的所有频道 232 //释放nodeId占用的所有频道
200 - _releaseNodeIdAllChannel(nodeId){  
201 - loger.log(nodeId,"_releaseNodeIdAllChannel",this.mcu.connected);  
202 - if(!this.mcu.connected){ 233 + _releaseNodeIdAllChannel(nodeId) {
  234 + loger.log(nodeId, "_releaseNodeIdAllChannel", this.mcu.connected);
  235 + if (!this.mcu.connected) {
203 clearTimeout(this.releaseTimeId); 236 clearTimeout(this.releaseTimeId);
204 loger.warn(GlobalConfig.getCurrentStatus()); 237 loger.warn(GlobalConfig.getCurrentStatus());
205 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 238 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
@@ -207,28 +240,29 @@ class AudioApe extends Ape { @@ -207,28 +240,29 @@ class AudioApe extends Ape {
207 240
208 let openingChannelInfo = this.mediaModule.getOpeningMediaChannelForNodeId(nodeId); 241 let openingChannelInfo = this.mediaModule.getOpeningMediaChannelForNodeId(nodeId);
209 if (openingChannelInfo.channelId == 0) { 242 if (openingChannelInfo.channelId == 0) {
210 - loger.warn(nodeId,"没有占用频道不需要处理"); 243 + loger.warn(nodeId, "没有占用频道不需要处理");
211 return {"code": ApeConsts.RETURN_FAILED, "data": "没有占用channel不需要处理"}; 244 return {"code": ApeConsts.RETURN_FAILED, "data": "没有占用channel不需要处理"};
212 } 245 }
213 246
214 - let channelInfo=this.mediaModule.getDefaultChannelInfo();  
215 - channelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED;  
216 - channelInfo.channelId=openingChannelInfo.channelId;  
217 - channelInfo.nodeId=openingChannelInfo.fromNodeId;  
218 - channelInfo.userRole=openingChannelInfo.userRole;  
219 - channelInfo.userName=openingChannelInfo.userName;  
220 - channelInfo.userId=openingChannelInfo.userId; 247 + let channelInfo = this.mediaModule.getDefaultChannelInfo();
  248 + channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
  249 + channelInfo.channelId = openingChannelInfo.channelId;
  250 + channelInfo.nodeId = openingChannelInfo.fromNodeId;
  251 + channelInfo.userRole = openingChannelInfo.userRole;
  252 + channelInfo.userName = openingChannelInfo.userName;
  253 + channelInfo.userId = openingChannelInfo.userId;
221 254
222 this.sendTableUpdateHandler(channelInfo); 255 this.sendTableUpdateHandler(channelInfo);
223 //递归检查,800毫秒之后执行 256 //递归检查,800毫秒之后执行
224 - this.releaseTimeId=setTimeout(function(){  
225 - loger.warn(nodeId,"检查频道是否占用"); 257 + this.releaseTimeId = setTimeout(function () {
  258 + loger.warn(nodeId, "检查频道是否占用");
226 this._releaseNodeIdAllChannel(nodeId); 259 this._releaseNodeIdAllChannel(nodeId);
227 - }.bind(this),800); 260 + }.bind(this), 800);
228 } 261 }
  262 +
229 sendAudioBroadcastMsg(_param) { 263 sendAudioBroadcastMsg(_param) {
230 264
231 - if(!this.mcu.connected){ 265 + if (!this.mcu.connected) {
232 loger.warn(GlobalConfig.getCurrentStatus()); 266 loger.warn(GlobalConfig.getCurrentStatus());
233 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 267 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
234 } 268 }
@@ -246,13 +280,13 @@ class AudioApe extends Ape { @@ -246,13 +280,13 @@ class AudioApe extends Ape {
246 return {"code": ApeConsts.RETURN_FAILED, "data": "sendAudioBroadcastMsg,参数错误"}; 280 return {"code": ApeConsts.RETURN_FAILED, "data": "sendAudioBroadcastMsg,参数错误"};
247 } 281 }
248 // to, message 282 // to, message
249 - loger.log('音频模块广播->',_param); 283 + loger.log('音频模块广播->', _param);
250 if (_param.actionType != null && _param.actionType == ApeConsts.MEDIA_ACTION_OPEN_CAMERA) { 284 if (_param.actionType != null && _param.actionType == ApeConsts.MEDIA_ACTION_OPEN_CAMERA) {
251 //判断当前开启的视频数量是否已经是最大值,如果已经是最大值，不能再开启 285 //判断当前开启的视频数量是否已经是最大值,如果已经是最大值，不能再开启
252 let freeChannel = this.mediaModule.getFreeMediaChannel(); 286 let freeChannel = this.mediaModule.getFreeMediaChannel();
253 if (freeChannel == 0) { 287 if (freeChannel == 0) {
254 loger.warn('不能再打开更多的设备', _param); 288 loger.warn('不能再打开更多的设备', _param);
255 - return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备","mediaChannels":this.mediaModule.mediaChannels}; 289 + return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备", "mediaChannels": this.mediaModule.mediaChannels};
256 } 290 }
257 } 291 }
258 292
@@ -265,15 +299,15 @@ class AudioApe extends Ape { @@ -265,15 +299,15 @@ class AudioApe extends Ape {
265 audioSendPdu.toNodeId = parseInt(_param.toNodeId) || 0;//接收者，0就是所有人 299 audioSendPdu.toNodeId = parseInt(_param.toNodeId) || 0;//接收者，0就是所有人
266 audioSendPdu.actionType = parseInt(_param.actionType) || ApeConsts.MEDIA_ACTION_DEFAULT; 300 audioSendPdu.actionType = parseInt(_param.actionType) || ApeConsts.MEDIA_ACTION_DEFAULT;
267 301
268 - let dataStr='';  
269 - try{  
270 - dataStr=JSON.stringify(_param.data);  
271 - }catch (err){ 302 + let dataStr = '';
  303 + try {
  304 + dataStr = JSON.stringify(_param.data);
  305 + } catch (err) {
272 loger.warn('控制消息->JSON转换失败'); 306 loger.warn('控制消息->JSON转换失败');
273 - dataStr=_param.data; 307 + dataStr = _param.data;
274 } 308 }
275 309
276 - audioSendPdu.data = this._rCArrayBufferUtil.strToUint8Array("h5" +dataStr);//开头两个字会乱码,需要加上h5两个字符 310 + audioSendPdu.data = this._rCArrayBufferUtil.strToUint8Array("h5" + dataStr);//开头两个字会乱码,需要加上h5两个字符
277 311
278 if (!audioSendPdu.isPublic && 0 != audioSendPdu.toNodeId) { 312 if (!audioSendPdu.isPublic && 0 != audioSendPdu.toNodeId) {
279 //发送给制定的人 313 //发送给制定的人
@@ -290,8 +324,8 @@ class AudioApe extends Ape { @@ -290,8 +324,8 @@ class AudioApe extends Ape {
290 sendTableUpdateHandler(_channelInfo) { 324 sendTableUpdateHandler(_channelInfo) {
291 //loger.log("audio,sendTableUpdateHandler "); 325 //loger.log("audio,sendTableUpdateHandler ");
292 let updateModelPdu = this.packPdu(_channelInfo, _channelInfo.channelId); 326 let updateModelPdu = this.packPdu(_channelInfo, _channelInfo.channelId);
293 - if(updateModelPdu==null){  
294 - loger.warn("音频模块更新数据-> 失败->数据无效",_channelInfo); 327 + if (updateModelPdu == null) {
  328 + loger.warn("音频模块更新数据-> 失败->数据无效", _channelInfo);
295 return; 329 return;
296 } 330 }
297 331
@@ -334,113 +368,116 @@ class AudioApe extends Ape { @@ -334,113 +368,116 @@ class AudioApe extends Ape {
334 } 368 }
335 audioReceivePdu.data = this._rCArrayBufferUtil.uint8ArrayToStr(audioReceivePdu.data, 2);//开头两个字会乱码 369 audioReceivePdu.data = this._rCArrayBufferUtil.uint8ArrayToStr(audioReceivePdu.data, 2);//开头两个字会乱码
336 370
337 - let dataObj= {};  
338 - try{  
339 - dataObj=JSON.parse(audioReceivePdu.data);  
340 - }catch (err){ 371 + let dataObj = {};
  372 + try {
  373 + dataObj = JSON.parse(audioReceivePdu.data);
  374 + } catch (err) {
341 loger.warn('控制消息->JSON转换失败'); 375 loger.warn('控制消息->JSON转换失败');
342 - dataObj= audioReceivePdu.data; 376 + dataObj = audioReceivePdu.data;
343 } 377 }
344 - audioReceivePdu.data=dataObj; 378 + audioReceivePdu.data = dataObj;
345 //判断接收者的id,如果不是0，并且也不是自己的nodeId，那么消息不做处理 379 //判断接收者的id,如果不是0，并且也不是自己的nodeId，那么消息不做处理
346 if (audioReceivePdu.toNodeId != 0 && audioReceivePdu.toNodeId != GlobalConfig.nodeId) { 380 if (audioReceivePdu.toNodeId != 0 && audioReceivePdu.toNodeId != GlobalConfig.nodeId) {
347 loger.log('音频消息不处理 toNodeId=', audioReceivePdu.toNodeId, "my nodeId=", GlobalConfig.nodeId); 381 loger.log('音频消息不处理 toNodeId=', audioReceivePdu.toNodeId, "my nodeId=", GlobalConfig.nodeId);
348 } else { 382 } else {
349 - loger.log('音频控制消息处理 .',audioReceivePdu); 383 + loger.log('音频控制消息处理 .', audioReceivePdu);
350 this._emit(MessageTypes.AUDIO_BROADCAST, audioReceivePdu); 384 this._emit(MessageTypes.AUDIO_BROADCAST, audioReceivePdu);
351 } 385 }
352 } 386 }
353 387
354 - tableUpdateHandler(owner, itemIdx, itemData,seek) { 388 + tableUpdateHandler(owner, itemIdx, itemData, seek) {
355 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData); 389 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData);
356 - loger.log("tableUpdateHandler->channel",itemIdx,'status->',unpackChannelInfo.status,"seek->",seek); 390 + loger.log("tableUpdateHandler->channel", itemIdx, 'status->', unpackChannelInfo.status, "seek->", seek);
357 //****很重要******** 391 //****很重要********
358 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0) 392 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0)
359 - if(owner==0){  
360 - loger.log("释放占用的频道,channel",itemIdx);  
361 - unpackChannelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED;  
362 - unpackChannelInfo.streamId=""; 393 + if (owner == 0) {
  394 + loger.log("释放占用的频道,channel", itemIdx);
  395 + unpackChannelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
  396 + unpackChannelInfo.streamId = "";
363 } 397 }
364 398
365 this.mediaModule.mediaChannels[itemIdx] = unpackChannelInfo; 399 this.mediaModule.mediaChannels[itemIdx] = unpackChannelInfo;
366 400
367 - if(unpackChannelInfo&&unpackChannelInfo.fromNodeId!=GlobalConfig.nodeId){  
368 - let receiveChannelInfo={};  
369 - receiveChannelInfo.mediaId=unpackChannelInfo.channelId;  
370 - receiveChannelInfo.fromNodeId=unpackChannelInfo.fromNodeId;  
371 - receiveChannelInfo.userName=unpackChannelInfo.userName||"";  
372 - receiveChannelInfo.userRole=unpackChannelInfo.userRole||ApeConsts.normal;  
373 - receiveChannelInfo.mediaType=unpackChannelInfo.mediaType||ApeConsts.MEDIA_TYPE_DEFAULT;  
374 - receiveChannelInfo.screenWidth=unpackChannelInfo.screenWidth||GlobalConfig.screenWidth;  
375 - receiveChannelInfo.screenHeight=unpackChannelInfo.screenHeight||GlobalConfig.screenHeight;  
376 - receiveChannelInfo.deviceType=unpackChannelInfo.deviceType||0;  
377 - receiveChannelInfo.optionJsonData=unpackChannelInfo.optionJsonData||""; 401 + if (unpackChannelInfo && unpackChannelInfo.fromNodeId != GlobalConfig.nodeId) {
  402 + let receiveChannelInfo = {};
  403 + receiveChannelInfo.mediaId = unpackChannelInfo.channelId;
  404 + receiveChannelInfo.fromNodeId = unpackChannelInfo.fromNodeId;
  405 + receiveChannelInfo.userName = unpackChannelInfo.userName || "";
  406 + receiveChannelInfo.userRole = unpackChannelInfo.userRole || ApeConsts.normal;
  407 + receiveChannelInfo.mediaType = unpackChannelInfo.mediaType || ApeConsts.MEDIA_TYPE_DEFAULT;
  408 + receiveChannelInfo.screenWidth = unpackChannelInfo.screenWidth || GlobalConfig.screenWidth;
  409 + receiveChannelInfo.screenHeight = unpackChannelInfo.screenHeight || GlobalConfig.screenHeight;
  410 + receiveChannelInfo.deviceType = unpackChannelInfo.deviceType || 0;
  411 + receiveChannelInfo.optionJsonData = unpackChannelInfo.optionJsonData || "";
378 412
379 //消息不是自己同步的，需要处理 413 //消息不是自己同步的，需要处理
380 - if(unpackChannelInfo.status==ApeConsts.CHANNEL_STATUS_OPENING){ 414 + if (unpackChannelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
381 //正在推流 415 //正在推流
382 - receiveChannelInfo.m3u8Url="";  
383 - receiveChannelInfo.rtmpUrl="";  
384 - receiveChannelInfo.replay=""; 416 + receiveChannelInfo.m3u8Url = "";
  417 + receiveChannelInfo.rtmpUrl = "";
  418 + receiveChannelInfo.replay = "";
385 419
386 - receiveChannelInfo.seek=seek||0;//这个是录制回放时使用的seek 420 + receiveChannelInfo.seek = seek || 0;//这个是录制回放时使用的seek
387 421
388 - let m3u8Stream=this.mediaModule.getMediaPlayPath({"type":"m3u8","streamId": unpackChannelInfo.streamId});  
389 - let rtmpStream=this.mediaModule.getMediaPlayPath({"type":"rtmp","streamId": unpackChannelInfo.streamId});  
390 - let replay=this.mediaModule.getMediaRecordPlaybackPath({"type":"m3u8","streamId": unpackChannelInfo.streamId}); 422 + let m3u8Stream = this.mediaModule.getMediaPlayPath({"type": "m3u8", "streamId": unpackChannelInfo.streamId});
  423 + let rtmpStream = this.mediaModule.getMediaPlayPath({"type": "rtmp", "streamId": unpackChannelInfo.streamId});
  424 + let replay = this.mediaModule.getMediaRecordPlaybackPath({
  425 + "type": "m3u8",
  426 + "streamId": unpackChannelInfo.streamId
  427 + });
391 428
392 - if(m3u8Stream.code==0){  
393 - receiveChannelInfo.m3u8Url=m3u8Stream.playUrl; 429 + if (m3u8Stream.code == 0) {
  430 + receiveChannelInfo.m3u8Url = m3u8Stream.playUrl;
394 } 431 }
395 - if(rtmpStream.code==0){  
396 - receiveChannelInfo.rtmpUrl=rtmpStream.playUrl; 432 + if (rtmpStream.code == 0) {
  433 + receiveChannelInfo.rtmpUrl = rtmpStream.playUrl;
397 } 434 }
398 - if(replay.code==0){  
399 - receiveChannelInfo.replay=replay.playUrl; 435 + if (replay.code == 0) {
  436 + receiveChannelInfo.replay = replay.playUrl;
400 } 437 }
401 - loger.log("AUDIO_PLAY->",receiveChannelInfo); 438 + loger.log("AUDIO_PLAY->", receiveChannelInfo);
402 //广播播放视频的消息 439 //广播播放视频的消息
403 this._emit(MessageTypes.AUDIO_PLAY, receiveChannelInfo); 440 this._emit(MessageTypes.AUDIO_PLAY, receiveChannelInfo);
404 - }else {  
405 - loger.log("AUDIO_STOP->",receiveChannelInfo); 441 + } else {
  442 + loger.log("AUDIO_STOP->", receiveChannelInfo);
406 //流已经停止 443 //流已经停止
407 this._emit(MessageTypes.AUDIO_STOP, receiveChannelInfo); 444 this._emit(MessageTypes.AUDIO_STOP, receiveChannelInfo);
408 } 445 }
409 - }else { 446 + } else {
410 loger.warn("消息是自己发送的或者是消息无效，不需要处理，消息内容如下："); 447 loger.warn("消息是自己发送的或者是消息无效，不需要处理，消息内容如下：");
411 loger.log(unpackChannelInfo); 448 loger.log(unpackChannelInfo);
412 - if(unpackChannelInfo.status==ApeConsts.CHANNEL_STATUS_OPENING){  
413 - GlobalConfig.openMicrophones=EngineUtils.creatTimestamp();  
414 - GlobalConfig.openCamera=0;  
415 - }else {  
416 - GlobalConfig.openCamera=0;  
417 - GlobalConfig.openMicrophones=0;  
418 - }  
419 - this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE,{  
420 - nodeId:GlobalConfig.nodeId,  
421 - userRole:GlobalConfig.userRole,  
422 - userName:GlobalConfig.userName,  
423 - userId:GlobalConfig.userId,  
424 - openCamera:GlobalConfig.openCamera,  
425 - openMicrophones:GlobalConfig.openMicrophones 449 + if (unpackChannelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
  450 + GlobalConfig.openMicrophones = EngineUtils.creatTimestamp();
  451 + GlobalConfig.openCamera = 0;
  452 + } else {
  453 + GlobalConfig.openCamera = 0;
  454 + GlobalConfig.openMicrophones = 0;
  455 + }
  456 + this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE, {
  457 + nodeId: GlobalConfig.nodeId,
  458 + userRole: GlobalConfig.userRole,
  459 + userName: GlobalConfig.userName,
  460 + userId: GlobalConfig.userId,
  461 + openCamera: GlobalConfig.openCamera,
  462 + openMicrophones: GlobalConfig.openMicrophones
426 }); 463 });
427 } 464 }
428 465
429 - MediaModule.allMediaChannelsList[itemIdx]=unpackChannelInfo;  
430 - console.log('MediaModule.allMediaChannelsList',MediaModule.allMediaChannelsList); 466 + MediaModule.allMediaChannelsList[itemIdx] = unpackChannelInfo;
  467 + console.log('MediaModule.allMediaChannelsList', MediaModule.allMediaChannelsList);
431 this._emit(MessageTypes.AUDIO_UPDATE, unpackChannelInfo); 468 this._emit(MessageTypes.AUDIO_UPDATE, unpackChannelInfo);
432 } 469 }
433 470
434 //更新媒体文件模块的录制信息，每次开启录制的时候需要把当前媒体文件的信息更新一次 471 //更新媒体文件模块的录制信息，每次开启录制的时候需要把当前媒体文件的信息更新一次
435 - updaterRecordApeStatus(_param){  
436 - console.warn("录制状态发送改变->更新当前的状态->",this.mediaModule.mediaChannels);  
437 - for (let i in this.mediaModule.mediaChannels){  
438 - let channelInfo=this.mediaModule.mediaChannels[i];  
439 - if(channelInfo){  
440 - if(channelInfo.status==ApeConsts.CHANNEL_STATUS_RELEASED){  
441 - channelInfo.owner=0;  
442 - }else {  
443 - channelInfo.owner=channelInfo.fromNodeId; 472 + updaterRecordApeStatus(_param) {
  473 + console.warn("录制状态发送改变->更新当前的状态->", this.mediaModule.mediaChannels);
  474 + for (let i in this.mediaModule.mediaChannels) {
  475 + let channelInfo = this.mediaModule.mediaChannels[i];
  476 + if (channelInfo) {
  477 + if (channelInfo.status == ApeConsts.CHANNEL_STATUS_RELEASED) {
  478 + channelInfo.owner = 0;
  479 + } else {
  480 + channelInfo.owner = channelInfo.fromNodeId;
444 } 481 }
445 this.sendTableUpdateHandler(channelInfo); 482 this.sendTableUpdateHandler(channelInfo);
446 } 483 }
@@ -458,23 +495,23 @@ class AudioApe extends Ape { @@ -458,23 +495,23 @@ class AudioApe extends Ape {
458 495
459 //判断type类型，根据type设置不同的参数 496 //判断type类型，根据type设置不同的参数
460 let packPduModel = new pdu['RCAudioChannelInfoPdu']; 497 let packPduModel = new pdu['RCAudioChannelInfoPdu'];
461 - packPduModel.status = _param.status||ApeConsts.CHANNEL_STATUS_RELEASED; 498 + packPduModel.status = _param.status || ApeConsts.CHANNEL_STATUS_RELEASED;
462 packPduModel.channelId = _itemIdx; 499 packPduModel.channelId = _itemIdx;
463 - packPduModel.streamId = _param.streamId||"";  
464 - packPduModel.siteId=_param.siteId||GlobalConfig.siteId;//GlobalConfig.siteId;  
465 - packPduModel.classId =parseInt(_param.classId)||parseInt(GlobalConfig.classId);  
466 - packPduModel.userId =_param.userId||"0";  
467 - packPduModel.mediaType =_param.mediaType|| ApeConsts.MEDIA_TYPE_AUDIO;  
468 - packPduModel.timestamp =_param.timestamp||EngineUtils.creatTimestamp();  
469 - packPduModel.fromNodeId =_param.nodeId|| GlobalConfig.nodeId;  
470 - packPduModel.userName=_param.userName||GlobalConfig.userName||""; 500 + packPduModel.streamId = _param.streamId || "";
  501 + packPduModel.siteId = _param.siteId || GlobalConfig.siteId;//GlobalConfig.siteId;
  502 + packPduModel.classId = parseInt(_param.classId) || parseInt(GlobalConfig.classId);
  503 + packPduModel.userId = _param.userId || "0";
  504 + packPduModel.mediaType = _param.mediaType || ApeConsts.MEDIA_TYPE_AUDIO;
  505 + packPduModel.timestamp = _param.timestamp || EngineUtils.creatTimestamp();
  506 + packPduModel.fromNodeId = _param.nodeId || GlobalConfig.nodeId;
  507 + packPduModel.userName = _param.userName || GlobalConfig.userName || "";
471 packPduModel.toNodeId = 0; 508 packPduModel.toNodeId = 0;
472 - packPduModel.userRole=_param.userRole||GlobalConfig.userRole;  
473 - packPduModel.screenWidth=_param.screenWidth||GlobalConfig.screenWidth;  
474 - packPduModel.screenHeight=_param.screenHeight||GlobalConfig.screenHeight;  
475 - packPduModel.deviceType=_param.deviceType||GlobalConfig.deviceType;  
476 - packPduModel.optionJsonData=_param.optionJsonData||GlobalConfig.optionJsonData;  
477 - loger.log("packPdu->",packPduModel); 509 + packPduModel.userRole = _param.userRole || GlobalConfig.userRole;
  510 + packPduModel.screenWidth = _param.screenWidth || GlobalConfig.screenWidth;
  511 + packPduModel.screenHeight = _param.screenHeight || GlobalConfig.screenHeight;
  512 + packPduModel.deviceType = _param.deviceType || GlobalConfig.deviceType;
  513 + packPduModel.optionJsonData = GlobalConfig.optionJsonData;
  514 + loger.log("packPdu->", packPduModel);
478 return packPduModel; 515 return packPduModel;
479 } 516 }
480 517
@@ -485,7 +522,7 @@ class AudioApe extends Ape { @@ -485,7 +522,7 @@ class AudioApe extends Ape {
485 } 522 }
486 try { 523 try {
487 let packChannelInfo = pdu['RCAudioChannelInfoPdu'].decode(itemData); 524 let packChannelInfo = pdu['RCAudioChannelInfoPdu'].decode(itemData);
488 - loger.log("unPackPdu->",packChannelInfo); 525 + loger.log("unPackPdu->", packChannelInfo);
489 return packChannelInfo; 526 return packChannelInfo;
490 } catch (err) { 527 } catch (err) {
491 loger.log("unPackPdu error->itemIdx=" + itemIdx + " err:" + err.message); 528 loger.log("unPackPdu error->itemIdx=" + itemIdx + " err:" + err.message);
@@ -21,18 +21,18 @@ class VideoApe extends Ape { @@ -21,18 +21,18 @@ class VideoApe extends Ape {
21 ApeConsts.VIDEO_SESSION_TAG 21 ApeConsts.VIDEO_SESSION_TAG
22 ); 22 );
23 23
24 - this.mediaModule=new MediaModule();  
25 - this.mediaModule.MEDIA_OBJ_TABLE_ID=ApeConsts.VIDEO_OBJ_TABLE_ID;  
26 - this.mediaModule.mediaChannels={};  
27 - this.mediaModule.mediaType=ApeConsts.MEDIA_TYPE_VIDEO;  
28 - this.shareApe=new ShareApe();  
29 - this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_SUCCESS,this.onPublishScreenShareSuccess.bind(this));  
30 - this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_FAILE,this.onPublishScreenShareFaile.bind(this));  
31 - this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_CLOSE,this.onPublishScreenShareClose.bind(this));  
32 - this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_DISCONNECT,this.onPublishScreenShareDisconnect.bind(this));  
33 - this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_CONNECTED,this.onPublishScreenShareConnected.bind(this));  
34 - this.shareApe.on( MessageTypes.PUBLISH_SCREEN_MOVIE_INFO_CHANGE,this.onPublishScreenMovieInfoChange.bind(this));  
35 - this.shareApe.on(MessageTypes.PUBLISH_SCREEN_VIDEO_INFO_CHANGE,this.onPublishScreenVideoInfoChange.bind(this)); 24 + this.mediaModule = new MediaModule();
  25 + this.mediaModule.MEDIA_OBJ_TABLE_ID = ApeConsts.VIDEO_OBJ_TABLE_ID;
  26 + this.mediaModule.mediaChannels = {};
  27 + this.mediaModule.mediaType = ApeConsts.MEDIA_TYPE_VIDEO;
  28 + this.shareApe = new ShareApe();
  29 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_SUCCESS, this.onPublishScreenShareSuccess.bind(this));
  30 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_FAILE, this.onPublishScreenShareFaile.bind(this));
  31 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_CLOSE, this.onPublishScreenShareClose.bind(this));
  32 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_DISCONNECT, this.onPublishScreenShareDisconnect.bind(this));
  33 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_SHARE_CONNECTED, this.onPublishScreenShareConnected.bind(this));
  34 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_MOVIE_INFO_CHANGE, this.onPublishScreenMovieInfoChange.bind(this));
  35 + this.shareApe.on(MessageTypes.PUBLISH_SCREEN_VIDEO_INFO_CHANGE, this.onPublishScreenVideoInfoChange.bind(this));
36 36
37 // Ape Models 37 // Ape Models
38 this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer); 38 this.registerKey(this._session_id, this._session_name, this._session_tag, new ArrayBuffer);
@@ -41,10 +41,11 @@ class VideoApe extends Ape { @@ -41,10 +41,11 @@ class VideoApe extends Ape {
41 // videoApe 监听视频控制消息，用户之间的消息传递 41 // videoApe 监听视频控制消息，用户之间的消息传递
42 this.on(pdu.RCPDU_SEND_VIDEO_DATA_REQUEST, this.receiveVideoCommandHandler.bind(this)); 42 this.on(pdu.RCPDU_SEND_VIDEO_DATA_REQUEST, this.receiveVideoCommandHandler.bind(this));
43 } 43 }
  44 +
44 //ape加入成功 45 //ape加入成功
45 - onJoinChannelHandlerSuccess(){ 46 + onJoinChannelHandlerSuccess() {
46 //这个设置很重要，因为只有Sass流程完成之后，APE才能取得GlobalConfig中的数据 47 //这个设置很重要，因为只有Sass流程完成之后，APE才能取得GlobalConfig中的数据
47 - this.mediaModule.maxMediaChannel=GlobalConfig.maxVideoChannels; 48 + this.mediaModule.maxMediaChannel = GlobalConfig.maxVideoChannels;
48 } 49 }
49 50
50 /////////////发送数据操作//////////////////////////////////////////// 51 /////////////发送数据操作////////////////////////////////////////////
@@ -57,66 +58,76 @@ class VideoApe extends Ape { @@ -57,66 +58,76 @@ class VideoApe extends Ape {
57 //获取推流地址 58 //获取推流地址
58 getPublishVideoPath(_param) { 59 getPublishVideoPath(_param) {
59 loger.log('获取推流地址->'); 60 loger.log('获取推流地址->');
60 - if(!this.mcu.connected){ 61 + if (!this.mcu.connected) {
61 loger.warn(GlobalConfig.getCurrentStatus()); 62 loger.warn(GlobalConfig.getCurrentStatus());
62 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 63 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
63 } 64 }
64 //监课比较特殊，不占用课堂内的音视频路数，额外创建 65 //监课比较特殊，不占用课堂内的音视频路数，额外创建
65 - if(GlobalConfig.userRole==ApeConsts.invisible){  
66 - let result=this.mediaModule.getMediaPublishPathForInVisible(_param);  
67 - this._emit( MessageTypes.VIDEO_GET_PUBLISH_PATH,result); 66 + if (GlobalConfig.userRole == ApeConsts.invisible) {
  67 + let result = this.mediaModule.getMediaPublishPathForInVisible(_param);
  68 + this._emit(MessageTypes.VIDEO_GET_PUBLISH_PATH, result);
68 return result; 69 return result;
69 } 70 }
70 71
71 //非监课的身份，需要判断是否可以继续推流 72 //非监课的身份，需要判断是否可以继续推流
72 //需要判断当前已经使用的流路数 73 //需要判断当前已经使用的流路数
73 - let openChannel=0;  
74 - let allChannels= MediaModule.allMediaChannelsList;  
75 - for(let i in allChannels){  
76 - let channel=allChannels[i];  
77 - if(channel&&channel.status==ApeConsts.CHANNEL_STATUS_OPENING&&channel.userRole!=ApeConsts.invisible){ 74 + let openChannel = 0;
  75 + let allChannels = MediaModule.allMediaChannelsList;
  76 + for (let i in allChannels) {
  77 + let channel = allChannels[i];
  78 + if (channel && channel.status == ApeConsts.CHANNEL_STATUS_OPENING && channel.userRole != ApeConsts.invisible) {
78 //正在开启的才计数，监课开启的不计算在内 79 //正在开启的才计数，监课开启的不计算在内
79 openChannel++; 80 openChannel++;
80 } 81 }
81 } 82 }
82 //如果已经开启的数量大于等于最大允许开启的数量，不允许再推流 83 //如果已经开启的数量大于等于最大允许开启的数量，不允许再推流
83 - if(openChannel>=GlobalConfig.maxMediaChannels){  
84 - loger.warn('不能再打开设备->当前开启的设备数量->',openChannel); 84 + if (openChannel >= GlobalConfig.maxMediaChannels) {
  85 + loger.warn('不能再打开设备->当前开启的设备数量->', openChannel);
85 return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开设备,当前开启的设备数量"}; 86 return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开设备,当前开启的设备数量"};
86 } 87 }
87 88
88 - let result=this.mediaModule.getMediaPublishPath(_param);  
89 - this._emit( MessageTypes.VIDEO_GET_PUBLISH_PATH,result); 89 + let result = this.mediaModule.getMediaPublishPath(_param);
  90 + this._emit(MessageTypes.VIDEO_GET_PUBLISH_PATH, result);
90 return result; 91 return result;
91 } 92 }
92 93
93 //获取当前所有频道信息 94 //获取当前所有频道信息
94 - getAllChannelInfo(_param){ 95 + getAllChannelInfo(_param) {
95 loger.log('获取当前所有频道信息->'); 96 loger.log('获取当前所有频道信息->');
96 return this.mediaModule.getAllMediaChannelInfo(); 97 return this.mediaModule.getAllMediaChannelInfo();
97 } 98 }
98 99
99 //推流 100 //推流
100 publishVideo(_param) { 101 publishVideo(_param) {
101 - if(!this.mcu.connected){ 102 + if (!this.mcu.connected) {
102 loger.warn(GlobalConfig.getCurrentStatus()); 103 loger.warn(GlobalConfig.getCurrentStatus());
103 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"已经断开连接!","mediaId":0}); 104 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接!", "mediaId": 0});
104 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 105 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
105 } 106 }
106 107
107 - if (_param == null||_param.publishUrl == null)  
108 - { 108 + if (_param == null || _param.publishUrl == null) {
109 loger.warn('推流->参数错误', _param); 109 loger.warn('推流->参数错误', _param);
110 this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG); 110 this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
111 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"参数错误!","mediaId":0}); 111 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "参数错误!", "mediaId": 0});
112 return {"code": ApeConsts.RETURN_FAILED, "data": "参数错误"}; 112 return {"code": ApeConsts.RETURN_FAILED, "data": "参数错误"};
113 } 113 }
114 114
  115 + //获取可选参数,转换为JSON字符串
  116 + try {
  117 + GlobalConfig.optionJsonData = JSON.stringify(_param.optionJsonData)||""
  118 + } catch (err) {
  119 + GlobalConfig.optionJsonData = "";
  120 + }
  121 +
115 //根据推流的地址获取对应的频道信息 122 //根据推流的地址获取对应的频道信息
116 - let needPublishChannelInfo=this.mediaModule.getNeedPublishMediaChannel(_param.publishUrl);  
117 - if(needPublishChannelInfo==null){ 123 + let needPublishChannelInfo = this.mediaModule.getNeedPublishMediaChannel(_param.publishUrl);
  124 + if (needPublishChannelInfo == null) {
118 loger.warn('推流->推流数据已经无效', _param); 125 loger.warn('推流->推流数据已经无效', _param);
119 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"推流数据已经无效!","mediaId":0}); 126 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
  127 + "code": ApeConsts.RETURN_FAILED,
  128 + "data": "推流数据已经无效!",
  129 + "mediaId": 0
  130 + });
120 return {"code": ApeConsts.RETURN_FAILED, "data": "推流数据已经无效"}; 131 return {"code": ApeConsts.RETURN_FAILED, "data": "推流数据已经无效"};
121 } 132 }
122 133
@@ -124,62 +135,82 @@ class VideoApe extends Ape { @@ -124,62 +135,82 @@ class VideoApe extends Ape {
124 let freeChannel = this.mediaModule.getFreeMediaChannel(); 135 let freeChannel = this.mediaModule.getFreeMediaChannel();
125 if (freeChannel == 0) { 136 if (freeChannel == 0) {
126 loger.warn("推流->不能再打开更多的设备 "); 137 loger.warn("推流->不能再打开更多的设备 ");
127 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"不能再打开更多的设备!","mediaId":0});  
128 - return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备","mediaChannels":this.mediaModule.mediaChannels}; 138 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
  139 + "code": ApeConsts.RETURN_FAILED,
  140 + "data": "不能再打开更多的设备!",
  141 + "mediaId": 0
  142 + });
  143 + return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备", "mediaChannels": this.mediaModule.mediaChannels};
129 } 144 }
130 145
131 146
132 //判断当前的频道是否已经占用 147 //判断当前的频道是否已经占用
133 - if(this.mediaModule.checkChannelIsOpening(needPublishChannelInfo.channelId)){  
134 - if(needPublishChannelInfo.nodeId==GlobalConfig.nodeId){  
135 - loger.warn(needPublishChannelInfo.channelId,"已经推送过消息，不需要再次推送");  
136 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_SUCCESS, "data":"已经推送过消息，不需要再次推送!","mediaId":needPublishChannelInfo.channelId});  
137 - return {"code": ApeConsts.RETURN_SUCCESS, "data":"已经推送过消息，不需要再次推送!","mediaId":needPublishChannelInfo.channelId};  
138 - }else {  
139 - loger.warn(needPublishChannelInfo.channelId,"频道已经被占用");  
140 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"频道已经被占用!","mediaId":0});  
141 - return {"code": ApeConsts.RETURN_FAILED, "data":"频道已经被占用!","mediaChannels":this.mediaModule.mediaChannels};  
142 - }  
143 - }  
144 -  
145 - let channelInfo=this.mediaModule.getDefaultChannelInfo();  
146 - channelInfo.owner=GlobalConfig.nodeId;  
147 - channelInfo.status=ApeConsts.CHANNEL_STATUS_OPENING;  
148 - channelInfo.channelId=needPublishChannelInfo.channelId;  
149 - channelInfo.streamId=needPublishChannelInfo.streamId;//按规则拼接的流名称  
150 - channelInfo.timestamp=needPublishChannelInfo.timestamp;//时间戳  
151 - channelInfo.mediaType=ApeConsts.MEDIA_TYPE_VIDEO; 148 + if (this.mediaModule.checkChannelIsOpening(needPublishChannelInfo.channelId)) {
  149 + if (needPublishChannelInfo.nodeId == GlobalConfig.nodeId) {
  150 + loger.warn(needPublishChannelInfo.channelId, "已经推送过消息，不需要再次推送");
  151 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
  152 + "code": ApeConsts.RETURN_SUCCESS,
  153 + "data": "已经推送过消息，不需要再次推送!",
  154 + "mediaId": needPublishChannelInfo.channelId
  155 + });
  156 + return {
  157 + "code": ApeConsts.RETURN_SUCCESS,
  158 + "data": "已经推送过消息，不需要再次推送!",
  159 + "mediaId": needPublishChannelInfo.channelId
  160 + };
  161 + } else {
  162 + loger.warn(needPublishChannelInfo.channelId, "频道已经被占用");
  163 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
  164 + "code": ApeConsts.RETURN_FAILED,
  165 + "data": "频道已经被占用!",
  166 + "mediaId": 0
  167 + });
  168 + return {"code": ApeConsts.RETURN_FAILED, "data": "频道已经被占用!", "mediaChannels": this.mediaModule.mediaChannels};
  169 + }
  170 + }
  171 +
  172 + let channelInfo = this.mediaModule.getDefaultChannelInfo();
  173 + channelInfo.owner = GlobalConfig.nodeId;
  174 + channelInfo.status = ApeConsts.CHANNEL_STATUS_OPENING;
  175 + channelInfo.channelId = needPublishChannelInfo.channelId;
  176 + channelInfo.streamId = needPublishChannelInfo.streamId;//按规则拼接的流名称
  177 + channelInfo.timestamp = needPublishChannelInfo.timestamp;//时间戳
  178 + channelInfo.mediaType = ApeConsts.MEDIA_TYPE_VIDEO;
152 this.sendTableUpdateHandler(channelInfo); 179 this.sendTableUpdateHandler(channelInfo);
153 180
154 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_SUCCESS, "data":"推流成功!","mediaId":needPublishChannelInfo.channelId});  
155 - return {"code": ApeConsts.RETURN_SUCCESS, "data":"推流成功!","mediaId":needPublishChannelInfo.channelId}; 181 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {
  182 + "code": ApeConsts.RETURN_SUCCESS,
  183 + "data": "推流成功!",
  184 + "mediaId": needPublishChannelInfo.channelId
  185 + });
  186 + return {"code": ApeConsts.RETURN_SUCCESS, "data": "推流成功!", "mediaId": needPublishChannelInfo.channelId};
156 } 187 }
157 188
158 //停止推流， 189 //停止推流，
159 stopPublishVideo(_param) { 190 stopPublishVideo(_param) {
160 - loger.log('停止推流->',_param);  
161 - if(!this.mcu.connected){ 191 + loger.log('停止推流->', _param);
  192 + if (!this.mcu.connected) {
162 loger.warn(GlobalConfig.getCurrentStatus()); 193 loger.warn(GlobalConfig.getCurrentStatus());
163 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 194 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
164 } 195 }
165 196
166 //默认为自己的nodeId，_param如果为空，那么默认就是当前自己的nodeId，否则用_param 197 //默认为自己的nodeId，_param如果为空，那么默认就是当前自己的nodeId，否则用_param
167 - let nodeId=GlobalConfig.nodeId;  
168 - if(_param&&parseInt(_param.nodeId)>0){  
169 - nodeId=parseInt(_param.nodeId); 198 + let nodeId = GlobalConfig.nodeId;
  199 + if (_param && parseInt(_param.nodeId) > 0) {
  200 + nodeId = parseInt(_param.nodeId);
170 } 201 }
171 202
172 //默认为0,如果releaseChannelId 存在就释放releaseChannelId通道 203 //默认为0,如果releaseChannelId 存在就释放releaseChannelId通道
173 - let releaseChannelId=0;  
174 - if(_param&&parseInt(_param.mediaId)>0){  
175 - releaseChannelId=parseInt(_param.mediaId); 204 + let releaseChannelId = 0;
  205 + if (_param && parseInt(_param.mediaId) > 0) {
  206 + releaseChannelId = parseInt(_param.mediaId);
176 } 207 }
177 208
178 //释放channelId 的占用 209 //释放channelId 的占用
179 - if(releaseChannelId>0){ 210 + if (releaseChannelId > 0) {
180 //第一种情况，释放nodeId占用的指定mediaId (channelId) 211 //第一种情况，释放nodeId占用的指定mediaId (channelId)
181 - this._releaseChannelForNodeId(nodeId,releaseChannelId);  
182 - }else { 212 + this._releaseChannelForNodeId(nodeId, releaseChannelId);
  213 + } else {
183 //第二种情况，释放nodeId占用的所有channelId 214 //第二种情况，释放nodeId占用的所有channelId
184 this._releaseNodeIdAllChannel(nodeId); 215 this._releaseNodeIdAllChannel(nodeId);
185 } 216 }
@@ -188,74 +219,85 @@ class VideoApe extends Ape { @@ -188,74 +219,85 @@ class VideoApe extends Ape {
188 //==========================屏幕共享========================================================================= 219 //==========================屏幕共享=========================================================================
189 220
190 //屏幕共享连接打开 221 //屏幕共享连接打开
191 - onPublishScreenShareFaile(){ 222 + onPublishScreenShareFaile() {
192 loger.log('屏幕共享推流失败->'); 223 loger.log('屏幕共享推流失败->');
193 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_FAILE); 224 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_FAILE);
194 } 225 }
  226 +
195 //屏幕共享连接关闭 227 //屏幕共享连接关闭
196 - onPublishScreenShareClose(){ 228 + onPublishScreenShareClose() {
197 loger.log('屏幕共享推流关闭->'); 229 loger.log('屏幕共享推流关闭->');
198 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_CLOSE); 230 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_CLOSE);
199 } 231 }
  232 +
200 //屏幕共享连接失败 233 //屏幕共享连接失败
201 - onPublishScreenShareDisconnect(){ 234 + onPublishScreenShareDisconnect() {
202 loger.log('屏幕共享服务器连接失败->'); 235 loger.log('屏幕共享服务器连接失败->');
203 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_DISCONNECT); 236 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_DISCONNECT);
204 } 237 }
  238 +
205 //屏幕共享连接失败 239 //屏幕共享连接失败
206 - onPublishScreenShareConnected(){ 240 + onPublishScreenShareConnected() {
207 loger.log('屏幕共享服务器连接成功->'); 241 loger.log('屏幕共享服务器连接成功->');
208 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_CONNECTED); 242 this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_CONNECTED);
209 } 243 }
210 - onPublishScreenMovieInfoChange(data){ 244 +
  245 + onPublishScreenMovieInfoChange(data) {
211 loger.log('屏幕共享MOVIE信息发生改变->'); 246 loger.log('屏幕共享MOVIE信息发生改变->');
212 - this._emit(MessageTypes.PUBLISH_SCREEN_MOVIE_INFO_CHANGE,data); 247 + this._emit(MessageTypes.PUBLISH_SCREEN_MOVIE_INFO_CHANGE, data);
213 } 248 }
214 - onPublishScreenVideoInfoChange(data){ 249 +
  250 + onPublishScreenVideoInfoChange(data) {
215 loger.log('屏幕共享视频信息发生改变->'); 251 loger.log('屏幕共享视频信息发生改变->');
216 - this._emit(MessageTypes.PUBLISH_SCREEN_VIDEO_INFO_CHANGE,data); 252 + this._emit(MessageTypes.PUBLISH_SCREEN_VIDEO_INFO_CHANGE, data);
217 } 253 }
  254 +
218 //监听屏幕共享发布成功 255 //监听屏幕共享发布成功
219 - onPublishScreenShareSuccess(){ 256 + onPublishScreenShareSuccess() {
220 loger.log('屏幕共享推流成功之后才能更新同步消息->'); 257 loger.log('屏幕共享推流成功之后才能更新同步消息->');
221 //屏幕共享推流成功之后才能更新同步消息 258 //屏幕共享推流成功之后才能更新同步消息
222 - let channelInfo=this.shareApe.getPublishChannelInfo(); 259 + let channelInfo = this.shareApe.getPublishChannelInfo();
223 this.sendTableUpdateHandler(channelInfo); 260 this.sendTableUpdateHandler(channelInfo);
224 - this._emit( MessageTypes.PUBLISH_SCREEN_SHARE_SUCCESS,{"code": ApeConsts.RETURN_SUCCESS, "data":"桌面共享推流!","mediaId":channelInfo.channelId});  
225 - return {"code": ApeConsts.RETURN_SUCCESS, "data":"桌面共享推流!","mediaId":channelInfo.channelId}; 261 + this._emit(MessageTypes.PUBLISH_SCREEN_SHARE_SUCCESS, {
  262 + "code": ApeConsts.RETURN_SUCCESS,
  263 + "data": "桌面共享推流!",
  264 + "mediaId": channelInfo.channelId
  265 + });
  266 + return {"code": ApeConsts.RETURN_SUCCESS, "data": "桌面共享推流!", "mediaId": channelInfo.channelId};
226 } 267 }
  268 +
227 //桌面共享推流 269 //桌面共享推流
228 publishScreenShare(_param) { 270 publishScreenShare(_param) {
229 - if(!this.mcu.connected){ 271 + if (!this.mcu.connected) {
230 loger.warn(GlobalConfig.getCurrentStatus()); 272 loger.warn(GlobalConfig.getCurrentStatus());
231 - this._emit( MessageTypes.VIDEO_PUBLISH_RESULT,{"code": ApeConsts.RETURN_FAILED, "data":"已经断开连接!","mediaId":0}); 273 + this._emit(MessageTypes.VIDEO_PUBLISH_RESULT, {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接!", "mediaId": 0});
232 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 274 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
233 } 275 }
234 - let publishType='flash';  
235 - if(_param&&_param.type=='live'){  
236 - publishType='live'; 276 + let publishType = 'flash';
  277 + if (_param && _param.type == 'live') {
  278 + publishType = 'live';
237 } 279 }
238 //老师能开启屏幕共享 280 //老师能开启屏幕共享
239 - if(GlobalConfig.isHost) { 281 + if (GlobalConfig.isHost) {
240 //获取屏幕共享推流的地址 282 //获取屏幕共享推流的地址
241 let shareResult = this.mediaModule.getMediaPublishPathForScreenShare(this.shareApe.channelId, publishType); 283 let shareResult = this.mediaModule.getMediaPublishPathForScreenShare(this.shareApe.channelId, publishType);
242 - shareResult.ip=_param.ip||"";//外部可以设置屏幕共享的IP  
243 - shareResult.port=_param.port||"";//外部可以设置屏幕共享的端口 284 + shareResult.ip = _param.ip || "";//外部可以设置屏幕共享的IP
  285 + shareResult.port = _param.port || "";//外部可以设置屏幕共享的端口
244 this.shareApe.publish(shareResult); 286 this.shareApe.publish(shareResult);
245 } 287 }
246 } 288 }
247 289
248 //停止桌面共享推流 290 //停止桌面共享推流
249 stopPublishScreenShare(_param) { 291 stopPublishScreenShare(_param) {
250 - loger.log('停止桌面共享推流->',_param);  
251 - if(!this.mcu.connected){ 292 + loger.log('停止桌面共享推流->', _param);
  293 + if (!this.mcu.connected) {
252 loger.warn(GlobalConfig.getCurrentStatus()); 294 loger.warn(GlobalConfig.getCurrentStatus());
253 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 295 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
254 } 296 }
255 //只有老师能停止屏幕共享 297 //只有老师能停止屏幕共享
256 - if(GlobalConfig.isHost){  
257 - let channelInfo=this.shareApe.getDefaultChannelInfo();  
258 - channelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED; 298 + if (GlobalConfig.isHost) {
  299 + let channelInfo = this.shareApe.getDefaultChannelInfo();
  300 + channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
259 this.sendTableUpdateHandler(channelInfo); 301 this.sendTableUpdateHandler(channelInfo);
260 302
261 this.shareApe.stopPublish(); 303 this.shareApe.stopPublish();
@@ -266,56 +308,57 @@ class VideoApe extends Ape { @@ -266,56 +308,57 @@ class VideoApe extends Ape {
266 //=============================屏幕共享 end================================================= 308 //=============================屏幕共享 end=================================================
267 309
268 //释放nodeId占用的指定的channelId频道 310 //释放nodeId占用的指定的channelId频道
269 - _releaseChannelForNodeId(nodeId,channelId){  
270 - loger.log(nodeId,"_releaseChannelForNodeId-->channelId",channelId);  
271 - let channelInfo=this.mediaModule.mediaChannels[channelId];  
272 - if(channelInfo&&channelInfo.status==ApeConsts.CHANNEL_STATUS_OPENING){  
273 - if(channelInfo.fromNodeId==nodeId){ 311 + _releaseChannelForNodeId(nodeId, channelId) {
  312 + loger.log(nodeId, "_releaseChannelForNodeId-->channelId", channelId);
  313 + let channelInfo = this.mediaModule.mediaChannels[channelId];
  314 + if (channelInfo && channelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
  315 + if (channelInfo.fromNodeId == nodeId) {
274 316
275 - let channelInfo=this.mediaModule.getDefaultChannelInfo();  
276 - channelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED;  
277 - channelInfo.channelId=channelId; 317 + let channelInfo = this.mediaModule.getDefaultChannelInfo();
  318 + channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
  319 + channelInfo.channelId = channelId;
278 320
279 this.sendTableUpdateHandler(channelInfo); 321 this.sendTableUpdateHandler(channelInfo);
280 - }else {  
281 - loger.warn(channelId,"不属于nodeId",nodeId,"不能释放",channelInfo); 322 + } else {
  323 + loger.warn(channelId, "不属于nodeId", nodeId, "不能释放", channelInfo);
282 } 324 }
283 - }else {  
284 - loger.warn(nodeId,"要释放的channel不存在或者已经释放-->channelId",channelInfo); 325 + } else {
  326 + loger.warn(nodeId, "要释放的channel不存在或者已经释放-->channelId", channelInfo);
285 } 327 }
286 } 328 }
  329 +
287 //释放nodeId占用的所有频道 330 //释放nodeId占用的所有频道
288 - _releaseNodeIdAllChannel(nodeId){  
289 - if(!this.mcu.connected){ 331 + _releaseNodeIdAllChannel(nodeId) {
  332 + if (!this.mcu.connected) {
290 clearTimeout(this.releaseTimeId); 333 clearTimeout(this.releaseTimeId);
291 loger.warn(GlobalConfig.getCurrentStatus()); 334 loger.warn(GlobalConfig.getCurrentStatus());
292 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 335 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
293 } 336 }
294 - loger.log("释放nodeId占用的所有频道->",nodeId); 337 + loger.log("释放nodeId占用的所有频道->", nodeId);
295 let openingChannelInfo = this.mediaModule.getOpeningMediaChannelForNodeId(nodeId); 338 let openingChannelInfo = this.mediaModule.getOpeningMediaChannelForNodeId(nodeId);
296 - if (openingChannelInfo.channelId== 0) {  
297 - loger.warn(nodeId,"没有占用channel不需要处理"); 339 + if (openingChannelInfo.channelId == 0) {
  340 + loger.warn(nodeId, "没有占用channel不需要处理");
298 return {"code": ApeConsts.RETURN_FAILED, "data": "没有占用channel不需要处理"}; 341 return {"code": ApeConsts.RETURN_FAILED, "data": "没有占用channel不需要处理"};
299 } 342 }
300 343
301 - let channelInfo=this.mediaModule.getDefaultChannelInfo();  
302 - channelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED;  
303 - channelInfo.channelId=openingChannelInfo.channelId;  
304 - channelInfo.nodeId=openingChannelInfo.fromNodeId;//发送消息的人员nodeId  
305 - channelInfo.userRole=openingChannelInfo.userRole;  
306 - channelInfo.userName=openingChannelInfo.userName;  
307 - channelInfo.userId=openingChannelInfo.userId; 344 + let channelInfo = this.mediaModule.getDefaultChannelInfo();
  345 + channelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
  346 + channelInfo.channelId = openingChannelInfo.channelId;
  347 + channelInfo.nodeId = openingChannelInfo.fromNodeId;//发送消息的人员nodeId
  348 + channelInfo.userRole = openingChannelInfo.userRole;
  349 + channelInfo.userName = openingChannelInfo.userName;
  350 + channelInfo.userId = openingChannelInfo.userId;
308 351
309 this.sendTableUpdateHandler(channelInfo); 352 this.sendTableUpdateHandler(channelInfo);
310 //递归检查,800毫秒之后执行 353 //递归检查,800毫秒之后执行
311 - this.releaseTimeId=setTimeout(function(){  
312 - loger.warn(nodeId,"检查频道是否占用"); 354 + this.releaseTimeId = setTimeout(function () {
  355 + loger.warn(nodeId, "检查频道是否占用");
313 this._releaseNodeIdAllChannel(nodeId); 356 this._releaseNodeIdAllChannel(nodeId);
314 - }.bind(this),800); 357 + }.bind(this), 800);
315 } 358 }
316 359
317 sendVideoBroadcastMsg(_param) { 360 sendVideoBroadcastMsg(_param) {
318 - if(!this.mcu.connected){ 361 + if (!this.mcu.connected) {
319 loger.warn(GlobalConfig.getCurrentStatus()); 362 loger.warn(GlobalConfig.getCurrentStatus());
320 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"}; 363 return {"code": ApeConsts.RETURN_FAILED, "data": "已经断开连接"};
321 } 364 }
@@ -341,7 +384,7 @@ class VideoApe extends Ape { @@ -341,7 +384,7 @@ class VideoApe extends Ape {
341 let freeChannel = this.mediaModule.getFreeMediaChannel(); 384 let freeChannel = this.mediaModule.getFreeMediaChannel();
342 if (freeChannel == 0) { 385 if (freeChannel == 0) {
343 loger.warn('视频模块广播消息->不能再打开更多的设备', _param); 386 loger.warn('视频模块广播消息->不能再打开更多的设备', _param);
344 - return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备","mediaChannels":this.mediaModule.mediaChannels}; 387 + return {"code": ApeConsts.RETURN_FAILED, "data": "不能再打开更多的设备", "mediaChannels": this.mediaModule.mediaChannels};
345 } 388 }
346 } 389 }
347 390
@@ -353,12 +396,12 @@ class VideoApe extends Ape { @@ -353,12 +396,12 @@ class VideoApe extends Ape {
353 videoSendPdu.toNodeId = parseInt(_param.toNodeId) || 0;//接收者，0就是所有人 396 videoSendPdu.toNodeId = parseInt(_param.toNodeId) || 0;//接收者，0就是所有人
354 videoSendPdu.actionType = parseInt(_param.actionType) || ApeConsts.MEDIA_ACTION_DEFAULT; 397 videoSendPdu.actionType = parseInt(_param.actionType) || ApeConsts.MEDIA_ACTION_DEFAULT;
355 398
356 - let dataStr='';  
357 - try{  
358 - dataStr=JSON.stringify(_param.data);  
359 - }catch (err){ 399 + let dataStr = '';
  400 + try {
  401 + dataStr = JSON.stringify(_param.data);
  402 + } catch (err) {
360 loger.warn('控制消息->JSON转换失败'); 403 loger.warn('控制消息->JSON转换失败');
361 - dataStr=_param.data; 404 + dataStr = _param.data;
362 } 405 }
363 videoSendPdu.data = this._rCArrayBufferUtil.strToUint8Array("h5" + dataStr);//开头两个字会乱码 406 videoSendPdu.data = this._rCArrayBufferUtil.strToUint8Array("h5" + dataStr);//开头两个字会乱码
364 407
@@ -371,12 +414,13 @@ class VideoApe extends Ape { @@ -371,12 +414,13 @@ class VideoApe extends Ape {
371 } 414 }
372 return {"code": ApeConsts.RETURN_SUCCESS, "data": ""}; 415 return {"code": ApeConsts.RETURN_SUCCESS, "data": ""};
373 } 416 }
  417 +
374 //发送到mcu同步（更新数据） 418 //发送到mcu同步（更新数据）
375 sendTableUpdateHandler(_channelInfo) { 419 sendTableUpdateHandler(_channelInfo) {
376 //loger.log("video===sendTableUpdateHandler "); 420 //loger.log("video===sendTableUpdateHandler ");
377 let updateModelPdu = this.packPdu(_channelInfo, _channelInfo.channelId);//let updateModelPdu=this.packPdu({},ApeConsts.VIDEO_OBJ_TABLE_ID+2); 421 let updateModelPdu = this.packPdu(_channelInfo, _channelInfo.channelId);//let updateModelPdu=this.packPdu({},ApeConsts.VIDEO_OBJ_TABLE_ID+2);
378 422
379 - if(updateModelPdu==null){ 423 + if (updateModelPdu == null) {
380 loger.warn("sendTableUpdateHandler error,updateModelPdu=null"); 424 loger.warn("sendTableUpdateHandler error,updateModelPdu=null");
381 return; 425 return;
382 } 426 }
@@ -420,115 +464,117 @@ class VideoApe extends Ape { @@ -420,115 +464,117 @@ class VideoApe extends Ape {
420 } 464 }
421 videoReceivePdu.data = this._rCArrayBufferUtil.uint8ArrayToStr(videoReceivePdu.data, 2);//开头两个字会乱码 465 videoReceivePdu.data = this._rCArrayBufferUtil.uint8ArrayToStr(videoReceivePdu.data, 2);//开头两个字会乱码
422 466
423 - let dataObj= {};  
424 - try{  
425 - dataObj=JSON.parse(videoReceivePdu.data);  
426 - }catch (err){ 467 + let dataObj = {};
  468 + try {
  469 + dataObj = JSON.parse(videoReceivePdu.data);
  470 + } catch (err) {
427 loger.warn('控制消息->JSON转换失败'); 471 loger.warn('控制消息->JSON转换失败');
428 - dataObj= videoReceivePdu.data; 472 + dataObj = videoReceivePdu.data;
429 } 473 }
430 - videoReceivePdu.data=dataObj; 474 + videoReceivePdu.data = dataObj;
431 //判断接收者的id,如果不是0，并且也不是自己的nodeId，那么消息不做处理 475 //判断接收者的id,如果不是0，并且也不是自己的nodeId，那么消息不做处理
432 if (videoReceivePdu.toNodeId != 0 && videoReceivePdu.toNodeId != GlobalConfig.nodeId) { 476 if (videoReceivePdu.toNodeId != 0 && videoReceivePdu.toNodeId != GlobalConfig.nodeId) {
433 loger.log('视频消息不处理 toNodeId=', videoReceivePdu.toNodeId, "my nodeId=", GlobalConfig.nodeId); 477 loger.log('视频消息不处理 toNodeId=', videoReceivePdu.toNodeId, "my nodeId=", GlobalConfig.nodeId);
434 } else { 478 } else {
435 - loger.log('视频控制消息处理 .',videoReceivePdu); 479 + loger.log('视频控制消息处理 .', videoReceivePdu);
436 this._emit(MessageTypes.VIDEO_BROADCAST, videoReceivePdu); 480 this._emit(MessageTypes.VIDEO_BROADCAST, videoReceivePdu);
437 } 481 }
438 } 482 }
439 483
440 484
441 -  
442 - tableUpdateHandler(owner, itemIdx, itemData,seek) { 485 + tableUpdateHandler(owner, itemIdx, itemData, seek) {
443 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData); 486 let unpackChannelInfo = this.unPackPdu(owner, itemIdx, itemData);
444 - loger.log("tableUpdateHandler->channel",itemIdx,'mediaType',unpackChannelInfo.mediaType,'status->',unpackChannelInfo.status,"seek->",seek); 487 + loger.log("tableUpdateHandler->channel", itemIdx, 'mediaType', unpackChannelInfo.mediaType, 'status->', unpackChannelInfo.status, "seek->", seek);
445 488
446 //****很重要******** 489 //****很重要********
447 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0) 490 //如果owner的值为0，代表的是这个歌频道已经被释放了(mcu服务端对于占用channel的掉线用户，就是把owner设置为0)
448 - if(owner==0){  
449 - loger.log("释放占用的频道,channel",itemIdx);  
450 - unpackChannelInfo.status=ApeConsts.CHANNEL_STATUS_RELEASED;  
451 - unpackChannelInfo.streamId=""; 491 + if (owner == 0) {
  492 + loger.log("释放占用的频道,channel", itemIdx);
  493 + unpackChannelInfo.status = ApeConsts.CHANNEL_STATUS_RELEASED;
  494 + unpackChannelInfo.streamId = "";
452 } 495 }
453 //屏幕共享的流不保存 496 //屏幕共享的流不保存
454 - if(unpackChannelInfo.mediaType!=ApeConsts.MEDIA_TYPE_SHARE&&unpackChannelInfo.channelId>0){ 497 + if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE && unpackChannelInfo.channelId > 0) {
455 this.mediaModule.mediaChannels[itemIdx] = unpackChannelInfo; 498 this.mediaModule.mediaChannels[itemIdx] = unpackChannelInfo;
456 } 499 }
457 500
458 - if(unpackChannelInfo&&unpackChannelInfo.fromNodeId!=GlobalConfig.nodeId){  
459 - let receiveChannelInfo={};  
460 - receiveChannelInfo.mediaId=unpackChannelInfo.channelId;  
461 - receiveChannelInfo.fromNodeId=unpackChannelInfo.fromNodeId;  
462 - receiveChannelInfo.userName=unpackChannelInfo.userName||"";  
463 - receiveChannelInfo.userRole=unpackChannelInfo.userRole||ApeConsts.normal;  
464 - receiveChannelInfo.mediaType=unpackChannelInfo.mediaType||ApeConsts.MEDIA_TYPE_DEFAULT;  
465 - receiveChannelInfo.screenWidth=unpackChannelInfo.screenWidth||GlobalConfig.screenWidth;  
466 - receiveChannelInfo.screenHeight=unpackChannelInfo.screenHeight||GlobalConfig.screenHeight;  
467 - receiveChannelInfo.deviceType=unpackChannelInfo.deviceType||0;  
468 - receiveChannelInfo.optionJsonData=unpackChannelInfo.optionJsonData||""; 501 + if (unpackChannelInfo && unpackChannelInfo.fromNodeId != GlobalConfig.nodeId) {
  502 + let receiveChannelInfo = {};
  503 + receiveChannelInfo.mediaId = unpackChannelInfo.channelId;
  504 + receiveChannelInfo.fromNodeId = unpackChannelInfo.fromNodeId;
  505 + receiveChannelInfo.userName = unpackChannelInfo.userName || "";
  506 + receiveChannelInfo.userRole = unpackChannelInfo.userRole || ApeConsts.normal;
  507 + receiveChannelInfo.mediaType = unpackChannelInfo.mediaType || ApeConsts.MEDIA_TYPE_DEFAULT;
  508 + receiveChannelInfo.screenWidth = unpackChannelInfo.screenWidth || GlobalConfig.screenWidth;
  509 + receiveChannelInfo.screenHeight = unpackChannelInfo.screenHeight || GlobalConfig.screenHeight;
  510 + receiveChannelInfo.deviceType = unpackChannelInfo.deviceType || 0;
  511 + receiveChannelInfo.optionJsonData = unpackChannelInfo.optionJsonData || "";
469 //消息不是自己同步的，需要处理 512 //消息不是自己同步的，需要处理
470 - if(unpackChannelInfo.status==ApeConsts.CHANNEL_STATUS_OPENING){ 513 + if (unpackChannelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
471 //正在推流 514 //正在推流
472 - receiveChannelInfo.m3u8Url="";  
473 - receiveChannelInfo.rtmpUrl="";  
474 - receiveChannelInfo.replay=""; 515 + receiveChannelInfo.m3u8Url = "";
  516 + receiveChannelInfo.rtmpUrl = "";
  517 + receiveChannelInfo.replay = "";
475 518
476 - receiveChannelInfo.seek=seek||0;//这个是录制回放时使用的seek 519 + receiveChannelInfo.seek = seek || 0;//这个是录制回放时使用的seek
477 520
478 - let m3u8Stream=this.mediaModule.getMediaPlayPath({"type":"m3u8","streamId": unpackChannelInfo.streamId});  
479 - let rtmpStream=this.mediaModule.getMediaPlayPath({"type":"rtmp","streamId": unpackChannelInfo.streamId});  
480 - let replay=this.mediaModule.getMediaRecordPlaybackPath({"type":"m3u8","streamId": unpackChannelInfo.streamId}); 521 + let m3u8Stream = this.mediaModule.getMediaPlayPath({"type": "m3u8", "streamId": unpackChannelInfo.streamId});
  522 + let rtmpStream = this.mediaModule.getMediaPlayPath({"type": "rtmp", "streamId": unpackChannelInfo.streamId});
  523 + let replay = this.mediaModule.getMediaRecordPlaybackPath({
  524 + "type": "m3u8",
  525 + "streamId": unpackChannelInfo.streamId
  526 + });
481 527
482 - if(m3u8Stream.code==0){  
483 - receiveChannelInfo.m3u8Url=m3u8Stream.playUrl; 528 + if (m3u8Stream.code == 0) {
  529 + receiveChannelInfo.m3u8Url = m3u8Stream.playUrl;
484 } 530 }
485 - if(rtmpStream.code==0){  
486 - receiveChannelInfo.rtmpUrl=rtmpStream.playUrl; 531 + if (rtmpStream.code == 0) {
  532 + receiveChannelInfo.rtmpUrl = rtmpStream.playUrl;
487 } 533 }
488 - if(replay.code==0){  
489 - receiveChannelInfo.replay=replay.playUrl; 534 + if (replay.code == 0) {
  535 + receiveChannelInfo.replay = replay.playUrl;
490 } 536 }
491 537
492 - if(unpackChannelInfo.mediaType!=ApeConsts.MEDIA_TYPE_SHARE){ 538 + if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE) {
493 //广播播放视频的消息 539 //广播播放视频的消息
494 - loger.log("VIDEO_PLAY",receiveChannelInfo); 540 + loger.log("VIDEO_PLAY", receiveChannelInfo);
495 this._emit(MessageTypes.VIDEO_PLAY, receiveChannelInfo); 541 this._emit(MessageTypes.VIDEO_PLAY, receiveChannelInfo);
496 - }else{ 542 + } else {
497 //播放屏幕共享 543 //播放屏幕共享
498 - loger.log("SCREEN_SHARE_PLAY",receiveChannelInfo); 544 + loger.log("SCREEN_SHARE_PLAY", receiveChannelInfo);
499 this._emit(MessageTypes.SCREEN_SHARE_PLAY, receiveChannelInfo); 545 this._emit(MessageTypes.SCREEN_SHARE_PLAY, receiveChannelInfo);
500 546
501 } 547 }
502 - }else {  
503 - if(unpackChannelInfo.mediaType!=ApeConsts.MEDIA_TYPE_SHARE){ 548 + } else {
  549 + if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE) {
504 //停止播放视频 550 //停止播放视频
505 - loger.log("VIDEO_STOP",receiveChannelInfo); 551 + loger.log("VIDEO_STOP", receiveChannelInfo);
506 this._emit(MessageTypes.VIDEO_STOP, receiveChannelInfo); 552 this._emit(MessageTypes.VIDEO_STOP, receiveChannelInfo);
507 - }else{ 553 + } else {
508 //停止播放屏幕共享 554 //停止播放屏幕共享
509 - if(unpackChannelInfo.channelId!=0){ 555 + if (unpackChannelInfo.channelId != 0) {
510 loger.log("SCREEN_SHARE_STOP", receiveChannelInfo); 556 loger.log("SCREEN_SHARE_STOP", receiveChannelInfo);
511 this._emit(MessageTypes.SCREEN_SHARE_STOP, receiveChannelInfo); 557 this._emit(MessageTypes.SCREEN_SHARE_STOP, receiveChannelInfo);
512 - }else { 558 + } else {
513 559
514 loger.log("停止播放视频->channelId=0->不合法的id", receiveChannelInfo); 560 loger.log("停止播放视频->channelId=0->不合法的id", receiveChannelInfo);
515 } 561 }
516 } 562 }
517 563
518 } 564 }
519 - }else { 565 + } else {
520 loger.warn("视频消息是自己发送的或者是视频消息无效，不需要处理，消息内容如下："); 566 loger.warn("视频消息是自己发送的或者是视频消息无效，不需要处理，消息内容如下：");
521 loger.log(unpackChannelInfo); 567 loger.log(unpackChannelInfo);
522 - if(unpackChannelInfo.status==ApeConsts.CHANNEL_STATUS_OPENING){  
523 - GlobalConfig.openCamera=EngineUtils.creatTimestamp();  
524 - GlobalConfig.openMicrophones=GlobalConfig.openCamera;  
525 - }else {  
526 - GlobalConfig.openCamera=0;  
527 - GlobalConfig.openMicrophones=0; 568 + if (unpackChannelInfo.status == ApeConsts.CHANNEL_STATUS_OPENING) {
  569 + GlobalConfig.openCamera = EngineUtils.creatTimestamp();
  570 + GlobalConfig.openMicrophones = GlobalConfig.openCamera;
  571 + } else {
  572 + GlobalConfig.openCamera = 0;
  573 + GlobalConfig.openMicrophones = 0;
528 } 574 }
529 575
530 //更新用户的摄像头和麦克风状态 576 //更新用户的摄像头和麦克风状态
531 - if(unpackChannelInfo.mediaType!=ApeConsts.MEDIA_TYPE_SHARE) { 577 + if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE) {
532 //非屏幕共享的情况下才更新状态 578 //非屏幕共享的情况下才更新状态
533 this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE, { 579 this._emit(MessageTypes.USER_DEVICE_STATUS_CHAANGE, {
534 nodeId: GlobalConfig.nodeId, 580 nodeId: GlobalConfig.nodeId,
@@ -542,24 +588,25 @@ class VideoApe extends Ape { @@ -542,24 +588,25 @@ class VideoApe extends Ape {
542 } 588 }
543 589
544 590
545 - if(unpackChannelInfo.mediaType!=ApeConsts.MEDIA_TYPE_SHARE){ 591 + if (unpackChannelInfo.mediaType != ApeConsts.MEDIA_TYPE_SHARE) {
546 //非屏幕共享情况的处理 592 //非屏幕共享情况的处理
547 - MediaModule.allMediaChannelsList[itemIdx]=unpackChannelInfo;  
548 - console.log('MediaModule.allMediaChannelsList',MediaModule.allMediaChannelsList); 593 + MediaModule.allMediaChannelsList[itemIdx] = unpackChannelInfo;
  594 + console.log('MediaModule.allMediaChannelsList', MediaModule.allMediaChannelsList);
549 this._emit(MessageTypes.VIDEO_UPDATE, unpackChannelInfo); 595 this._emit(MessageTypes.VIDEO_UPDATE, unpackChannelInfo);
550 } 596 }
551 597
552 } 598 }
  599 +
553 //更新媒体文件模块的录制信息，每次开启录制的时候需要把当前媒体文件的信息更新一次 600 //更新媒体文件模块的录制信息，每次开启录制的时候需要把当前媒体文件的信息更新一次
554 - updaterRecordApeStatus(_param){  
555 - console.warn("录制状态发送改变->更新当前的状态->",this.mediaModule.mediaChannels);  
556 - for (let i in this.mediaModule.mediaChannels){  
557 - let channelInfo=this.mediaModule.mediaChannels[i];  
558 - if(channelInfo){  
559 - if(channelInfo.status==ApeConsts.CHANNEL_STATUS_RELEASED){  
560 - channelInfo.owner=0;  
561 - }else {  
562 - channelInfo.owner=channelInfo.fromNodeId; 601 + updaterRecordApeStatus(_param) {
  602 + console.warn("录制状态发送改变->更新当前的状态->", this.mediaModule.mediaChannels);
  603 + for (let i in this.mediaModule.mediaChannels) {
  604 + let channelInfo = this.mediaModule.mediaChannels[i];
  605 + if (channelInfo) {
  606 + if (channelInfo.status == ApeConsts.CHANNEL_STATUS_RELEASED) {
  607 + channelInfo.owner = 0;
  608 + } else {
  609 + channelInfo.owner = channelInfo.fromNodeId;
563 } 610 }
564 this.sendTableUpdateHandler(channelInfo); 611 this.sendTableUpdateHandler(channelInfo);
565 } 612 }
@@ -567,9 +614,9 @@ class VideoApe extends Ape { @@ -567,9 +614,9 @@ class VideoApe extends Ape {
567 } 614 }
568 615
569 //清除当前模块的数据 616 //清除当前模块的数据
570 - clearData(){ 617 + clearData() {
571 loger.log("clearData->"); 618 loger.log("clearData->");
572 - MediaModule.allMediaChannelsList={}; 619 + MediaModule.allMediaChannelsList = {};
573 } 620 }
574 621
575 ///////数据的封包和解包///////////////////////////////////////// 622 ///////数据的封包和解包/////////////////////////////////////////
@@ -582,28 +629,28 @@ class VideoApe extends Ape { @@ -582,28 +629,28 @@ class VideoApe extends Ape {
582 629
583 //判断type类型，根据type设置不同的参数 630 //判断type类型，根据type设置不同的参数
584 let packPduModel = new pdu['RCVideoChannelInfoPdu']; 631 let packPduModel = new pdu['RCVideoChannelInfoPdu'];
585 - packPduModel.status = _param.status||ApeConsts.CHANNEL_STATUS_RELEASED; 632 + packPduModel.status = _param.status || ApeConsts.CHANNEL_STATUS_RELEASED;
586 packPduModel.channelId = _itemIdx; 633 packPduModel.channelId = _itemIdx;
587 - packPduModel.streamId = _param.streamId||"";  
588 - packPduModel.siteId=_param.siteId||GlobalConfig.siteId;//GlobalConfig.siteId;  
589 - packPduModel.classId =parseInt(_param.classId)||parseInt(GlobalConfig.classId);  
590 - packPduModel.userId =_param.userId||"0";  
591 - packPduModel.mediaType =_param.mediaType|| ApeConsts.MEDIA_TYPE_VIDEO;  
592 - packPduModel.timestamp =_param.timestamp||0;  
593 - packPduModel.fromNodeId = _param.nodeId||GlobalConfig.nodeId;  
594 - packPduModel.userName=_param.userName||GlobalConfig.userName; 634 + packPduModel.streamId = _param.streamId || "";
  635 + packPduModel.siteId = _param.siteId || GlobalConfig.siteId;//GlobalConfig.siteId;
  636 + packPduModel.classId = parseInt(_param.classId) || parseInt(GlobalConfig.classId);
  637 + packPduModel.userId = _param.userId || "0";
  638 + packPduModel.mediaType = _param.mediaType || ApeConsts.MEDIA_TYPE_VIDEO;
  639 + packPduModel.timestamp = _param.timestamp || 0;
  640 + packPduModel.fromNodeId = _param.nodeId || GlobalConfig.nodeId;
  641 + packPduModel.userName = _param.userName || GlobalConfig.userName;
595 packPduModel.toNodeId = 0; 642 packPduModel.toNodeId = 0;
596 - packPduModel.userRole=_param.userRole||GlobalConfig.userRole;  
597 - packPduModel.screenWidth=_param.screenWidth||GlobalConfig.screenWidth;  
598 - packPduModel.screenHeight=_param.screenHeight||GlobalConfig.screenHeight;  
599 - packPduModel.deviceType=_param.deviceType||GlobalConfig.deviceType;  
600 - packPduModel.optionJsonData=_param.optionJsonData||GlobalConfig.optionJsonData;  
601 - loger.log('packPdu->',packPduModel); 643 + packPduModel.userRole = _param.userRole || GlobalConfig.userRole;
  644 + packPduModel.screenWidth = _param.screenWidth || GlobalConfig.screenWidth;
  645 + packPduModel.screenHeight = _param.screenHeight || GlobalConfig.screenHeight;
  646 + packPduModel.deviceType = _param.deviceType || GlobalConfig.deviceType;
  647 + packPduModel.optionJsonData = GlobalConfig.optionJsonData;
  648 + loger.log('packPdu->', packPduModel);
602 return packPduModel; 649 return packPduModel;
603 } 650 }
604 651
605 unPackPdu(owner, itemIdx, itemData) { 652 unPackPdu(owner, itemIdx, itemData) {
606 - loger.log("unPackPdu->owner:",owner,"itemIdx->",itemIdx); 653 + loger.log("unPackPdu->owner:", owner, "itemIdx->", itemIdx);
607 if (owner == null || itemIdx == null || itemData == null) { 654 if (owner == null || itemIdx == null || itemData == null) {
608 this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG); 655 this._emit(MessageTypes.MCU_ERROR, MessageTypes.ERR_APE_INTERFACE_PARAM_WRONG);
609 return null; 656 return null;