1 /*
2 * Copyright (c) 2021-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 "netstack_log.h"
19 #include <algorithm>
20
21 namespace OHOS::NetStack {
22 static constexpr const int CALLBACK_PARAM_NUM = 1;
23
24 static constexpr const int ASYNC_CALLBACK_PARAM_NUM = 2;
25
EventManager()26 EventManager::EventManager() : data_(nullptr), isValid_(true) {}
27
~EventManager()28 EventManager::~EventManager()
29 {
30 NETSTACK_LOGI("EventManager is destructed by the destructor");
31 }
32
IsManagerValid() const33 bool EventManager::IsManagerValid() const
34 {
35 return isValid_;
36 }
37
SetInvalid()38 void EventManager::SetInvalid()
39 {
40 isValid_ = false;
41 }
42
AddListener(napi_env env,const std::string & type,napi_value callback,bool once,bool asyncCallback)43 void EventManager::AddListener(napi_env env, const std::string &type, napi_value callback, bool once,
44 bool asyncCallback)
45 {
46 std::lock_guard<std::mutex> lock(mutex_);
47 auto it = std::remove_if(listeners_.begin(), listeners_.end(),
48 [type](const EventListener &listener) -> bool { return listener.MatchType(type); });
49 if (it != listeners_.end()) {
50 listeners_.erase(it, listeners_.end());
51 }
52
53 listeners_.emplace_back(EventListener(env, type, callback, once, asyncCallback));
54 }
55
DeleteListener(const std::string & type,napi_value callback)56 void EventManager::DeleteListener(const std::string &type, napi_value callback)
57 {
58 std::lock_guard<std::mutex> lock(mutex_);
59 auto it =
60 std::remove_if(listeners_.begin(), listeners_.end(), [type, callback](const EventListener &listener) -> bool {
61 return listener.Match(type, callback);
62 });
63 listeners_.erase(it, listeners_.end());
64 }
65
Emit(const std::string & type,const std::pair<napi_value,napi_value> & argv)66 void EventManager::Emit(const std::string &type, const std::pair<napi_value, napi_value> &argv)
67 {
68 std::for_each(listeners_.begin(), listeners_.end(), [type, argv](const EventListener &listener) {
69 if (listener.IsAsyncCallback()) {
70 /* AsyncCallback(BusinessError error, T data) */
71 napi_value arg[ASYNC_CALLBACK_PARAM_NUM] = {argv.first, argv.second};
72 listener.Emit(type, ASYNC_CALLBACK_PARAM_NUM, arg);
73 } else {
74 /* Callback(T data) */
75 napi_value arg[CALLBACK_PARAM_NUM] = {argv.second};
76 listener.Emit(type, CALLBACK_PARAM_NUM, arg);
77 }
78 });
79
80 auto it = std::remove_if(listeners_.begin(), listeners_.end(),
81 [type](const EventListener &listener) -> bool { return listener.MatchOnce(type); });
82 listeners_.erase(it, listeners_.end());
83 }
84
SetData(void * data)85 void EventManager::SetData(void *data)
86 {
87 std::lock_guard<std::mutex> lock(mutex_);
88 data_ = data;
89 }
90
GetData()91 void *EventManager::GetData()
92 {
93 std::lock_guard<std::mutex> lock(mutex_);
94 return data_;
95 }
96
EmitByUv(const std::string & type,void * data,void (Handler)(uv_work_t *,int status))97 void EventManager::EmitByUv(const std::string &type, void *data, void(Handler)(uv_work_t *, int status))
98 {
99 std::lock_guard<std::mutex> lock(mutex_);
100 if (!IsManagerValid()) {
101 return;
102 }
103
104 std::for_each(listeners_.begin(), listeners_.end(), [type, data, Handler, this](const EventListener &listener) {
105 auto workWrapper = new UvWorkWrapper(data, listener.GetEnv(), type, this);
106 listener.EmitByUv(type, workWrapper, Handler);
107 });
108 }
109
HasEventListener(const std::string & type)110 bool EventManager::HasEventListener(const std::string &type)
111 {
112 std::lock_guard<std::mutex> lock(mutex_);
113
114 return std::any_of(listeners_.begin(), listeners_.end(),
115 [&type](const EventListener &listener) -> bool { return listener.MatchType(type); });
116 }
117
DeleteListener(const std::string & type)118 void EventManager::DeleteListener(const std::string &type)
119 {
120 std::lock_guard<std::mutex> lock(mutex_);
121 auto it = std::remove_if(listeners_.begin(), listeners_.end(),
122 [type](const EventListener &listener) -> bool { return listener.MatchType(type); });
123 listeners_.erase(it, listeners_.end());
124 }
125
UvWorkWrapper(void * theData,napi_env theEnv,std::string eventType,EventManager * eventManager)126 UvWorkWrapper::UvWorkWrapper(void *theData, napi_env theEnv, std::string eventType, EventManager *eventManager)
127 : data(theData), env(theEnv), type(std::move(eventType)), manager(eventManager)
128 {
129 }
130 } // namespace OHOS::NetStack
131