1 /*
2 * Copyright (c) 2022 Huawei Device 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_manager.h"
17
18 #include "netmanager_base_log.h"
19 #include "securec.h"
20
21 namespace OHOS {
22 namespace NetManagerStandard {
23 namespace {
24 static constexpr const int CALLBACK_PARAM_NUM = 1;
25 static constexpr const int ASYNC_CALLBACK_PARAM_NUM = 2;
26 } // namespace
27
EventManager()28 EventManager::EventManager() : data_(nullptr) {}
29
AddListener(napi_env env,const std::string & type,napi_value callback,bool once,bool asyncCallback)30 void EventManager::AddListener(napi_env env, const std::string &type, napi_value callback, bool once,
31 bool asyncCallback)
32 {
33 std::unique_lock<std::shared_mutex> lock(mutexForListenersAndEmitByUv_);
34 auto it = std::remove_if(listeners_.begin(), listeners_.end(),
35 [type](const EventListener &listener) -> bool { return listener.MatchType(type); });
36 if (it != listeners_.end()) {
37 listeners_.erase(it, listeners_.end());
38 }
39 listeners_.emplace_back(EventListener(env, type, callback, once, asyncCallback));
40 }
41
DeleteListener(const std::string & type,napi_value callback)42 void EventManager::DeleteListener(const std::string &type, napi_value callback)
43 {
44 std::unique_lock<std::shared_mutex> lock(mutexForListenersAndEmitByUv_);
45 auto it =
46 std::remove_if(listeners_.begin(), listeners_.end(), [type, callback](const EventListener &listener) -> bool {
47 return listener.Match(type, callback);
48 });
49 listeners_.erase(it, listeners_.end());
50 }
51
Emit(const std::string & type,const std::pair<napi_value,napi_value> & argv)52 void EventManager::Emit(const std::string &type, const std::pair<napi_value, napi_value> &argv)
53 {
54 std::unique_lock<std::shared_mutex> lock1(mutexForListenersAndEmitByUv_);
55 std::list<EventListener> tmpListeners(listeners_);
56 lock1.unlock();
57
58 std::unique_lock lock2(mutexForEmitAndEmitByUv_);
59 std::for_each(tmpListeners.begin(), tmpListeners.end(), [type, argv](const EventListener &listener) {
60 if (listener.IsAsyncCallback()) {
61 /* AsyncCallback(BusinessError error, T data) */
62 napi_value arg[ASYNC_CALLBACK_PARAM_NUM] = {argv.first, argv.second};
63 listener.Emit(type, ASYNC_CALLBACK_PARAM_NUM, arg);
64 } else {
65 /* Callback(T data) */
66 napi_value arg[CALLBACK_PARAM_NUM] = {argv.second};
67 listener.Emit(type, CALLBACK_PARAM_NUM, arg);
68 }
69 });
70 lock2.unlock();
71
72 std::unique_lock<std::shared_mutex> lock3(mutexForListenersAndEmitByUv_);
73 auto it = std::remove_if(listeners_.begin(), listeners_.end(),
74 [type](const EventListener &listener) -> bool { return listener.MatchOnce(type); });
75 listeners_.erase(it, listeners_.end());
76 }
77
SetData(void * data)78 void EventManager::SetData(void *data)
79 {
80 data_ = data;
81 }
82
GetData()83 void *EventManager::GetData()
84 {
85 return data_;
86 }
87
EmitByUvWithModuleId(const std::string & type,const NapiUtils::UvHandler & handler,uint64_t moduleId)88 void EventManager::EmitByUvWithModuleId(const std::string &type, const NapiUtils::UvHandler &handler, uint64_t moduleId)
89 {
90 std::shared_lock<std::shared_mutex> lock1(mutexForListenersAndEmitByUv_);
91 std::lock_guard lock2(mutexForEmitAndEmitByUv_);
92
93 std::for_each(listeners_.begin(), listeners_.end(), [type, handler, moduleId](const EventListener &listener) {
94 listener.EmitByUvByModuleId(type, handler, moduleId);
95 });
96 }
97
EmitByUv(const std::string & type,void * data,void (handler)(uv_work_t *,int status))98 void EventManager::EmitByUv(const std::string &type, void *data, void(handler)(uv_work_t *, int status))
99 {
100 std::shared_lock<std::shared_mutex> lock1(mutexForListenersAndEmitByUv_);
101 std::lock_guard lock2(mutexForEmitAndEmitByUv_);
102
103 std::for_each(listeners_.begin(), listeners_.end(), [type, data, handler, this](const EventListener &listener) {
104 auto workWrapper = new UvWorkWrapper(data, listener.GetEnv(), type, shared_from_this());
105 listener.EmitByUv(type, workWrapper, handler);
106 });
107 }
108
HasEventListener(const std::string & type)109 bool EventManager::HasEventListener(const std::string &type)
110 {
111 std::shared_lock<std::shared_mutex> lock2(mutexForListenersAndEmitByUv_);
112 return std::any_of(listeners_.begin(), listeners_.end(),
113 [&type](const EventListener &listener) -> bool { return listener.MatchType(type); });
114 }
115
DeleteListener(const std::string & type)116 void EventManager::DeleteListener(const std::string &type)
117 {
118 std::unique_lock<std::shared_mutex> lock2(mutexForListenersAndEmitByUv_);
119 auto it = std::remove_if(listeners_.begin(), listeners_.end(),
120 [type](const EventListener &listener) -> bool { return listener.MatchType(type); });
121 listeners_.erase(it, listeners_.end());
122 }
123
DeleteAllListener()124 void EventManager::DeleteAllListener()
125 {
126 NETMANAGER_BASE_LOGD("DeleteAllListener");
127 std::unique_lock<std::shared_mutex> lock(mutexForListenersAndEmitByUv_);
128 listeners_.clear();
129 }
130
GetRef() const131 napi_ref EventManager::GetRef() const
132 {
133 return ref_;
134 }
135
SetRef(napi_ref ref)136 void EventManager::SetRef(napi_ref ref)
137 {
138 ref_ = ref;
139 }
140
UvWorkWrapper(void * theData,napi_env theEnv,std::string eventType,std::shared_ptr<EventManager> eventManager)141 UvWorkWrapper::UvWorkWrapper(void *theData, napi_env theEnv, std::string eventType,
142 std::shared_ptr<EventManager> eventManager)
143 : data(theData), env(theEnv), type(std::move(eventType)), manager(eventManager)
144 {
145 }
146 } // namespace NetManagerStandard
147 } // namespace OHOS
148