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 "net_conn_callback_observer.h"
17
18 #include "connection_exec.h"
19 #include "constant.h"
20 #include "netconnection.h"
21 #include "netmanager_base_log.h"
22
23 namespace OHOS::NetManagerStandard {
NetAvailable(sptr<NetHandle> & netHandle)24 int32_t NetConnCallbackObserver::NetAvailable(sptr<NetHandle> &netHandle)
25 {
26 if (netHandle == nullptr) {
27 return 0;
28 }
29 NetConnection *netConnection = NET_CONNECTIONS[this];
30 if (netConnection == nullptr) {
31 NETMANAGER_BASE_LOGI("can not find netConnection handle");
32 return 0;
33 }
34 if (!netConnection->GetEventManager()->HasEventListener(EVENT_NET_AVAILABLE)) {
35 NETMANAGER_BASE_LOGI("no event listener find %{public}s", EVENT_NET_AVAILABLE);
36 return 0;
37 }
38 netConnection->GetEventManager()->EmitByUv(EVENT_NET_AVAILABLE, new NetHandle(*netHandle), NetAvailableCallback);
39 return 0;
40 }
41
NetCapabilitiesChange(sptr<NetHandle> & netHandle,const sptr<NetAllCapabilities> & netAllCap)42 int32_t NetConnCallbackObserver::NetCapabilitiesChange(sptr<NetHandle> &netHandle,
43 const sptr<NetAllCapabilities> &netAllCap)
44 {
45 if (netHandle == nullptr) {
46 return 0;
47 }
48 NetConnection *netConnection = NET_CONNECTIONS[this];
49 if (netConnection == nullptr) {
50 NETMANAGER_BASE_LOGI("can not find netConnection handle");
51 return 0;
52 }
53 if (!netConnection->GetEventManager()->HasEventListener(EVENT_NET_CAPABILITIES_CHANGE)) {
54 NETMANAGER_BASE_LOGI("no event listener find %{public}s", EVENT_NET_CAPABILITIES_CHANGE);
55 return 0;
56 }
57 auto pair = new std::pair<NetHandle *, NetAllCapabilities *>;
58 pair->first = new NetHandle(*netHandle);
59 pair->second = new NetAllCapabilities(*netAllCap);
60 netConnection->GetEventManager()->EmitByUv(EVENT_NET_CAPABILITIES_CHANGE, pair, NetCapabilitiesChangeCallback);
61 return 0;
62 }
63
NetConnectionPropertiesChange(sptr<NetHandle> & netHandle,const sptr<NetLinkInfo> & info)64 int32_t NetConnCallbackObserver::NetConnectionPropertiesChange(sptr<NetHandle> &netHandle,
65 const sptr<NetLinkInfo> &info)
66 {
67 if (netHandle == nullptr) {
68 return 0;
69 }
70 NetConnection *netConnection = NET_CONNECTIONS[this];
71 if (netConnection == nullptr) {
72 NETMANAGER_BASE_LOGI("can not find netConnection handle");
73 return 0;
74 }
75 if (!netConnection->GetEventManager()->HasEventListener(EVENT_NET_CONNECTION_PROPERTIES_CHANGE)) {
76 NETMANAGER_BASE_LOGI("no event listener find %{public}s", EVENT_NET_CONNECTION_PROPERTIES_CHANGE);
77 return 0;
78 }
79 auto pair = new std::pair<NetHandle *, NetLinkInfo *>;
80 pair->first = new NetHandle(*netHandle);
81 pair->second = new NetLinkInfo(*info);
82 netConnection->GetEventManager()->EmitByUv(EVENT_NET_CONNECTION_PROPERTIES_CHANGE, pair,
83 NetConnectionPropertiesChangeCallback);
84 return 0;
85 }
86
NetLost(sptr<NetHandle> & netHandle)87 int32_t NetConnCallbackObserver::NetLost(sptr<NetHandle> &netHandle)
88 {
89 if (netHandle == nullptr) {
90 return 0;
91 }
92 NetConnection *netConnection = NET_CONNECTIONS[this];
93 if (netConnection == nullptr) {
94 NETMANAGER_BASE_LOGI("can not find netConnection handle");
95 return 0;
96 }
97 if (!netConnection->GetEventManager()->HasEventListener(EVENT_NET_LOST)) {
98 NETMANAGER_BASE_LOGI("no event listener find %{public}s", EVENT_NET_LOST);
99 return 0;
100 }
101 netConnection->GetEventManager()->EmitByUv(EVENT_NET_LOST, new NetHandle(*netHandle), NetLostCallback);
102 return 0;
103 }
104
NetUnavailable()105 int32_t NetConnCallbackObserver::NetUnavailable()
106 {
107 NetConnection *netConnection = NET_CONNECTIONS[this];
108 if (netConnection == nullptr) {
109 NETMANAGER_BASE_LOGI("can not find netConnection handle");
110 return 0;
111 }
112 if (!netConnection->GetEventManager()->HasEventListener(EVENT_NET_UNAVAILABLE)) {
113 NETMANAGER_BASE_LOGI("no event listener find %{public}s", EVENT_NET_UNAVAILABLE);
114 return 0;
115 }
116 netConnection->GetEventManager()->EmitByUv(EVENT_NET_UNAVAILABLE, nullptr, NetUnavailableCallback);
117 return 0;
118 }
119
NetBlockStatusChange(sptr<NetHandle> & netHandle,bool blocked)120 int32_t NetConnCallbackObserver::NetBlockStatusChange(sptr<NetHandle> &netHandle, bool blocked)
121 {
122 NetConnection *netConnection = NET_CONNECTIONS[this];
123 if (netConnection == nullptr) {
124 NETMANAGER_BASE_LOGI("can not find netConnection handle");
125 return 0;
126 }
127 if (!netConnection->GetEventManager()->HasEventListener(EVENT_NET_BLOCK_STATUS_CHANGE)) {
128 NETMANAGER_BASE_LOGI("no event listener find %{public}s", EVENT_NET_BLOCK_STATUS_CHANGE);
129 return 0;
130 }
131 auto pair = new std::pair<NetHandle *, bool>;
132 pair->first = new NetHandle(*netHandle);
133 pair->second = blocked;
134 netConnection->GetEventManager()->EmitByUv(EVENT_NET_BLOCK_STATUS_CHANGE, pair, NetBlockStatusChangeCallback);
135 return 0;
136 }
137
CreateNetHandle(napi_env env,NetHandle * handle)138 napi_value NetConnCallbackObserver::CreateNetHandle(napi_env env, NetHandle *handle)
139 {
140 napi_value netHandle = ConnectionExec::CreateNetHandle(env, handle);
141 delete handle;
142 return netHandle;
143 }
144
CreateNetCapabilities(napi_env env,NetAllCapabilities * capabilities)145 napi_value NetConnCallbackObserver::CreateNetCapabilities(napi_env env, NetAllCapabilities *capabilities)
146 {
147 napi_value netCapabilities = ConnectionExec::CreateNetCapabilities(env, capabilities);
148 delete capabilities;
149 return netCapabilities;
150 }
151
CreateConnectionProperties(napi_env env,NetLinkInfo * linkInfo)152 napi_value NetConnCallbackObserver::CreateConnectionProperties(napi_env env, NetLinkInfo *linkInfo)
153 {
154 napi_value connectionProperties = ConnectionExec::CreateConnectionProperties(env, linkInfo);
155 delete linkInfo;
156 return connectionProperties;
157 }
158
CreateNetAvailableParam(napi_env env,void * data)159 napi_value NetConnCallbackObserver::CreateNetAvailableParam(napi_env env, void *data)
160 {
161 return CreateNetHandle(env, static_cast<NetHandle *>(data));
162 }
163
CreateNetCapabilitiesChangeParam(napi_env env,void * data)164 napi_value NetConnCallbackObserver::CreateNetCapabilitiesChangeParam(napi_env env, void *data)
165 {
166 auto pair = static_cast<std::pair<NetHandle *, NetAllCapabilities *> *>(data);
167 napi_value netHandle = CreateNetHandle(env, pair->first);
168 napi_value capabilities = CreateNetCapabilities(env, pair->second);
169 napi_value obj = NapiUtils::CreateObject(env);
170 NapiUtils::SetNamedProperty(env, obj, KEY_NET_HANDLE, netHandle);
171 NapiUtils::SetNamedProperty(env, obj, KEY_NET_CAP, capabilities);
172 delete pair;
173 return obj;
174 }
175
CreateNetConnectionPropertiesChangeParam(napi_env env,void * data)176 napi_value NetConnCallbackObserver::CreateNetConnectionPropertiesChangeParam(napi_env env, void *data)
177 {
178 auto pair = static_cast<std::pair<NetHandle *, NetLinkInfo *> *>(data);
179 napi_value netHandle = CreateNetHandle(env, pair->first);
180 napi_value properties = CreateConnectionProperties(env, pair->second);
181 napi_value obj = NapiUtils::CreateObject(env);
182 NapiUtils::SetNamedProperty(env, obj, KEY_NET_HANDLE, netHandle);
183 NapiUtils::SetNamedProperty(env, obj, KEY_CONNECTION_PROPERTIES, properties);
184 delete pair;
185 return obj;
186 }
187
CreateNetLostParam(napi_env env,void * data)188 napi_value NetConnCallbackObserver::CreateNetLostParam(napi_env env, void *data)
189 {
190 return CreateNetHandle(env, static_cast<NetHandle *>(data));
191 }
192
CreateNetUnavailableParam(napi_env env,void * data)193 napi_value NetConnCallbackObserver::CreateNetUnavailableParam(napi_env env, void *data)
194 {
195 (void)data;
196
197 return NapiUtils::GetUndefined(env);
198 }
199
CreateNetBlockStatusChangeParam(napi_env env,void * data)200 napi_value NetConnCallbackObserver::CreateNetBlockStatusChangeParam(napi_env env, void *data)
201 {
202 auto pair = static_cast<std::pair<NetHandle *, bool> *>(data);
203 napi_value netHandle = CreateNetHandle(env, pair->first);
204 napi_value obj = NapiUtils::CreateObject(env);
205 NapiUtils::SetNamedProperty(env, obj, KEY_NET_HANDLE, netHandle);
206 NapiUtils::SetBooleanProperty(env, obj, KEY_BLOCKED, pair->second);
207 delete pair;
208 return obj;
209 }
210
NetAvailableCallback(uv_work_t * work,int status)211 void NetConnCallbackObserver::NetAvailableCallback(uv_work_t *work, int status)
212 {
213 CallbackTemplate<CreateNetAvailableParam>(work, status);
214 }
215
NetCapabilitiesChangeCallback(uv_work_t * work,int status)216 void NetConnCallbackObserver::NetCapabilitiesChangeCallback(uv_work_t *work, int status)
217 {
218 CallbackTemplate<CreateNetCapabilitiesChangeParam>(work, status);
219 }
220
NetConnectionPropertiesChangeCallback(uv_work_t * work,int status)221 void NetConnCallbackObserver::NetConnectionPropertiesChangeCallback(uv_work_t *work, int status)
222 {
223 CallbackTemplate<CreateNetConnectionPropertiesChangeParam>(work, status);
224 }
225
NetLostCallback(uv_work_t * work,int status)226 void NetConnCallbackObserver::NetLostCallback(uv_work_t *work, int status)
227 {
228 CallbackTemplate<CreateNetLostParam>(work, status);
229 }
230
NetUnavailableCallback(uv_work_t * work,int status)231 void NetConnCallbackObserver::NetUnavailableCallback(uv_work_t *work, int status)
232 {
233 CallbackTemplate<CreateNetUnavailableParam>(work, status);
234 }
235
NetBlockStatusChangeCallback(uv_work_t * work,int status)236 void NetConnCallbackObserver::NetBlockStatusChangeCallback(uv_work_t *work, int status)
237 {
238 CallbackTemplate<CreateNetBlockStatusChangeParam>(work, status);
239 }
240 } // namespace OHOS::NetManagerStandard
241