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 "channel_manager.h"
17 #include "common/common_macro.h"
18 #include "magic_enum.hpp"
19 #include "mediachannel/media_channel.h"
20
21 namespace OHOS {
22 namespace Sharing {
23
ChannelManager()24 ChannelManager::ChannelManager()
25 {
26 SHARING_LOGD("id: %{public}s.", std::string(magic_enum::enum_name(ModuleType::MODULE_MEDIACHANNEL)).c_str());
27 }
28
Init()29 void ChannelManager::Init()
30 {
31 SHARING_LOGD("trace.");
32 }
33
~ChannelManager()34 ChannelManager::~ChannelManager()
35 {
36 SHARING_LOGD("id: %{public}s.", std::string(magic_enum::enum_name(ModuleType::MODULE_MEDIACHANNEL)).c_str());
37 }
38
HandleMediaChannelCreate(SharingEvent & event)39 SharingErrorCode ChannelManager::HandleMediaChannelCreate(SharingEvent &event)
40 {
41 SHARING_LOGD("trace.");
42 auto eventMsg = ConvertEventMsg<ChannelEventMsg>(event);
43 if (eventMsg == nullptr) {
44 return SharingErrorCode::ERR_GENERAL_ERROR;
45 }
46
47 auto channel = std::make_shared<MediaChannel>();
48 channel->SetContextId(eventMsg->srcId);
49 eventMsg->srcId = channel->GetId();
50 {
51 std::lock_guard<std::mutex> lock(mutex_);
52 mediaChannels_.emplace(channel->GetId(), channel);
53 }
54
55 return SharingErrorCode::ERR_OK;
56 }
57
HandleMediaChannelDestroy(SharingEvent & event)58 SharingErrorCode ChannelManager::HandleMediaChannelDestroy(SharingEvent &event)
59 {
60 SHARING_LOGD("trace.");
61 auto eventMsg = ConvertEventMsg<ChannelEventMsg>(event);
62 if (eventMsg == nullptr) {
63 return SharingErrorCode::ERR_GENERAL_ERROR;
64 }
65
66 {
67 std::lock_guard<std::mutex> lock(mutex_);
68 auto channel = mediaChannels_.find(eventMsg->dstId);
69 if (channel != mediaChannels_.end()) {
70 mediaChannels_.erase(channel);
71 }
72 }
73
74 auto contextMsg = std::make_shared<ContextEventMsg>();
75 contextMsg->type = EventType::EVENT_CONTEXTMGR_STATE_CHANNEL_DESTROY;
76 contextMsg->toMgr = ModuleType::MODULE_CONTEXT;
77 contextMsg->fromMgr = ModuleType::MODULE_MEDIACHANNEL;
78 contextMsg->srcId = eventMsg->dstId;
79 contextMsg->dstId = eventMsg->srcId;
80 contextMsg->agentId = eventMsg->agentId;
81 SharingEvent contextEvent;
82 contextEvent.eventMsg = std::move(contextMsg);
83 SHARING_LOGI("mediachannelId: %{public}d, SendEvent event: %{public}s.", eventMsg->dstId,
84 std::string(magic_enum::enum_name(contextEvent.eventMsg->type)).c_str());
85 SendEvent(contextEvent);
86
87 return SharingErrorCode::ERR_OK;
88 }
89
HandleEvent(SharingEvent & event)90 int32_t ChannelManager::HandleEvent(SharingEvent &event)
91 {
92 SHARING_LOGD("trace.");
93 RETURN_INVALID_IF_NULL(event.eventMsg);
94 SHARING_LOGI("fromMgr: %{public}u, srcId: %{public}u, toMgr: %{public}u, dstId: %{public}u, event: %{public}s.",
95 event.eventMsg->fromMgr, event.eventMsg->srcId, event.eventMsg->toMgr, event.eventMsg->dstId,
96 std::string(magic_enum::enum_name(event.eventMsg->type)).c_str());
97
98 switch (event.eventMsg->type) {
99 case EventType::EVENT_CONFIGURE_MEDIACHANNEL:
100 SHARING_LOGD("EVENT_CONFIGURE_MEDIACHANNEL.");
101 break;
102 case EventType::EVENT_MEDIA_CHANNEL_CREATE:
103 SHARING_LOGD("trace.");
104 HandleMediaChannelCreate(event);
105 break;
106 case EventType::EVENT_MEDIA_CHANNEL_DESTROY:
107 SHARING_LOGD("trace.");
108 HandleMediaChannelDestroy(event);
109 break;
110 default: {
111 SHARING_LOGD("default.");
112 uint32_t mediaChannelId = event.eventMsg->dstId;
113 auto mediaChannel = GetMediaChannel(mediaChannelId);
114 if (mediaChannel != nullptr) {
115 mediaChannel->HandleEvent(event);
116 } else {
117 SHARING_LOGE("distribute event channel not exist channelId: %{public}d.", mediaChannelId);
118 }
119 break;
120 }
121 }
122
123 SHARING_LOGD("done eventType: %{public}s.", std::string(magic_enum::enum_name(event.eventMsg->type)).c_str());
124 return 0;
125 }
126
GetMediaChannel(uint32_t mediaChannelId)127 MediaChannel::Ptr ChannelManager::GetMediaChannel(uint32_t mediaChannelId)
128 {
129 SHARING_LOGD("trace, mediachannelId: %{public}u.", mediaChannelId);
130 std::lock_guard<std::mutex> lock(mutex_);
131 auto channel = mediaChannels_.find(mediaChannelId);
132 if (channel != mediaChannels_.end()) {
133 return (channel->second);
134 } else {
135 return nullptr;
136 }
137 }
138
139 } // namespace Sharing
140 } // namespace OHOS