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 "event_handler_manager.h"
17 #include "common/media_log.h"
18
19 namespace OHOS {
20 namespace Sharing {
EventHandlerManager()21 EventHandlerManager::EventHandlerManager()
22 {
23 SHARING_LOGD("trace.");
24 Init();
25 }
26
~EventHandlerManager()27 EventHandlerManager::~EventHandlerManager()
28 {
29 SHARING_LOGD("~EventHandlerManager.");
30 std::unique_lock<std::mutex> lock(mutex);
31 eventRunner_->Stop();
32 listenerMap_.clear();
33 handlerMap_.clear();
34 }
35
Init()36 void EventHandlerManager::Init()
37 {
38 SHARING_LOGD("eventHandlerManager Init.");
39 std::unique_lock<std::mutex> lock(mutex);
40 eventRunner_ = OHOS::AppExecFwk::EventRunner::Create(true);
41 eventRunner_->Run();
42 }
43
GetEventRunner()44 std::shared_ptr<OHOS::AppExecFwk::EventRunner> EventHandlerManager::GetEventRunner()
45 {
46 SHARING_LOGD("trace.");
47 return eventRunner_;
48 }
49
GetEventHandler(int32_t fd)50 std::shared_ptr<OHOS::AppExecFwk::EventHandler> EventHandlerManager::GetEventHandler(int32_t fd)
51 {
52 SHARING_LOGD("trace.");
53 std::unique_lock<std::mutex> lock(mutex);
54 if (handlerMap_.find(fd) != handlerMap_.end()) {
55 auto handler = handlerMap_[fd].lock();
56 if (handler != nullptr) {
57 return handler;
58 }
59 }
60
61 return nullptr;
62 }
63
AddFdListener(int32_t fd,const std::shared_ptr<FileDescriptorListener> & listener)64 int32_t EventHandlerManager::AddFdListener(int32_t fd, const std::shared_ptr<FileDescriptorListener> &listener)
65 {
66 SHARING_LOGD("trace.");
67 std::unique_lock<std::mutex> lock(mutex);
68 if (listenerMap_.find(fd) != listenerMap_.end()) {
69 auto listener = listenerMap_[fd].lock();
70 if (listener != nullptr) {
71 return 0;
72 }
73 }
74 listenerMap_.insert(std::make_pair(fd, listener));
75 return 0;
76 }
77
AddEventHandler(int32_t fd,const std::shared_ptr<OHOS::AppExecFwk::EventHandler> & handler)78 int32_t EventHandlerManager::AddEventHandler(int32_t fd, const std::shared_ptr<OHOS::AppExecFwk::EventHandler> &handler)
79 {
80 SHARING_LOGD("trace.");
81 std::unique_lock<std::mutex> lock(mutex);
82 if (handlerMap_.find(fd) != handlerMap_.end()) {
83 auto handler = handlerMap_[fd].lock();
84 if (handler != nullptr) {
85 return 0;
86 }
87 }
88 handlerMap_.insert(std::make_pair(fd, handler));
89 return 0;
90 }
91
DelFdListener(int32_t fd)92 int32_t EventHandlerManager::DelFdListener(int32_t fd)
93 {
94 SHARING_LOGD("trace.");
95 std::unique_lock<std::mutex> lock(mutex);
96 if (listenerMap_.find(fd) != listenerMap_.end()) {
97 listenerMap_.erase(fd);
98 }
99
100 return 0;
101 }
102
DelEventHandler(int32_t fd)103 int32_t EventHandlerManager::DelEventHandler(int32_t fd)
104 {
105 SHARING_LOGD("trace.");
106 std::unique_lock<std::mutex> lock(mutex);
107 if (handlerMap_.find(fd) != handlerMap_.end()) {
108 handlerMap_.erase(fd);
109 }
110
111 return 0;
112 }
113
114 } // namespace Sharing
115 } // namespace OHOS