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