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
21namespace OHOS {
22namespace Sharing {
23
24ChannelManager::ChannelManager()
25{
26    SHARING_LOGD("id: %{public}s.", std::string(magic_enum::enum_name(ModuleType::MODULE_MEDIACHANNEL)).c_str());
27}
28
29void ChannelManager::Init()
30{
31    SHARING_LOGD("trace.");
32}
33
34ChannelManager::~ChannelManager()
35{
36    SHARING_LOGD("id: %{public}s.", std::string(magic_enum::enum_name(ModuleType::MODULE_MEDIACHANNEL)).c_str());
37}
38
39SharingErrorCode 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
58SharingErrorCode 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
90int32_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
127MediaChannel::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