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