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 if (channel == nullptr) {
49 SHARING_LOGE("channel is null");
50 return SharingErrorCode::ERR_GENERAL_ERROR;
51 }
52
53 channel->SetContextId(eventMsg->srcId);
54 eventMsg->srcId = channel->GetId();
55 {
56 std::lock_guard<std::mutex> lock(mutex_);
57 mediaChannels_.emplace(channel->GetId(), channel);
58 }
59
60 return SharingErrorCode::ERR_OK;
61 }
62
HandleMediaChannelDestroy(SharingEvent & event)63 SharingErrorCode ChannelManager::HandleMediaChannelDestroy(SharingEvent &event)
64 {
65 SHARING_LOGD("trace.");
66 auto eventMsg = ConvertEventMsg<ChannelEventMsg>(event);
67 if (eventMsg == nullptr) {
68 return SharingErrorCode::ERR_GENERAL_ERROR;
69 }
70
71 {
72 std::lock_guard<std::mutex> lock(mutex_);
73 auto channel = mediaChannels_.find(eventMsg->dstId);
74 if (channel != mediaChannels_.end()) {
75 mediaChannels_.erase(channel);
76 }
77 }
78
79 auto contextMsg = std::make_shared<ContextEventMsg>();
80 contextMsg->type = EventType::EVENT_CONTEXTMGR_STATE_CHANNEL_DESTROY;
81 contextMsg->toMgr = ModuleType::MODULE_CONTEXT;
82 contextMsg->fromMgr = ModuleType::MODULE_MEDIACHANNEL;
83 contextMsg->srcId = eventMsg->dstId;
84 contextMsg->dstId = eventMsg->srcId;
85 contextMsg->agentId = eventMsg->agentId;
86 SharingEvent contextEvent;
87 contextEvent.eventMsg = std::move(contextMsg);
88 SHARING_LOGI("mediachannelId: %{public}d, SendEvent event: %{public}s.", eventMsg->dstId,
89 std::string(magic_enum::enum_name(contextEvent.eventMsg->type)).c_str());
90 SendEvent(contextEvent);
91
92 return SharingErrorCode::ERR_OK;
93 }
94
HandleEvent(SharingEvent & event)95 int32_t ChannelManager::HandleEvent(SharingEvent &event)
96 {
97 SHARING_LOGD("trace.");
98 RETURN_INVALID_IF_NULL(event.eventMsg);
99 SHARING_LOGI("fromMgr: %{public}u, srcId: %{public}u, toMgr: %{public}u, dstId: %{public}u, event: %{public}s.",
100 event.eventMsg->fromMgr, event.eventMsg->srcId, event.eventMsg->toMgr, event.eventMsg->dstId,
101 std::string(magic_enum::enum_name(event.eventMsg->type)).c_str());
102
103 switch (event.eventMsg->type) {
104 case EventType::EVENT_CONFIGURE_MEDIACHANNEL:
105 SHARING_LOGD("EVENT_CONFIGURE_MEDIACHANNEL.");
106 break;
107 case EventType::EVENT_MEDIA_CHANNEL_CREATE:
108 SHARING_LOGD("trace.");
109 HandleMediaChannelCreate(event);
110 break;
111 case EventType::EVENT_MEDIA_CHANNEL_DESTROY:
112 SHARING_LOGD("trace.");
113 HandleMediaChannelDestroy(event);
114 break;
115 default: {
116 SHARING_LOGD("default.");
117 uint32_t mediaChannelId = event.eventMsg->dstId;
118 auto mediaChannel = GetMediaChannel(mediaChannelId);
119 if (mediaChannel != nullptr) {
120 mediaChannel->HandleEvent(event);
121 } else {
122 SHARING_LOGE("distribute event channel not exist channelId: %{public}d.", mediaChannelId);
123 }
124 break;
125 }
126 }
127
128 SHARING_LOGD("done eventType: %{public}s.", std::string(magic_enum::enum_name(event.eventMsg->type)).c_str());
129 return 0;
130 }
131
GetMediaChannel(uint32_t mediaChannelId)132 MediaChannel::Ptr ChannelManager::GetMediaChannel(uint32_t mediaChannelId)
133 {
134 SHARING_LOGD("trace, mediachannelId: %{public}u.", mediaChannelId);
135 std::lock_guard<std::mutex> lock(mutex_);
136 auto channel = mediaChannels_.find(mediaChannelId);
137 if (channel != mediaChannels_.end()) {
138 return (channel->second);
139 } else {
140 return nullptr;
141 }
142 }
143
144 } // namespace Sharing
145 } // namespace OHOS