1 /*
2  * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "media_channel.h"
17 #include <chrono>
18 #include "common/common_macro.h"
19 #include "common/const_def.h"
20 #include "common/event_comm.h"
21 #include "common/media_log.h"
22 #include "common/reflect_registration.h"
23 #include "configuration/include/config.h"
24 #include "magic_enum.hpp"
25 #include "mediachannel/channel_manager.h"
26 
27 using namespace std::chrono_literals;
28 
29 namespace OHOS {
30 namespace Sharing {
31 
MediaChannel()32 MediaChannel::MediaChannel()
33 {
34     SHARING_LOGD("mediachannelId: %{public}u.", GetId());
35     SharingValue::Ptr values = nullptr;
36     int32_t maxBufferCapacity = MAX_BUFFER_CAPACITY;
37     auto ret = Config::GetInstance().GetConfig("mediachannel", "bufferDispatcher", "maxBufferCapacity", values);
38     if (ret == CONFIGURE_ERROR_NONE) {
39         values->GetValue<int32_t>(maxBufferCapacity);
40     }
41 
42     int32_t bufferCapacityIncrement = BUFFER_CAPACITY_INCREMENT;
43     ret = Config::GetInstance().GetConfig("mediachannel", "bufferDispatcher", "bufferCapacityIncrement", values);
44     if (ret == CONFIGURE_ERROR_NONE) {
45         values->GetValue<int32_t>(bufferCapacityIncrement);
46     }
47 
48     dispatcher_ = std::make_shared<BufferDispatcher>(maxBufferCapacity, bufferCapacityIncrement);
49     playController_ = std::make_shared<MediaController>(GetId());
50 }
51 
~MediaChannel()52 MediaChannel::~MediaChannel()
53 {
54     SHARING_LOGD("mediachannelId: %{public}u.", GetId());
55     if (consumer_) {
56         consumer_.reset();
57     }
58 
59     if (dispatcher_ != nullptr) {
60         dispatcher_->StopDispatch();
61         dispatcher_->FlushBuffer();
62         dispatcher_->ReleaseAllReceiver();
63         dispatcher_.reset();
64     }
65 
66     SHARING_LOGD("leave, mediachannelId: %{public}u.", GetId());
67 }
68 
OnWriteTimeout()69 void MediaChannel::OnWriteTimeout()
70 {
71     SHARING_LOGD("trace.");
72     auto msg = std::make_shared<EventMsg>();
73     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
74     statusMsg->eventMsg = msg;
75     statusMsg->errorCode = ERR_INTAKE_TIMEOUT;
76     statusMsg->agentId = GetSinkAgentId();
77     statusMsg->prosumerId = consumer_ ? consumer_->GetId() : INVALID_ID;
78 
79     SendAgentEvent(statusMsg, EVENT_AGENT_STATE_WRITE_WARNING);
80 }
81 
GetSinkAgentId()82 uint32_t MediaChannel::GetSinkAgentId()
83 {
84     SHARING_LOGD("trace.");
85     if (consumer_)
86         return consumer_->GetSinkAgentId();
87     else
88         return INVALID_ID;
89 }
90 
OnProducerNotify(ProsumerStatusMsg::Ptr &msg)91 void MediaChannel::OnProducerNotify(ProsumerStatusMsg::Ptr &msg)
92 {
93     SHARING_LOGD("trace.");
94     RETURN_IF_NULL(msg);
95     RETURN_IF_NULL(msg->eventMsg);
96     SHARING_LOGI("mediachannelId: %{public}u, producerId: %{public}u, status: %{public}s.", GetId(), msg->prosumerId,
97                  std::string(magic_enum::enum_name(static_cast<ProsumerNotifyStatus>(msg->status))).c_str());
98     switch (msg->status) {
99         case ProsumerNotifyStatus::PROSUMER_NOTIFY_INIT_SUCCESS:
100             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_CREATE);
101             break;
102         case PROSUMER_NOTIFY_START_SUCCESS:
103             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_START);
104             break;
105         case PROSUMER_NOTIFY_STOP_SUCCESS:
106             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_STOP);
107             break;
108         case PROSUMER_NOTIFY_PAUSE_SUCCESS:
109             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_PAUSE);
110             break;
111         case PROSUMER_NOTIFY_RESUME_SUCCESS:
112             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_RESUME);
113             break;
114         case PROSUMER_NOTIFY_DESTROY_SUCCESS: {
115             SHARING_LOGD("destroy producer, mediachannelId: %{public}u.", GetId());
116             std::unique_lock<std::mutex> lock(mutex_);
117             auto iter = producers_.find(msg->prosumerId);
118             if (iter != producers_.end()) {
119                 producers_.erase(iter);
120             }
121             SHARING_LOGD("erase producer, mediachannelId: %{public}u.", GetId());
122             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_DESTROY);
123             break;
124         }
125         case PROSUMER_NOTIFY_ERROR:
126             SendAgentEvent(msg, EVENT_AGENT_PROSUMER_ERROR);
127             break;
128         case PROSUMER_NOTIFY_PRIVATE_EVENT: {
129             SharingEvent agentEvent;
130             agentEvent.eventMsg = msg->eventMsg;
131             SendEvent(agentEvent);
132             return;
133         }
134         default:
135             break;
136     }
137 }
138 
OnConsumerNotify(ProsumerStatusMsg::Ptr &msg)139 void MediaChannel::OnConsumerNotify(ProsumerStatusMsg::Ptr &msg)
140 {
141     SHARING_LOGD("trace.");
142     RETURN_IF_NULL(msg);
143     RETURN_IF_NULL(msg->eventMsg);
144     SHARING_LOGI("mediachannelId: %{public}u, consumerId: %{public}u, status: %{public}s.", GetId(), msg->prosumerId,
145                  std::string(magic_enum::enum_name(static_cast<ProsumerNotifyStatus>(msg->status))).c_str());
146 
147     switch (msg->status) {
148         case ProsumerNotifyStatus::PROSUMER_NOTIFY_INIT_SUCCESS:
149             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_CREATE);
150             break;
151         case PROSUMER_NOTIFY_START_SUCCESS: {
152             msg->errorCode = InitPlayController();
153             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_START);
154             break;
155         }
156         case PROSUMER_NOTIFY_STOP_SUCCESS:
157             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_STOP);
158             break;
159         case PROSUMER_NOTIFY_PAUSE_SUCCESS:
160             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_PAUSE);
161             break;
162         case PROSUMER_NOTIFY_RESUME_SUCCESS:
163             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_RESUME);
164             break;
165         case PROSUMER_NOTIFY_DESTROY_SUCCESS:
166             SendAgentEvent(msg, EVENT_AGENT_STATE_PROSUMER_DESTROY);
167             break;
168         case PROSUMER_NOTIFY_ERROR:
169             SendAgentEvent(msg, EVENT_AGENT_PROSUMER_ERROR);
170             break;
171         case PROSUMER_NOTIFY_PRIVATE_EVENT: {
172             SharingEvent agentEvent;
173             agentEvent.eventMsg = msg->eventMsg;
174             SendEvent(agentEvent);
175             return;
176         }
177         default:
178             break;
179     }
180 }
181 
OnMediaControllerNotify(ProsumerStatusMsg::Ptr &msg)182 void MediaChannel::OnMediaControllerNotify(ProsumerStatusMsg::Ptr &msg)
183 {
184     SHARING_LOGD("trace.");
185     RETURN_IF_NULL(msg);
186     RETURN_IF_NULL(msg->eventMsg);
187     SHARING_LOGI("mediachannelId: %{public}u, prosumerId: %{public}u, status: %{public}s.", GetId(), msg->prosumerId,
188                  std::string(magic_enum::enum_name(static_cast<PlayConntrollerNotifyStatus>(msg->status))).c_str());
189 
190     switch (msg->status) {
191         case CONNTROLLER_NOTIFY_ACCELERATION:
192             SendAgentEvent(msg, EVENT_AGEINT_ACCELERATION_DONE);
193             break;
194         case CONNTROLLER_NOTIFY_DECODER_DIED:
195             SendAgentEvent(msg, EVENT_AGENT_DECODER_DIED);
196             break;
197         case CONNTROLLER_NOTIFY_KEYMOD_START:
198             SendAgentEvent(msg, EVENT_AGENT_KEYMODE_START);
199             break;
200         case CONNTROLLER_NOTIFY_KEYMOD_STOP:
201             SendAgentEvent(msg, EVENT_AGENT_KEYMODE_STOP);
202             break;
203         default:
204             break;
205     }
206 }
207 
CreateProducer(std::string &className)208 uint32_t MediaChannel::CreateProducer(std::string &className)
209 {
210     SHARING_LOGD("trace.");
211     BaseProducer::Ptr producer = ClassReflector<BaseProducer>::Class2Instance(className);
212     if (producer) {
213         std::unique_lock<std::mutex> lock(mutex_);
214         producer->SetProducerListener(shared_from_this());
215         producers_[producer->GetId()] = producer;
216         SHARING_LOGD("create producer success, mediachannelId: %{public}u.", GetId());
217         return producer->GetId();
218     }
219 
220     return INVALID_ID;
221 }
222 
CreateConsumer(std::string &className)223 SharingErrorCode MediaChannel::CreateConsumer(std::string &className)
224 {
225     SHARING_LOGD("trace.");
226     if (consumer_) {
227         consumer_.reset();
228         SHARING_LOGW("create consumer. The consumer is reseted.");
229     }
230     consumer_ = ClassReflector<BaseConsumer>::Class2Instance(className);
231     if (consumer_) {
232         consumer_->SetConsumerListener(shared_from_this());
233         if (dispatcher_) {
234             dispatcher_->SetBufferDispatcherListener(shared_from_this());
235         }
236         SHARING_LOGD("create consumer success name: %{public}s, mediachannelId: %{public}u.", className.c_str(),
237                      GetId());
238         return SharingErrorCode::ERR_OK;
239     }
240 
241     SHARING_LOGD("create consumer error name: %{public}s.", className.c_str());
242     return SharingErrorCode::ERR_GENERAL_ERROR;
243 }
244 
HandleEvent(SharingEvent &event)245 int32_t MediaChannel::HandleEvent(SharingEvent &event)
246 {
247     SHARING_LOGD("trace.");
248     RETURN_INVALID_IF_NULL(event.eventMsg);
249     SHARING_LOGI(
250         "HandleEvent mediachannelId: %{public}u, fromMgr: %{public}u, srcId: %{public}u, handle event: %{public}s.",
251         event.eventMsg->dstId, event.eventMsg->fromMgr, event.eventMsg->srcId,
252         std::string(magic_enum::enum_name(event.eventMsg->type)).c_str());
253 
254     switch (event.eventMsg->type) {
255         case EventType::EVENT_MEDIA_CONSUMER_CREATE:
256             HandleCreateConsumer(event);
257             break;
258         case EventType::EVENT_MEDIA_CONSUMER_DESTROY:
259             HandleDestroyConsumer(event);
260             break;
261         case EventType::EVENT_MEDIA_CONSUMER_START:
262             HandleStartConsumer(event);
263             break;
264         case EventType::EVENT_MEDIA_CONSUMER_STOP:
265             HandleStopConsumer(event);
266             break;
267         case EventType::EVENT_MEDIA_CONSUMER_PAUSE:
268             HandlePauseConsumer(event);
269             break;
270         case EventType::EVENT_MEDIA_CONSUMER_RESUME:
271             HandleResumeConsumer(event);
272             break;
273         case EventType::EVENT_MEDIA_PRODUCER_CREATE:
274             HandleCreateProducer(event);
275             break;
276         case EventType::EVENT_MEDIA_PRODUCER_DESTROY:
277             HandleDestroyProducer(event);
278             break;
279         case EventType::EVENT_MEDIA_PRODUCER_START:
280             HandleStartProducer(event);
281             break;
282         case EventType::EVENT_MEDIA_PRODUCER_STOP:
283             HandleStopProducer(event);
284             break;
285         case EventType::EVENT_MEDIA_PRODUCER_PAUSE:
286             HandlePauseProducer(event);
287             break;
288         case EventType::EVENT_MEDIA_PRODUCER_RESUME:
289             HandleResumeProducer(event);
290             break;
291         case EventType::EVENT_MEDIA_CHANNEL_APPENDSURFACE:
292             HandleAppendSurface(event);
293             break;
294         case EventType::EVENT_MEDIA_CHANNEL_REMOVESURFACE:
295             HandleRemoveSurface(event);
296             break;
297         case EventType::EVENT_MEDIA_CHANNEL_SETSCENETYPE:
298             HandleSetSceneType(event);
299             break;
300         case EventType::EVENT_MEDIA_CHANNEL_SETVOLUME:
301             HandleSetVolume(event);
302             break;
303         case EventType::EVENT_MEDIA_PLAY_START:
304             HandleStartPlay(event);
305             break;
306         case EventType::EVENT_MEDIA_PLAY_STOP:
307             HandleStopPlay(event);
308             break;
309         case EventType::EVENT_MEDIA_CHANNEL_KEY_REDIRECT:
310             HandleSetKeyRedirect(event);
311             break;
312         default: {
313             auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
314             if (channelMsg) {
315                 if (consumer_ && (consumer_->GetId() == channelMsg->prosumerId)) {
316                     SHARING_LOGD("send event to consumer.");
317                     consumer_->HandleEvent(event);
318                 } else if (producers_.find(channelMsg->prosumerId) != producers_.end()) {
319                     SHARING_LOGD("send event to producer.");
320                     producers_[channelMsg->prosumerId]->HandleEvent(event);
321                     return SharingErrorCode::ERR_OK;
322                 } else {
323                     SHARING_LOGW("unknow prosumerId: %{public}u.", channelMsg->prosumerId);
324                 }
325             } else {
326                 SHARING_LOGW("unknown event msg.");
327             }
328 
329             break;
330         }
331     }
332 
333     return 0;
334 }
335 
Release()336 int32_t MediaChannel::Release()
337 {
338     SHARING_LOGD("trace, mediachannelId: %{public}u.", GetId());
339     if (nullptr != playController_) {
340         SHARING_LOGD("release playController, mediachannelId: %{public}u.", GetId());
341         playController_->Release();
342         playController_.reset();
343     } else {
344         SHARING_LOGD("playerController has been released, mediachannelId: %{public}u.", GetId());
345     }
346     if (nullptr != consumer_) {
347         SHARING_LOGD("release Consumer, mediachannelId: %{public}u.", GetId());
348         consumer_.reset();
349     }
350 
351     std::unique_lock<std::mutex> lock(mutex_);
352     producers_.clear();
353     SHARING_LOGD("end mediachannelId: %{public}u.", GetId());
354     return 0;
355 }
356 
SetMediaChannelListener(std::weak_ptr<IMediaChannelListener> listener)357 void MediaChannel::SetMediaChannelListener(std::weak_ptr<IMediaChannelListener> listener)
358 {
359     SHARING_LOGD("trace.");
360     listener_ = listener;
361 }
362 
HandleAppendSurface(SharingEvent &event)363 SharingErrorCode MediaChannel::HandleAppendSurface(SharingEvent &event)
364 {
365     SHARING_LOGD("trace.");
366     auto channelMsg = ConvertEventMsg<ChannelAppendSurfaceEventMsg>(event);
367     if (channelMsg == nullptr) {
368         SHARING_LOGD("unknow msg.");
369         return SharingErrorCode::ERR_GENERAL_ERROR;
370     }
371 
372     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
373     statusMsg->eventMsg = channelMsg;
374     if ((nullptr != channelMsg->surface) && playController_) {
375         if (playController_->AppendSurface(channelMsg->surface, channelMsg->sceneType)) {
376             statusMsg->errorCode = ERR_OK;
377             statusMsg->prosumerId = consumer_->GetId();
378             statusMsg->agentId = consumer_->GetSinkAgentId();
379             SendAgentEvent(statusMsg, EVENT_AGENT_STATE_CHANNEL_APPENDSURFACE);
380             return ERR_OK;
381         } else {
382             SHARING_LOGW("AppendSurface failed.");
383             statusMsg->errorCode = ERR_INVALID_SURFACE_ID;
384         }
385     } else {
386         SHARING_LOGW("playerController or surface is nullptr.");
387         statusMsg->errorCode = ERR_PLAY_START;
388     }
389 
390     statusMsg->prosumerId = channelMsg->prosumerId;
391     statusMsg->agentId = channelMsg->agentId;
392     SendAgentEvent(statusMsg, EVENT_AGENT_STATE_CHANNEL_APPENDSURFACE);
393     return ERR_GENERAL_ERROR;
394 }
395 
HandleRemoveSurface(SharingEvent &event)396 SharingErrorCode MediaChannel::HandleRemoveSurface(SharingEvent &event)
397 {
398     SHARING_LOGD("trace.");
399     if (consumer_ == nullptr) {
400         SHARING_LOGE("consumer is not inited.");
401         return SharingErrorCode::ERR_GENERAL_ERROR;
402     }
403 
404     auto channelMsg = ConvertEventMsg<ChannelRemoveSurfaceEventMsg>(event);
405     if (channelMsg == nullptr) {
406         SHARING_LOGE("unknow msg.");
407         return SharingErrorCode::ERR_GENERAL_ERROR;
408     }
409 
410     if (playController_) {
411         playController_->RemoveSurface(channelMsg->surfaceId);
412     } else {
413         SHARING_LOGW("remove surface error, mediachannelId: %{public}u.", GetId());
414     }
415 
416     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
417     statusMsg->eventMsg = channelMsg;
418     statusMsg->errorCode = ERR_OK;
419     statusMsg->prosumerId = consumer_->GetId();
420     statusMsg->agentId = consumer_->GetSinkAgentId();
421     statusMsg->surfaceId = channelMsg->surfaceId;
422     SendAgentEvent(statusMsg, EVENT_AGENT_STATE_CHANNEL_REMOVESURFACE);
423 
424     return SharingErrorCode::ERR_OK;
425 }
426 
HandleSetSceneType(SharingEvent &event)427 SharingErrorCode MediaChannel::HandleSetSceneType(SharingEvent &event)
428 {
429     SHARING_LOGD("trace.");
430     auto channelMsg = ConvertEventMsg<ChannelSetSceneTypeEventMsg>(event);
431     if (channelMsg == nullptr) {
432         SHARING_LOGE("unknow msg.");
433         return SharingErrorCode::ERR_GENERAL_ERROR;
434     }
435 
436     if (playController_) {
437         if (channelMsg->sceneType == OHOS::Sharing::SceneType::FOREGROUND) {
438             playController_->SetKeyMode(channelMsg->surfaceId, false);
439         } else if (channelMsg->sceneType == OHOS::Sharing::SceneType::BACKGROUND) {
440             playController_->SetKeyMode(channelMsg->surfaceId, true);
441         }
442     }
443 
444     SHARING_LOGW("playerController is nullptr, mediaChannelId: %{public}u.", GetId());
445     return ERR_OK;
446 }
447 
HandleSetKeyRedirect(SharingEvent &event)448 SharingErrorCode MediaChannel::HandleSetKeyRedirect(SharingEvent &event)
449 {
450     SHARING_LOGD("trace.");
451     auto channelMsg = ConvertEventMsg<ChannelSetKeyRedirectEventMsg>(event);
452     if (channelMsg == nullptr) {
453         SHARING_LOGE("unknow msg.");
454         return SharingErrorCode::ERR_GENERAL_ERROR;
455     }
456 
457     if (playController_) {
458         playController_->SetKeyRedirect(channelMsg->surfaceId, channelMsg->keyRedirect);
459     } else {
460         SHARING_LOGW("playerController is nullptr, mediaChannelId: %{public}u.", GetId());
461     }
462 
463     return ERR_OK;
464 }
465 
HandleSetVolume(SharingEvent &event)466 SharingErrorCode MediaChannel::HandleSetVolume(SharingEvent &event)
467 {
468     SHARING_LOGD("trace.");
469     auto channelMsg = ConvertEventMsg<ChannelSetVolumeEventMsg>(event);
470     if (channelMsg == nullptr) {
471         SHARING_LOGE("unknow msg.");
472         return SharingErrorCode::ERR_GENERAL_ERROR;
473     }
474 
475     float volume = channelMsg->volume;
476     if (playController_) {
477         playController_->SetVolume(volume);
478     } else {
479         SHARING_LOGW("playerController is nullptr, mediaChannelId: %{public}u.", GetId());
480     }
481 
482     return ERR_OK;
483 }
484 
HandleStartPlay(SharingEvent &event)485 SharingErrorCode MediaChannel::HandleStartPlay(SharingEvent &event)
486 {
487     SHARING_LOGD("trace.");
488     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
489     if (channelMsg == nullptr) {
490         SHARING_LOGE("unknow msg.");
491         return SharingErrorCode::ERR_GENERAL_ERROR;
492     }
493 
494     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
495     statusMsg->eventMsg = channelMsg;
496     statusMsg->prosumerId = consumer_ ? consumer_->GetId() : channelMsg->prosumerId;
497     statusMsg->agentId = channelMsg->agentId;
498 
499     if (playController_) {
500         playController_->Start();
501         statusMsg->errorCode = ERR_OK;
502     } else {
503         SHARING_LOGW("playerController is nullptr, mediaChannelId: %{public}u.", GetId());
504         statusMsg->errorCode = ERR_PLAY_START;
505     }
506 
507     SendAgentEvent(statusMsg, EVENT_AGENT_STATE_PLAY_START);
508     return ERR_OK;
509 }
510 
HandleStopPlay(SharingEvent &event)511 SharingErrorCode MediaChannel::HandleStopPlay(SharingEvent &event)
512 {
513     SHARING_LOGD("trace.");
514     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
515     if (channelMsg == nullptr) {
516         SHARING_LOGE("unknow msg.");
517         return SharingErrorCode::ERR_GENERAL_ERROR;
518     }
519 
520     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
521     statusMsg->eventMsg = channelMsg;
522     statusMsg->prosumerId = consumer_ ? consumer_->GetId() : channelMsg->prosumerId;
523     statusMsg->agentId = channelMsg->agentId;
524 
525     if (playController_) {
526         playController_->Stop();
527         statusMsg->errorCode = ERR_OK;
528     } else {
529         SHARING_LOGW("playerController is nullptr, mediaChannelId: %{public}u.", GetId());
530         statusMsg->errorCode = ERR_PLAY_STOP;
531     }
532 
533     SendAgentEvent(statusMsg, EVENT_AGENT_STATE_PLAY_STOP);
534     return ERR_OK;
535 }
536 
HandleCreateConsumer(SharingEvent &event)537 SharingErrorCode MediaChannel::HandleCreateConsumer(SharingEvent &event)
538 {
539     SHARING_LOGD("trace.");
540     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
541     if (channelMsg == nullptr) {
542         SHARING_LOGE("unknow msg.");
543         return SharingErrorCode::ERR_GENERAL_ERROR;
544     }
545     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
546     statusMsg->eventMsg = channelMsg;
547 
548     if (CreateConsumer(channelMsg->className) == ERR_OK) {
549         if (consumer_) {
550             SHARING_LOGD("create consumer success, consumerId: %{public}u, mediachannelId: %{public}u.",
551                          consumer_->GetId(), GetId());
552             statusMsg->status = PROSUMER_INIT;
553             consumer_->SetSinkAgentId(channelMsg->agentId);
554             consumer_->UpdateOperation(statusMsg);
555         }
556         return ERR_OK;
557     } else {
558         SHARING_LOGW("create consumer failed.");
559         statusMsg->errorCode = ERR_PROSUMER_CREATE;
560         statusMsg->prosumerId = INVALID_ID;
561         statusMsg->agentId = channelMsg->agentId;
562         SendAgentEvent(statusMsg, EVENT_AGENT_PROSUMER_ERROR);
563         return ERR_GENERAL_ERROR;
564     }
565 }
566 
HandleDestroyConsumer(SharingEvent &event)567 SharingErrorCode MediaChannel::HandleDestroyConsumer(SharingEvent &event)
568 {
569     SHARING_LOGD("trace.");
570     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
571     if (channelMsg == nullptr) {
572         SHARING_LOGE("unknow msg.");
573         return SharingErrorCode::ERR_GENERAL_ERROR;
574     }
575 
576     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
577     statusMsg->eventMsg = channelMsg;
578 
579     if (consumer_ == nullptr) {
580         SHARING_LOGW("consumer is null, mediachannelId: %{public}u.", GetId());
581         statusMsg->errorCode = ERR_OK;
582         statusMsg->prosumerId = INVALID_ID;
583         statusMsg->agentId = channelMsg->agentId;
584         SendAgentEvent(statusMsg, EVENT_AGENT_STATE_PROSUMER_DESTROY);
585         return SharingErrorCode::ERR_OK;
586     }
587 
588     if (consumer_->IsRunning()) {
589         SHARING_LOGD("consumer is running, mediachannelId: %{public}u.", GetId());
590         statusMsg->errorCode = ERR_PROSUMER_DESTROY;
591         statusMsg->prosumerId = consumer_ ? consumer_->GetId() : INVALID_ID;
592         statusMsg->agentId = channelMsg->agentId;
593         SendAgentEvent(statusMsg, EVENT_AGENT_PROSUMER_ERROR);
594         return SharingErrorCode::ERR_GENERAL_ERROR;
595     } else {
596         statusMsg->status = PROSUMER_DESTROY;
597         consumer_->UpdateOperation(statusMsg);
598         SHARING_LOGD("ERR_OK.");
599         return SharingErrorCode::ERR_OK;
600     }
601 }
602 
HandleStartConsumer(SharingEvent &event)603 SharingErrorCode MediaChannel::HandleStartConsumer(SharingEvent &event)
604 {
605     SHARING_LOGD("trace.");
606     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
607     if (channelMsg == nullptr) {
608         SHARING_LOGE("unknow msg.");
609         return SharingErrorCode::ERR_GENERAL_ERROR;
610     }
611 
612     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
613     statusMsg->eventMsg = channelMsg;
614 
615     if (consumer_) {
616         statusMsg->status = PROSUMER_START;
617         consumer_->UpdateOperation(statusMsg);
618         SHARING_LOGD("update consumer start success, mediaChannelId: %{public}u.", GetId());
619         return SharingErrorCode::ERR_OK;
620     } else {
621         SHARING_LOGE("consumer is null, mediachannelId: %{public}u.", GetId());
622         statusMsg->errorCode = ERR_PROSUMER_START;
623         statusMsg->prosumerId = INVALID_ID;
624         statusMsg->agentId = channelMsg->agentId;
625         SendAgentEvent(statusMsg, EVENT_AGENT_PROSUMER_ERROR);
626         return SharingErrorCode::ERR_GENERAL_ERROR;
627     }
628 }
629 
HandleStopConsumer(SharingEvent &event)630 SharingErrorCode MediaChannel::HandleStopConsumer(SharingEvent &event)
631 {
632     SHARING_LOGD("trace.");
633     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
634     if (channelMsg == nullptr) {
635         SHARING_LOGE("unknow msg.");
636         return SharingErrorCode::ERR_GENERAL_ERROR;
637     }
638 
639     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
640     statusMsg->eventMsg = channelMsg;
641 
642     if (nullptr != playController_) {
643         playController_->Stop();
644         SHARING_LOGD("play controller stop success, mediaChannelId: %{public}u.", GetId());
645     } else {
646         SHARING_LOGW("playerController is nullptr, mediaChannelId: %{public}u.", GetId());
647     }
648 
649     if (consumer_) {
650         statusMsg->status = PROSUMER_STOP;
651         consumer_->UpdateOperation(statusMsg);
652         SHARING_LOGD("update consumer stop success, mediaChannelId: %{public}u.", GetId());
653     } else {
654         SHARING_LOGW("consumer null mediaChannelId: %{public}u.", GetId());
655         statusMsg->errorCode = ERR_OK;
656         statusMsg->prosumerId = INVALID_ID;
657         statusMsg->agentId = channelMsg->agentId;
658         SendAgentEvent(statusMsg, EVENT_AGENT_STATE_PROSUMER_STOP);
659     }
660 
661     return SharingErrorCode::ERR_OK;
662 }
663 
HandlePauseConsumer(SharingEvent &event)664 SharingErrorCode MediaChannel::HandlePauseConsumer(SharingEvent &event)
665 {
666     SHARING_LOGD("trace.");
667     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
668     if (channelMsg == nullptr) {
669         SHARING_LOGE("unknow msg.");
670         return SharingErrorCode::ERR_GENERAL_ERROR;
671     }
672 
673     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
674     statusMsg->eventMsg = channelMsg;
675     statusMsg->mediaType = channelMsg->mediaType;
676 
677     if (consumer_) {
678         statusMsg->status = PROSUMER_PAUSE;
679         consumer_->UpdateOperation(statusMsg);
680         return SharingErrorCode::ERR_OK;
681     }
682 
683     SHARING_LOGD("pasue consumer error mediachannelId: %{public}u.", GetId());
684     return SharingErrorCode::ERR_GENERAL_ERROR;
685 }
686 
HandleResumeConsumer(SharingEvent &event)687 SharingErrorCode MediaChannel::HandleResumeConsumer(SharingEvent &event)
688 {
689     SHARING_LOGD("trace.");
690     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
691     if (channelMsg == nullptr) {
692         SHARING_LOGE("unknow msg.");
693         return SharingErrorCode::ERR_GENERAL_ERROR;
694     }
695 
696     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
697     statusMsg->eventMsg = channelMsg;
698     statusMsg->mediaType = channelMsg->mediaType;
699 
700     if (consumer_) {
701         statusMsg->status = PROSUMER_RESUME;
702         consumer_->UpdateOperation(statusMsg);
703         return SharingErrorCode::ERR_OK;
704     }
705 
706     SHARING_LOGD("resume consumer error mediachannelId: %{public}u.", GetId());
707     return SharingErrorCode::ERR_GENERAL_ERROR;
708 }
709 
HandleCreateProducer(SharingEvent &event)710 SharingErrorCode MediaChannel::HandleCreateProducer(SharingEvent &event)
711 {
712     SHARING_LOGD("trace.");
713     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
714     if (channelMsg == nullptr) {
715         SHARING_LOGE("unknow msg.");
716         return SharingErrorCode::ERR_GENERAL_ERROR;
717     }
718 
719     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
720     statusMsg->eventMsg = channelMsg;
721 
722     uint32_t retId = CreateProducer(channelMsg->className);
723     if (retId != INVALID_ID) {
724         SHARING_LOGD("create prosumer success.");
725         producers_[retId]->SetSrcAgentId(channelMsg->agentId);
726         statusMsg->status = PROSUMER_INIT;
727         producers_[retId]->UpdateOperation(statusMsg);
728         return SharingErrorCode::ERR_OK;
729     } else {
730         SHARING_LOGW("create prosumer failed.");
731         statusMsg->errorCode = ERR_PROSUMER_CREATE;
732         statusMsg->prosumerId = INVALID_ID;
733         statusMsg->agentId = channelMsg->agentId;
734         SendAgentEvent(statusMsg, EVENT_AGENT_PROSUMER_ERROR);
735         return SharingErrorCode::ERR_GENERAL_ERROR;
736     }
737 }
738 
HandleDestroyProducer(SharingEvent &event)739 SharingErrorCode MediaChannel::HandleDestroyProducer(SharingEvent &event)
740 {
741     SHARING_LOGD("trace.");
742     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
743     if (channelMsg == nullptr) {
744         SHARING_LOGE("unknow msg.");
745         return SharingErrorCode::ERR_GENERAL_ERROR;
746     }
747 
748     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
749     statusMsg->eventMsg = channelMsg;
750 
751     uint32_t id = channelMsg->prosumerId;
752     BaseProducer::Ptr pProducer = nullptr;
753     {
754         std::unique_lock<std::mutex> lock(mutex_);
755         auto iter = producers_.find(id);
756         if (iter != producers_.end()) {
757             pProducer = iter->second;
758         } else {
759             SHARING_LOGE("cann't find producerId: %{public}d, channelId: %{public}d.", id, GetId());
760         }
761     }
762 
763     if (nullptr == pProducer) {
764         statusMsg->errorCode = ERR_OK;
765         statusMsg->prosumerId = id;
766         statusMsg->agentId = channelMsg->agentId;
767         SendAgentEvent(statusMsg, EVENT_AGENT_STATE_PROSUMER_DESTROY);
768         return SharingErrorCode::ERR_OK;
769     }
770 
771     if (pProducer->IsRunning()) {
772         SHARING_LOGD("producer is running, producerId: %{public}d, mediachannelId: %{public}u.", id, GetId());
773         statusMsg->errorCode = ERR_PROSUMER_DESTROY;
774         statusMsg->prosumerId = id;
775         statusMsg->agentId = channelMsg->agentId;
776         SendAgentEvent(statusMsg, EVENT_AGENT_PROSUMER_ERROR);
777     } else {
778         statusMsg->status = PROSUMER_DESTROY;
779         pProducer->UpdateOperation(statusMsg);
780     }
781 
782     SHARING_LOGD("producer destroy exit, mediachannelId: %{public}u.", GetId());
783     return SharingErrorCode::ERR_OK;
784 }
785 
HandleStartProducer(SharingEvent &event)786 SharingErrorCode MediaChannel::HandleStartProducer(SharingEvent &event)
787 {
788     SHARING_LOGD("trace.");
789     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
790     if (channelMsg == nullptr) {
791         SHARING_LOGE("unknow msg.");
792         return SharingErrorCode::ERR_GENERAL_ERROR;
793     }
794 
795     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
796     statusMsg->eventMsg = channelMsg;
797 
798     {
799         std::unique_lock<std::mutex> lock(mutex_);
800         auto iter = producers_.find(channelMsg->prosumerId);
801         if (iter != producers_.end() && (iter->second)) {
802             auto producer = iter->second;
803             dispatcher_->AttachReceiver(producer);
804             statusMsg->status = PROSUMER_START;
805             producer->UpdateOperation(statusMsg);
806             producer->StartDispatchThread();
807             SHARING_LOGD("media start producer success, mediachannelId: %{public}u.", GetId());
808             return SharingErrorCode::ERR_OK;
809         } else {
810             SHARING_LOGW("cann't find producerId: %{public}d, mediachannelId: %{public}d, agentId: %{public}d.",
811                          channelMsg->prosumerId, GetId(), channelMsg->agentId);
812             statusMsg->errorCode = ERR_PROSUMER_START;
813             statusMsg->prosumerId = channelMsg->prosumerId;
814             statusMsg->agentId = channelMsg->agentId;
815             SendAgentEvent(statusMsg, EVENT_AGENT_PROSUMER_ERROR);
816         }
817     }
818 
819     SHARING_LOGD("media start producer end, mediachannelId: %{public}u.", GetId());
820     return SharingErrorCode::ERR_GENERAL_ERROR;
821 }
822 
HandleStopProducer(SharingEvent &event)823 SharingErrorCode MediaChannel::HandleStopProducer(SharingEvent &event)
824 {
825     SHARING_LOGD("trace.");
826     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
827     if (channelMsg == nullptr) {
828         SHARING_LOGE("unknow msg.");
829         return SharingErrorCode::ERR_GENERAL_ERROR;
830     }
831 
832     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
833     statusMsg->eventMsg = channelMsg;
834     {
835         std::unique_lock<std::mutex> lock(mutex_);
836         auto iter = producers_.find(channelMsg->prosumerId);
837         if (iter != producers_.end() && (iter->second)) {
838             dispatcher_->DetachReceiver(iter->second);
839             statusMsg->status = PROSUMER_STOP;
840             iter->second->UpdateOperation(statusMsg);
841             SHARING_LOGD("media stop producer success, mediachannelId: %{public}u.", GetId());
842             return SharingErrorCode::ERR_OK;
843         } else {
844             SHARING_LOGW("cann't find producerId: %{public}d, mediachannelId: %{public}d, agentId: %{public}d.",
845                          channelMsg->prosumerId, GetId(), channelMsg->agentId);
846             statusMsg->errorCode = ERR_OK;
847             statusMsg->prosumerId = channelMsg->prosumerId;
848             statusMsg->agentId = channelMsg->agentId;
849             SendAgentEvent(statusMsg, EVENT_AGENT_STATE_PROSUMER_STOP);
850         }
851     }
852 
853     SHARING_LOGD("media stop producer end, mediachannelId: %{public}u.", GetId());
854     return SharingErrorCode::ERR_GENERAL_ERROR;
855 }
856 
HandlePauseProducer(SharingEvent &event)857 SharingErrorCode MediaChannel::HandlePauseProducer(SharingEvent &event)
858 {
859     SHARING_LOGD("trace.");
860     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
861     if (channelMsg == nullptr) {
862         SHARING_LOGE("unknow msg.");
863         return SharingErrorCode::ERR_GENERAL_ERROR;
864     }
865 
866     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
867     statusMsg->eventMsg = channelMsg;
868     statusMsg->mediaType = channelMsg->mediaType;
869 
870     {
871         std::unique_lock<std::mutex> lock(mutex_);
872         auto iter = producers_.find(channelMsg->prosumerId);
873         if (iter != producers_.end() && (iter->second)) {
874             statusMsg->status = PROSUMER_PAUSE;
875             iter->second->UpdateOperation(statusMsg);
876             return SharingErrorCode::ERR_OK;
877         } else {
878             SHARING_LOGW("cann't find producerId: %{public}d, mediachannelId: %{public}d, agentId: %{public}d.",
879                          channelMsg->prosumerId, GetId(), channelMsg->agentId);
880         }
881     }
882 
883     SHARING_LOGD("media pause producer end, mediachannelId: %{public}u.", GetId());
884     return SharingErrorCode::ERR_GENERAL_ERROR;
885 }
886 
HandleResumeProducer(SharingEvent &event)887 SharingErrorCode MediaChannel::HandleResumeProducer(SharingEvent &event)
888 {
889     SHARING_LOGD("trace.");
890     auto channelMsg = ConvertEventMsg<ChannelEventMsg>(event);
891     if (channelMsg == nullptr) {
892         SHARING_LOGE("unknow msg.");
893         return SharingErrorCode::ERR_GENERAL_ERROR;
894     }
895 
896     auto statusMsg = std::make_shared<ProsumerStatusMsg>();
897     statusMsg->eventMsg = channelMsg;
898     statusMsg->mediaType = channelMsg->mediaType;
899 
900     {
901         std::unique_lock<std::mutex> lock(mutex_);
902         auto iter = producers_.find(channelMsg->prosumerId);
903         if (iter != producers_.end() && (iter->second)) {
904             statusMsg->status = PROSUMER_RESUME;
905             iter->second->UpdateOperation(statusMsg);
906             return SharingErrorCode::ERR_OK;
907         } else {
908             SHARING_LOGW("cann't find producerId: %{public}d, mediachannelId: %{public}d, agentId: %{public}d.",
909                          channelMsg->prosumerId, GetId(), channelMsg->agentId);
910         }
911     }
912 
913     SHARING_LOGD("media resume producer end, mediachannelId: %{public}u.", GetId());
914     return SharingErrorCode::ERR_GENERAL_ERROR;
915 }
916 
SendAgentEvent(ProsumerStatusMsg::Ptr &msg, EventType eventType)917 void MediaChannel::SendAgentEvent(ProsumerStatusMsg::Ptr &msg, EventType eventType)
918 {
919     SHARING_LOGD("trace.");
920     RETURN_IF_NULL(msg);
921     RETURN_IF_NULL(msg->eventMsg);
922     SHARING_LOGD("send event: %{public}s ,mediachannelId: %{public}u, contextId: %{public}u, agentId: %{public}u.",
923                  std::string(magic_enum::enum_name(eventType)).c_str(), GetId(), srcContextId_, msg->agentId);
924 
925     auto agentMsg = std::make_shared<AgentEventMsg>();
926     agentMsg->toMgr = ModuleType::MODULE_CONTEXT;
927     agentMsg->fromMgr = ModuleType::MODULE_MEDIACHANNEL;
928     agentMsg->srcId = GetId();
929     agentMsg->dstId = srcContextId_;
930     agentMsg->type = eventType;
931     agentMsg->requestId = msg->eventMsg->requestId;
932     agentMsg->agentId = msg->agentId;
933     agentMsg->prosumerId = msg->prosumerId;
934     agentMsg->errorCode = msg->errorCode;
935     agentMsg->surfaceId = msg->surfaceId;
936 
937     SharingEvent agentEvent;
938     agentEvent.eventMsg = std::move(agentMsg);
939     SendEvent(agentEvent);
940 }
941 
InitPlayController()942 SharingErrorCode MediaChannel::InitPlayController()
943 {
944     SHARING_LOGD("trace.");
945     if (playController_ != nullptr) {
946         playController_->SetMediaChannel(shared_from_this());
947         AudioTrack audioTrack;
948         if (!(consumer_->IsCapture())) {
949             audioTrack = consumer_->GetAudioTrack();
950         }
951         VideoTrack videoTrack = consumer_->GetVideoTrack();
952         if (!playController_->Init(audioTrack, videoTrack)) {
953             SHARING_LOGE("player controller Init error.");
954             playController_ = nullptr;
955             return SharingErrorCode::ERR_DECODE_FORMAT;
956         }
957     }
958 
959     SHARING_LOGD("create playcontroller end, mediachannelId: %{public}u.", GetId());
960     return SharingErrorCode::ERR_OK;
961 }
962 
963 } // namespace Sharing
964 } // namespace OHOS