1 /*
2 * Copyright (C) 2025 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 "napi_link_enhance_connection.h"
17
18 #include "conn_log.h"
19 #include "napi_link_enhance_error_code.h"
20 #include "napi_link_enhance_utils.h"
21 #include "securec.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_connection.h"
24 #include "softbus_error_code.h"
25
26 namespace Communication {
27 namespace OHOS::Softbus {
28
29 thread_local napi_ref NapiLinkEnhanceConnection::consRef_ = nullptr;
30
31 std::vector<NapiLinkEnhanceConnection *> NapiLinkEnhanceConnection::connectionList_;
32 std::mutex NapiLinkEnhanceConnection::connectionListMutex_;
33
CheckCreateConnectionParams(napi_env env,napi_callback_info info,napi_value & outResult)34 static napi_status CheckCreateConnectionParams(napi_env env, napi_callback_info info, napi_value &outResult)
35 {
36 size_t argc = ARGS_SIZE_THREE;
37 napi_value argv[ARGS_SIZE_THREE] = { 0 };
38
39 NAPI_SOFTBUS_CALL_RETURN(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
40 NAPI_SOFTBUS_RETURN_IF(
41 argc != ARGS_SIZE_TWO && argc != ARGS_SIZE_THREE, "expect 2 or 3 args", napi_invalid_arg);
42
43 std::string deviceId {};
44 if (!ParseString(env, deviceId, argv[ARGS_SIZE_ZERO])) {
45 COMM_LOGE(COMM_SDK, "expect string");
46 return napi_string_expected;
47 }
48
49 std::string name {};
50 if (!ParseString(env, name, argv[ARGS_SIZE_ONE])) {
51 COMM_LOGE(COMM_SDK, "expect string");
52 return napi_string_expected;
53 }
54
55 if (deviceId.length() == 0 || name.length() == 0) {
56 COMM_LOGE(COMM_SDK, "name or deviceId is null");
57 return napi_invalid_arg;
58 }
59
60 if (argc == ARGS_SIZE_THREE) {
61 int32_t handle;
62 if (!ParseInt32(env, handle, argv[ARGS_SIZE_TWO])) {
63 COMM_LOGE(COMM_SDK, "expect int");
64 return napi_invalid_arg;
65 }
66 }
67
68 napi_value constructor = nullptr;
69 NAPI_SOFTBUS_CALL_RETURN(napi_get_reference_value(env, NapiLinkEnhanceConnection::consRef_, &constructor));
70 NAPI_SOFTBUS_CALL_RETURN(napi_new_instance(env, constructor, argc, argv, &outResult));
71 return napi_ok;
72 }
73
Create(napi_env env,napi_callback_info info)74 napi_value NapiLinkEnhanceConnection::Create(napi_env env, napi_callback_info info)
75 {
76 COMM_LOGD(COMM_SDK, "enter");
77 if (!CheckAccessToken()) {
78 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
79 return NapiGetUndefinedRet(env);
80 }
81 napi_value result;
82 auto status = CheckCreateConnectionParams(env, info, result);
83 if (status != napi_ok) {
84 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
85 return NapiGetUndefinedRet(env);
86 }
87 return result;
88 }
89
DefineJSClass(napi_env env)90 void NapiLinkEnhanceConnection::DefineJSClass(napi_env env)
91 {
92 napi_property_descriptor properties[] = {
93 DECLARE_NAPI_FUNCTION("connect", Connect),
94 DECLARE_NAPI_FUNCTION("disconnect", Disconnect),
95 DECLARE_NAPI_FUNCTION("close", Close),
96 DECLARE_NAPI_FUNCTION("getPeerDeviceId", GetPeerDeviceId),
97 DECLARE_NAPI_FUNCTION("sendData", SendData),
98
99 DECLARE_NAPI_FUNCTION("on", On),
100 DECLARE_NAPI_FUNCTION("off", Off),
101 };
102
103 napi_value constructor = nullptr;
104 napi_define_class(env, "Connection", NAPI_AUTO_LENGTH, Constructor, nullptr,
105 sizeof(properties) / sizeof(properties[0]), properties, &constructor);
106 napi_create_reference(env, constructor, 1, &consRef_);
107 }
108
Constructor(napi_env env,napi_callback_info info)109 napi_value NapiLinkEnhanceConnection::Constructor(napi_env env, napi_callback_info info)
110 {
111 COMM_LOGD(COMM_SDK, "enter");
112 napi_value thisVar = nullptr;
113
114 size_t argc = ARGS_SIZE_THREE;
115 napi_value argv[ARGS_SIZE_THREE] = { 0 };
116
117 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
118 if (argc != ARGS_SIZE_TWO && argc != ARGS_SIZE_THREE) {
119 COMM_LOGE(COMM_SDK, "unexpected args");
120 return NapiGetUndefinedRet(env);
121 }
122 std::string deviceId;
123 std::string name;
124 if (!ParseString(env, deviceId, argv[PARAM0]) || !ParseString(env, name, argv[PARAM1])) {
125 COMM_LOGE(COMM_SDK, "ParseString failed");
126 return NapiGetUndefinedRet(env);
127 };
128 NapiLinkEnhanceConnection *connection = nullptr;
129 if (argc == ARGS_SIZE_THREE) {
130 uint32_t handle;
131 ParseUInt32(env, handle, argv[PARAM2]);
132 connection = new NapiLinkEnhanceConnection(deviceId, name, handle);
133 } else {
134 connection = new NapiLinkEnhanceConnection(deviceId, name);
135 }
136 CONN_CHECK_AND_RETURN_RET_LOGE(connection != nullptr, thisVar, COMM_SDK, "new link enhance connection failed");
137 auto status = napi_wrap(
138 env, thisVar, connection,
139 [](napi_env env, void *data, void *hint) {
140 NapiLinkEnhanceConnection *connection = static_cast<NapiLinkEnhanceConnection *>(data);
141 if (connection) {
142 delete connection;
143 connection = nullptr;
144 }
145 },
146 nullptr, nullptr);
147 if (status != napi_ok) {
148 COMM_LOGE(COMM_SDK, "napi_wrap failed");
149 delete connection;
150 connection = nullptr;
151 return thisVar;
152 }
153
154 connection->env_ = env;
155 {
156 std::lock_guard<std::mutex> guard(connectionListMutex_);
157 connectionList_.push_back(connection);
158 }
159 return thisVar;
160 }
161
NapiGetEnhanceConnection(napi_env env,napi_value thisVar)162 static NapiLinkEnhanceConnection *NapiGetEnhanceConnection(napi_env env, napi_value thisVar)
163 {
164 NapiLinkEnhanceConnection *connection = nullptr;
165 auto status = napi_unwrap(env, thisVar, (void **)&connection);
166 if (status != napi_ok) {
167 return nullptr;
168 }
169 return connection;
170 }
171
NapiGetEnhanceConnection(napi_env env,napi_callback_info info)172 static NapiLinkEnhanceConnection *NapiGetEnhanceConnection(napi_env env, napi_callback_info info)
173 {
174 size_t argc = 0;
175 napi_value thisVar = nullptr;
176 if (napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr) != napi_ok) {
177 return nullptr;
178 }
179 return NapiGetEnhanceConnection(env, thisVar);
180 }
181
CheckAccessTokenAndParams(napi_env env,napi_callback_info info,std::string & funcName)182 static bool CheckAccessTokenAndParams(napi_env env, napi_callback_info info, std::string &funcName)
183 {
184 if (!CheckAccessToken()) {
185 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
186 return false;
187 }
188 size_t argc = ARGS_SIZE_TWO;
189 napi_value args[ARGS_SIZE_TWO];
190 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
191 if (status != napi_ok || argc != ARGS_SIZE_TWO) {
192 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
193 return false;
194 }
195
196 napi_valuetype valueType = napi_null;
197 napi_typeof(env, args[PARAM1], &valueType);
198 if (valueType != napi_function) {
199 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
200 return false;
201 }
202
203 size_t typeLen = 0;
204 status = napi_get_value_string_utf8(env, args[ARGS_SIZE_ZERO], nullptr, -1, &typeLen);
205 if (status != napi_ok || typeLen >= ARGS_TYPE_MAX_LEN) {
206 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
207 return false;
208 }
209 char type[ARGS_TYPE_MAX_LEN];
210 status = napi_get_value_string_utf8(env, args[ARGS_SIZE_ZERO], type, sizeof(type), &typeLen);
211 if (status != napi_ok) {
212 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
213 return false;
214 }
215 funcName = type;
216 return true;
217 }
218
On(napi_env env,napi_callback_info info)219 napi_value NapiLinkEnhanceConnection::On(napi_env env, napi_callback_info info)
220 {
221 std::string funcName = "";
222 if (!CheckAccessTokenAndParams(env, info, funcName)) {
223 return NapiGetUndefinedRet(env);
224 }
225 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
226 size_t argc = ARGS_SIZE_TWO;
227 napi_value args[ARGS_SIZE_TWO];
228 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
229 if (status != napi_ok || argc != ARGS_SIZE_TWO || connection == nullptr) {
230 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
231 return NapiGetUndefinedRet(env);
232 }
233 if (strcmp(funcName.c_str(), "connectResult") == 0) {
234 COMM_LOGI(COMM_SDK, "register connectResult");
235 if (connection->connectResultRef_ != nullptr) {
236 napi_delete_reference(env, connection->connectResultRef_);
237 }
238 napi_create_reference(env, args[ARGS_SIZE_ONE], 1, &(connection->connectResultRef_));
239 connection->SetConnectResultEnable(true);
240 } else if (strcmp(funcName.c_str(), "dataReceived") == 0) {
241 COMM_LOGI(COMM_SDK, "register dataReceived");
242 if (connection->dataReceivedRef_ != nullptr) {
243 napi_delete_reference(env, connection->dataReceivedRef_);
244 }
245 napi_create_reference(env, args[ARGS_SIZE_ONE], 1, &(connection->dataReceivedRef_));
246 connection->SetEnableData(true);
247 } else if (strcmp(funcName.c_str(), "disconnected") == 0) {
248 COMM_LOGI(COMM_SDK, "register disconnected");
249 if (connection->disconnectRef_ != nullptr) {
250 napi_delete_reference(env, connection->disconnectRef_);
251 }
252 napi_create_reference(env, args[ARGS_SIZE_ONE], 1, &(connection->disconnectRef_));
253 connection->SetEnableDisconnect(true);
254 } else {
255 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
256 return NapiGetUndefinedRet(env);
257 }
258 return NapiGetUndefinedRet(env);
259 }
260
Off(napi_env env,napi_callback_info info)261 napi_value NapiLinkEnhanceConnection::Off(napi_env env, napi_callback_info info)
262 {
263 std::string funcName = "";
264 if (!CheckAccessTokenAndParams(env, info, funcName)) {
265 return NapiGetUndefinedRet(env);
266 }
267 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
268 if (connection == nullptr) {
269 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
270 return NapiGetUndefinedRet(env);
271 }
272 if (strcmp(funcName.c_str(), "connectResult") == 0 && connection->connectResultRef_ != nullptr) {
273 COMM_LOGI(COMM_SDK, "unregister connectResult");
274 napi_delete_reference(env, connection->connectResultRef_);
275 connection->connectResultRef_ = nullptr;
276 connection->SetConnectResultEnable(false);
277 } else if (strcmp(funcName.c_str(), "dataReceived") == 0 && connection->dataReceivedRef_ != nullptr) {
278 COMM_LOGI(COMM_SDK, "unregister dataReceived");
279 napi_delete_reference(env, connection->dataReceivedRef_);
280 connection->dataReceivedRef_ = nullptr;
281 connection->SetEnableData(false);
282 } else if (strcmp(funcName.c_str(), "disconnected") == 0 && connection->disconnectRef_ != nullptr) {
283 COMM_LOGI(COMM_SDK, "unregister disconnected");
284 napi_delete_reference(env, connection->disconnectRef_);
285 connection->disconnectRef_ = nullptr;
286 connection->SetEnableDisconnect(false);
287 } else {
288 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
289 return NapiGetUndefinedRet(env);
290 }
291 return NapiGetUndefinedRet(env);
292 }
293
Connect(napi_env env,napi_callback_info info)294 napi_value NapiLinkEnhanceConnection::Connect(napi_env env, napi_callback_info info)
295 {
296 size_t argc = 0;
297 napi_status status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
298 if (status != napi_ok || argc > ARGS_SIZE_ZERO) {
299 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
300 return NapiGetUndefinedRet(env);
301 }
302 if (!CheckAccessToken()) {
303 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
304 return NapiGetUndefinedRet(env);
305 }
306 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
307 if (connection == nullptr) {
308 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
309 return NapiGetUndefinedRet(env);
310 }
311 Address address = {
312 .addrType = CONNECTION_ADDR_BLE,
313 };
314 if (strcpy_s(address.addr.ble.mac, BT_MAC_LEN, connection->deviceId_.c_str()) != 0) {
315 HandleSyncErr(env, LINK_ENHANCE_INTERVAL_ERR);
316 return NapiGetUndefinedRet(env);
317 }
318
319 int32_t handle = GeneralConnect(PKG_NAME.c_str(), connection->name_.c_str(), &address);
320 if (handle <= 0) {
321 COMM_LOGE(COMM_SDK, "connect failed, err=%{public}d", handle);
322 int32_t errcode = ConvertToJsErrcode(handle);
323 HandleSyncErr(env, errcode);
324 return NapiGetUndefinedRet(env);
325 }
326 connection->handle_ = (uint32_t)handle;
327 connection->state_ = ConnectionState::STATE_CONNECTING;
328 COMM_LOGI(COMM_SDK, "start connect handle=%{public}u", handle);
329 return NapiGetUndefinedRet(env);
330 }
331
Disconnect(napi_env env,napi_callback_info info)332 napi_value NapiLinkEnhanceConnection::Disconnect(napi_env env, napi_callback_info info)
333 {
334 if (!CheckAccessToken()) {
335 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
336 return NapiGetUndefinedRet(env);
337 }
338 size_t argc = 0;
339 napi_status status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
340 if (status != napi_ok || argc > ARGS_SIZE_ZERO) {
341 return NapiGetUndefinedRet(env);
342 }
343 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
344 if (connection == nullptr) {
345 return NapiGetUndefinedRet(env);
346 }
347 std::lock_guard<std::mutex> guard(connectionListMutex_);
348 for (auto iter = connectionList_.begin(); iter != connectionList_.end(); ++iter) {
349 if ((*iter)->handle_ == connection->handle_) {
350 COMM_LOGI(COMM_SDK, "disconnect connection, handle=%{public}u", connection->handle_);
351 int32_t errCode = ConvertToJsErrcode(GeneralDisconnect(connection->handle_));
352 if (errCode == LINK_ENHANCE_PERMISSION_DENIED) {
353 HandleSyncErr(env, errCode);
354 }
355 connectionList_.erase(iter);
356 break;
357 }
358 }
359
360 return NapiGetUndefinedRet(env);
361 }
362
Close(napi_env env,napi_callback_info info)363 napi_value NapiLinkEnhanceConnection::Close(napi_env env, napi_callback_info info)
364 {
365 if (!CheckAccessToken()) {
366 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
367 return NapiGetUndefinedRet(env);
368 }
369 size_t argc = 0;
370 napi_status status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
371 if (status != napi_ok || argc > ARGS_SIZE_ZERO) {
372 COMM_LOGE(COMM_SDK, "no needed arguments");
373 return NapiGetUndefinedRet(env);
374 }
375 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
376 if (connection == nullptr) {
377 COMM_LOGE(COMM_SDK, "get connection failed");
378 return NapiGetUndefinedRet(env);
379 }
380 COMM_LOGI(COMM_SDK, "close connection, handle=%{public}u", connection->handle_);
381 connection->lock_.lock();
382 connection->isEnableConnectResult_ = false;
383 connection->isEnableData_ = false;
384 connection->isEnableDisconnect_ = false;
385 connection->lock_.unlock();
386 if (connection->connectResultRef_ != nullptr) {
387 COMM_LOGI(COMM_SDK, "unregister connectResult");
388 napi_delete_reference(env, connection->connectResultRef_);
389 connection->connectResultRef_ = nullptr;
390 }
391 if (connection->dataReceivedRef_ != nullptr) {
392 COMM_LOGI(COMM_SDK, "unregister dataReceived");
393 napi_delete_reference(env, connection->dataReceivedRef_);
394 connection->dataReceivedRef_ = nullptr;
395 }
396 if (connection->disconnectRef_ != nullptr) {
397 COMM_LOGI(COMM_SDK, "unregister disconnected");
398 napi_delete_reference(env, connection->disconnectRef_);
399 connection->disconnectRef_ = nullptr;
400 }
401
402 (void)GeneralDisconnect(connection->handle_);
403 std::lock_guard<std::mutex> guard(connectionListMutex_);
404 for (auto iter = connectionList_.begin(); iter != connectionList_.end(); ++iter) {
405 if ((*iter)->handle_ == connection->handle_) {
406 COMM_LOGI(COMM_SDK, "erase connection, handle=%{public}u", connection->handle_);
407 connectionList_.erase(iter);
408 break;
409 }
410 }
411 return NapiGetUndefinedRet(env);
412 }
413
GetPeerDeviceId(napi_env env,napi_callback_info info)414 napi_value NapiLinkEnhanceConnection::GetPeerDeviceId(napi_env env, napi_callback_info info)
415 {
416 if (!CheckAccessToken()) {
417 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
418 return NapiGetUndefinedRet(env);
419 }
420 std::string deviceId = "";
421 size_t argc = 0;
422 napi_status status = napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
423 if (status != napi_ok || argc > ARGS_SIZE_ZERO) {
424 COMM_LOGI(COMM_SDK, "no needed arguments");
425 return NapiGetStringRet(env, deviceId);
426 }
427 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
428 if (connection == nullptr) {
429 COMM_LOGI(COMM_SDK, "get connection failed");
430 return NapiGetStringRet(env, deviceId);
431 }
432
433 uint32_t handle = connection->handle_;
434 if (handle == 0) {
435 COMM_LOGI(COMM_SDK, "invalid connection");
436 return NapiGetStringRet(env, deviceId);
437 }
438 char cDeviceId[BT_MAC_LEN] = { 0 };
439 int32_t ret = GeneralGetPeerDeviceId(handle, cDeviceId, BT_MAC_LEN);
440 if (ret != 0) {
441 COMM_LOGI(COMM_SDK, "get peer deviceId failed, handle=%{public}u", connection->handle_);
442 if (ConvertToJsErrcode(ret) == LINK_ENHANCE_PERMISSION_DENIED) {
443 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
444 }
445 return NapiGetStringRet(env, deviceId);
446 }
447 return NapiGetStringRet(env, cDeviceId);
448 }
449
SendData(napi_env env,napi_callback_info info)450 napi_value NapiLinkEnhanceConnection::SendData(napi_env env, napi_callback_info info)
451 {
452 if (!CheckAccessToken()) {
453 HandleSyncErr(env, LINK_ENHANCE_PERMISSION_DENIED);
454 return NapiGetUndefinedRet(env);
455 }
456 size_t argc = ARGS_SIZE_ONE;
457 napi_value args[ARGS_SIZE_ONE] = { 0 };
458 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
459 if (status != napi_ok || argc != ARGS_SIZE_ONE) {
460 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
461 return NapiGetUndefinedRet(env);
462 }
463 NapiLinkEnhanceConnection *connection = NapiGetEnhanceConnection(env, info);
464 if (connection == nullptr) {
465 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
466 return NapiGetUndefinedRet(env);
467 }
468
469 napi_value arrayBuffer = args[ARGS_SIZE_ZERO];
470 if (arrayBuffer == nullptr) {
471 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
472 return NapiGetUndefinedRet(env);
473 }
474
475 void *bufferData;
476 size_t dataLen = 0;
477 status = napi_get_arraybuffer_info(env, arrayBuffer, (void **)&bufferData, &dataLen);
478 if (status != napi_ok || dataLen == 0) {
479 COMM_LOGE(COMM_SDK, "get arraybuffer info failed, dataLen=%{public}zu", dataLen);
480 HandleSyncErr(env, LINK_ENHANCE_PARAMETER_INVALID);
481 return NapiGetUndefinedRet(env);
482 }
483 uint8_t *data = (uint8_t *)SoftBusCalloc(dataLen);
484 if (data == nullptr || memcpy_s(data, dataLen, bufferData, dataLen) != EOK) {
485 SoftBusFree(data);
486 HandleSyncErr(env, LINK_ENHANCE_INTERVAL_ERR);
487 return NapiGetUndefinedRet(env);
488 }
489 COMM_LOGI(COMM_SDK, "call send func handle=%{public}u, len=%{public}u", connection->handle_, (uint32_t)dataLen);
490 int32_t ret = GeneralSend(connection->handle_, data, (uint32_t)dataLen);
491 if (ret != 0) {
492 SoftBusFree(data);
493 int32_t errcode = ConvertToJsErrcode(ret);
494 HandleSyncErr(env, errcode);
495 return NapiGetUndefinedRet(env);
496 }
497 SoftBusFree(data);
498 return NapiGetUndefinedRet(env);
499 }
500
IsConnectResultEnable()501 bool NapiLinkEnhanceConnection::IsConnectResultEnable()
502 {
503 this->lock_.lock();
504 bool isEnableConnectResult = this->isEnableConnectResult_;
505 this->lock_.unlock();
506 return isEnableConnectResult;
507 }
508
IsDataReceiveEnable()509 bool NapiLinkEnhanceConnection::IsDataReceiveEnable()
510 {
511 this->lock_.lock();
512 bool isEnableData = this->isEnableData_;
513 this->lock_.unlock();
514 return isEnableData;
515 }
516
IsDisconnectEnable()517 bool NapiLinkEnhanceConnection::IsDisconnectEnable()
518 {
519 this->lock_.lock();
520 bool isEnableDisconnect = this->isEnableDisconnect_;
521 this->lock_.unlock();
522 return isEnableDisconnect;
523 }
524 } // namespace Softbus
525 } // namespace Communication
526