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 "wifi_napi_p2p.h"
17 #include "wifi_logger.h"
18 #include "wifi_napi_errcode.h"
19
20 namespace OHOS {
21 namespace Wifi {
22 DEFINE_WIFILOG_LABEL("WifiNAPIP2p");
23
24 std::unique_ptr<WifiP2p> wifiP2pPtr = WifiP2p::GetInstance(WIFI_P2P_ABILITY_ID);
DeviceInfoToJs(const napi_env & env,const WifiP2pDevice & device,napi_value & result)25 static void DeviceInfoToJs(const napi_env& env, const WifiP2pDevice& device, napi_value& result)
26 {
27 SetValueUtf8String(env, "deviceName", device.GetDeviceName().c_str(), result);
28 SetValueUtf8String(env, "deviceAddress", device.GetDeviceAddress().c_str(), result);
29 SetValueInt32(env, "deviceAddressType", device.GetDeviceAddressType(), result);
30 SetValueUtf8String(env, "primaryDeviceType", device.GetPrimaryDeviceType().c_str(), result);
31 SetValueInt32(env, "deviceStatus", static_cast<int>(device.GetP2pDeviceStatus()), result);
32 SetValueInt32(env, "groupCapabilitys", device.GetGroupCapabilitys(), result);
33 }
34
DevicesToJsArray(const napi_env & env,const std::vector<WifiP2pDevice> & vecDevices,napi_value & arrayResult)35 static ErrCode DevicesToJsArray(const napi_env& env,
36 const std::vector<WifiP2pDevice>& vecDevices, napi_value& arrayResult)
37 {
38 uint32_t idx = 0;
39 for (auto& each : vecDevices) {
40 napi_value eachObj;
41 napi_create_object(env, &eachObj);
42 DeviceInfoToJs(env, each, eachObj);
43 napi_status status = napi_set_element(env, arrayResult, idx++, eachObj);
44 if (status != napi_ok) {
45 WIFI_LOGE("wifi napi set element error: %{public}d, idx: %{public}d", status, idx - 1);
46 return WIFI_OPT_FAILED;
47 }
48 }
49 return WIFI_OPT_SUCCESS;
50 }
51
GroupInfosToJs(const napi_env & env,const WifiP2pGroupInfo & groupInfo,napi_value & result)52 static ErrCode GroupInfosToJs(const napi_env& env, const WifiP2pGroupInfo& groupInfo, napi_value& result)
53 {
54 SetValueBool(env, "isP2pGo", groupInfo.IsGroupOwner(), result);
55
56 WifiP2pDevice ownerDevice = groupInfo.GetOwner();
57 napi_value owner;
58 napi_create_object(env, &owner);
59 DeviceInfoToJs(env, ownerDevice, owner);
60 napi_status status = napi_set_named_property(env, result, "ownerInfo", owner);
61 if (status != napi_ok) {
62 WIFI_LOGE("napi_set_named_property ownerInfo fail");
63 return WIFI_OPT_FAILED;
64 }
65
66 SetValueUtf8String(env, "passphrase", groupInfo.GetPassphrase().c_str(), result);
67 SetValueUtf8String(env, "interface", groupInfo.GetInterface().c_str(), result);
68 SetValueUtf8String(env, "groupName", groupInfo.GetGroupName().c_str(), result);
69 SetValueInt32(env, "networkId", groupInfo.GetNetworkId(), result);
70 SetValueInt32(env, "frequency", groupInfo.GetFrequency(), result);
71
72 if (!groupInfo.IsClientDevicesEmpty()) {
73 const std::vector<OHOS::Wifi::WifiP2pDevice>& vecDevices = groupInfo.GetClientDevices();
74 napi_value devices;
75 napi_create_array_with_length(env, vecDevices.size(), &devices);
76 if (DevicesToJsArray(env, vecDevices, devices) != WIFI_OPT_SUCCESS) {
77 return WIFI_OPT_FAILED;
78 }
79 status = napi_set_named_property(env, result, "clientDevices", devices);
80 if (status != napi_ok) {
81 WIFI_LOGE("napi_set_named_property clientDevices fail");
82 return WIFI_OPT_FAILED;
83 }
84 }
85 SetValueUtf8String(env, "goIpAddress", groupInfo.GetGoIpAddress().c_str(), result);
86 return WIFI_OPT_SUCCESS;
87 }
88
GroupsToJsArray(const napi_env & env,const std::vector<WifiP2pGroupInfo> & vecGroups,napi_value & arrayResult)89 static ErrCode GroupsToJsArray(const napi_env& env,
90 const std::vector<WifiP2pGroupInfo>& vecGroups, napi_value& arrayResult)
91 {
92 uint32_t idx = 0;
93 for (auto& each : vecGroups) {
94 napi_value eachObj;
95 napi_create_object(env, &eachObj);
96 int ret = GroupInfosToJs(env, each, eachObj);
97 if (ret != WIFI_OPT_SUCCESS) {
98 return WIFI_OPT_FAILED;
99 }
100 napi_status status = napi_set_element(env, arrayResult, idx++, eachObj);
101 if (status != napi_ok) {
102 WIFI_LOGE("wifi napi set element error: %{public}d, idx: %{public}d", status, idx - 1);
103 return WIFI_OPT_FAILED;
104 }
105 }
106 return WIFI_OPT_SUCCESS;
107 }
108
GetCurrentGroup(napi_env env,napi_callback_info info)109 NO_SANITIZE("cfi") napi_value GetCurrentGroup(napi_env env, napi_callback_info info)
110 {
111 TRACE_FUNC_CALL;
112 size_t argc = 1;
113 napi_value argv[argc];
114 napi_value thisVar = nullptr;
115 void *data = nullptr;
116 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data));
117 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
118
119 P2pGroupInfoAsyncContext *asyncContext = new P2pGroupInfoAsyncContext(env);
120 WIFI_NAPI_ASSERT(env, asyncContext != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
121 napi_create_string_latin1(env, "getCurrentGroup", NAPI_AUTO_LENGTH, &asyncContext->resourceName);
122
123 asyncContext->executeFunc = [&](void* data) -> void {
124 P2pGroupInfoAsyncContext *context = static_cast<P2pGroupInfoAsyncContext *>(data);
125 TRACE_FUNC_CALL_NAME("wifiP2pPtr->GetCurrentGroup");
126 context->errorCode = wifiP2pPtr->GetCurrentGroup(context->groupInfo);
127 };
128
129 asyncContext->completeFunc = [&](void* data) -> void {
130 P2pGroupInfoAsyncContext *context = static_cast<P2pGroupInfoAsyncContext *>(data);
131 napi_create_object(context->env, &context->result);
132 if (context->errorCode == WIFI_OPT_SUCCESS) {
133 context->errorCode = GroupInfosToJs(context->env, context->groupInfo, context->result);
134 }
135 WIFI_LOGI("Push get current group result to client");
136 };
137
138 size_t nonCallbackArgNum = 0;
139 asyncContext->sysCap = SYSCAP_WIFI_P2P;
140 return DoAsyncWork(env, asyncContext, argc, argv, nonCallbackArgNum);
141 }
142
GetP2pGroups(napi_env env,napi_callback_info info)143 NO_SANITIZE("cfi") napi_value GetP2pGroups(napi_env env, napi_callback_info info)
144 {
145 TRACE_FUNC_CALL;
146 size_t argc = 1;
147 napi_value argv[argc];
148 napi_value thisVar = nullptr;
149 void *data = nullptr;
150 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data));
151 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
152
153 P2pGroupInfoListAsyncContext *asyncContext = new P2pGroupInfoListAsyncContext(env);
154 WIFI_NAPI_ASSERT(env, asyncContext != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
155 napi_create_string_latin1(env, "GetP2pGroups", NAPI_AUTO_LENGTH, &asyncContext->resourceName);
156
157 asyncContext->executeFunc = [&](void* data) -> void {
158 P2pGroupInfoListAsyncContext *context = static_cast<P2pGroupInfoListAsyncContext *>(data);
159 TRACE_FUNC_CALL_NAME("wifiP2pPtr->QueryP2pGroups");
160 context->errorCode = wifiP2pPtr->QueryP2pGroups(context->vecGroupInfoList);
161 };
162
163 asyncContext->completeFunc = [&](void* data) -> void {
164 P2pGroupInfoListAsyncContext *context = static_cast<P2pGroupInfoListAsyncContext *>(data);
165 napi_create_array_with_length(context->env, context->vecGroupInfoList.size(), &context->result);
166 if (context->errorCode == WIFI_OPT_SUCCESS) {
167 context->errorCode = GroupsToJsArray(context->env, context->vecGroupInfoList, context->result);
168 }
169 WIFI_LOGI("Push get group info list to client");
170 };
171
172 size_t nonCallbackArgNum = 0;
173 asyncContext->sysCap = SYSCAP_WIFI_P2P;
174 return DoAsyncWork(env, asyncContext, argc, argv, nonCallbackArgNum);
175 }
176
DeletePersistentGroup(napi_env env,napi_callback_info info)177 NO_SANITIZE("cfi") napi_value DeletePersistentGroup(napi_env env, napi_callback_info info)
178 {
179 TRACE_FUNC_CALL;
180 size_t argc = 1;
181 napi_value argv[argc];
182 napi_value thisVar;
183 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
184 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
185
186 napi_valuetype valueType;
187 napi_typeof(env, argv[0], &valueType);
188 WIFI_NAPI_ASSERT(env, valueType == napi_number, WIFI_OPT_INVALID_PARAM, SYSCAP_WIFI_P2P);
189
190 WifiP2pGroupInfo groupInfo;
191 int netId = -999;
192 napi_get_value_int32(env, argv[0], &netId);
193 groupInfo.SetNetworkId(netId);
194 ErrCode ret = wifiP2pPtr->DeleteGroup(groupInfo);
195 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
196 }
197
StartDiscoverDevices(napi_env env,napi_callback_info info)198 NO_SANITIZE("cfi") napi_value StartDiscoverDevices(napi_env env, napi_callback_info info)
199 {
200 TRACE_FUNC_CALL;
201 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
202
203 ErrCode ret = wifiP2pPtr->DiscoverDevices();
204 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
205 }
206
StopDiscoverDevices(napi_env env,napi_callback_info info)207 NO_SANITIZE("cfi") napi_value StopDiscoverDevices(napi_env env, napi_callback_info info)
208 {
209 TRACE_FUNC_CALL;
210 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
211
212 ErrCode ret = wifiP2pPtr->StopDiscoverDevices();
213 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
214 }
215
GetP2pDevices(napi_env env,napi_callback_info info)216 NO_SANITIZE("cfi") napi_value GetP2pDevices(napi_env env, napi_callback_info info)
217 {
218 size_t argc = 1;
219 napi_value argv[argc];
220 napi_value thisVar = nullptr;
221 void *data = nullptr;
222 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data));
223 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
224
225 QueryP2pDeviceAsyncContext *asyncContext = new QueryP2pDeviceAsyncContext(env);
226 WIFI_NAPI_ASSERT(env, asyncContext != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
227 napi_create_string_latin1(env, "GetP2pDevices", NAPI_AUTO_LENGTH, &asyncContext->resourceName);
228
229 asyncContext->executeFunc = [&](void* data) -> void {
230 QueryP2pDeviceAsyncContext *context = static_cast<QueryP2pDeviceAsyncContext *>(data);
231 context->errorCode = wifiP2pPtr->QueryP2pDevices(context->vecP2pDevices);
232 WIFI_LOGI("GetP2pDeviceList, size: %{public}zu", context->vecP2pDevices.size());
233 };
234
235 asyncContext->completeFunc = [&](void* data) -> void {
236 QueryP2pDeviceAsyncContext *context = static_cast<QueryP2pDeviceAsyncContext *>(data);
237 napi_create_array_with_length(context->env, context->vecP2pDevices.size(), &context->result);
238 if (context->errorCode == WIFI_OPT_SUCCESS) {
239 context->errorCode = DevicesToJsArray(context->env, context->vecP2pDevices, context->result);
240 }
241 WIFI_LOGI("Push P2p Device List to client");
242 };
243
244 size_t nonCallbackArgNum = 0;
245 asyncContext->sysCap = SYSCAP_WIFI_P2P;
246 return DoAsyncWork(env, asyncContext, argc, argv, nonCallbackArgNum);
247 }
248
GetP2pLocalDevice(napi_env env,napi_callback_info info)249 NO_SANITIZE("cfi") napi_value GetP2pLocalDevice(napi_env env, napi_callback_info info)
250 {
251 TRACE_FUNC_CALL;
252 size_t argc = 1;
253 napi_value argv[argc];
254 napi_value thisVar = nullptr;
255 void *data = nullptr;
256 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data));
257 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
258
259 P2pLocalDeviceAsyncContext *asyncContext = new P2pLocalDeviceAsyncContext(env);
260 WIFI_NAPI_ASSERT(env, asyncContext != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
261 napi_create_string_latin1(env, "GetP2pLocalDevice", NAPI_AUTO_LENGTH, &asyncContext->resourceName);
262
263 asyncContext->executeFunc = [&](void* data) -> void {
264 P2pLocalDeviceAsyncContext *context = static_cast<P2pLocalDeviceAsyncContext *>(data);
265 TRACE_FUNC_CALL_NAME("wifiP2pPtr->QueryP2pLocalDevice");
266 context->errorCode = wifiP2pPtr->QueryP2pLocalDevice(context->deviceInfo);
267 };
268
269 asyncContext->completeFunc = [&](void* data) -> void {
270 P2pLocalDeviceAsyncContext *context = static_cast<P2pLocalDeviceAsyncContext *>(data);
271 napi_create_object(context->env, &context->result);
272 if (context->errorCode == WIFI_OPT_SUCCESS) {
273 DeviceInfoToJs(context->env, context->deviceInfo, context->result);
274 }
275 WIFI_LOGI("Push get p2p local device result to client");
276 };
277
278 size_t nonCallbackArgNum = 0;
279 asyncContext->sysCap = SYSCAP_WIFI_P2P;
280 return DoAsyncWork(env, asyncContext, argc, argv, nonCallbackArgNum);
281 }
282
SetDeviceName(napi_env env,napi_callback_info info)283 NO_SANITIZE("cfi") napi_value SetDeviceName(napi_env env, napi_callback_info info)
284 {
285 TRACE_FUNC_CALL;
286 size_t argc = 1;
287 napi_value argv[1];
288 napi_value thisVar;
289 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
290 WIFI_NAPI_ASSERT(env, argc == 1, WIFI_OPT_INVALID_PARAM, SYSCAP_WIFI_P2P);
291 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
292
293 napi_valuetype valueType;
294 napi_typeof(env, argv[0], &valueType);
295 WIFI_NAPI_ASSERT(env, valueType == napi_string, WIFI_OPT_INVALID_PARAM, SYSCAP_WIFI_P2P);
296
297 char name[64] = {0};
298 size_t typeLen = 0;
299 napi_get_value_string_utf8(env, argv[0], name, sizeof(name), &typeLen);
300 ErrCode ret = wifiP2pPtr->SetP2pDeviceName(name);
301 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
302 }
303
JsObjToP2pConfig(const napi_env & env,const napi_value & object,WifiP2pConfig & config)304 static void JsObjToP2pConfig(const napi_env& env, const napi_value& object, WifiP2pConfig& config)
305 {
306 std::string address = "";
307 int bssidType = RANDOM_DEVICE_ADDRESS;
308 int netId = -1;
309 std::string passphrase = "";
310 std::string groupName = "";
311 int band = static_cast<int>(GroupOwnerBand::GO_BAND_AUTO);
312 JsObjectToString(env, object, "deviceAddress", WIFI_STR_MAC_LENGTH + 1, address);
313 JsObjectToInt(env, object, "deviceAddressType", bssidType);
314 WIFI_LOGI("JsObjToP2pConfig, bssid length: %{public}d, bssidType: %{public}d",
315 static_cast<int>(address.length()), bssidType);
316 JsObjectToInt(env, object, "netId", netId);
317 JsObjectToString(env, object, "passphrase", MAX_PASSPHRASE_LENGTH + 1, passphrase);
318 JsObjectToString(env, object, "groupName", DEVICE_NAME_LENGTH + 1, groupName);
319 JsObjectToInt(env, object, "goBand", band);
320 config.SetDeviceAddress(address);
321 config.SetDeviceAddressType(bssidType);
322 config.SetNetId(netId);
323 config.SetPassphrase(passphrase);
324 config.SetGroupName(groupName);
325 config.SetGoBand(static_cast<GroupOwnerBand>(band));
326 }
327
P2pConnect(napi_env env,napi_callback_info info)328 NO_SANITIZE("cfi") napi_value P2pConnect(napi_env env, napi_callback_info info)
329 {
330 TRACE_FUNC_CALL;
331 size_t argc = 1;
332 napi_value argv[argc];
333 napi_value thisVar;
334 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
335 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
336
337 napi_valuetype valueType;
338 napi_typeof(env, argv[0], &valueType);
339 WIFI_NAPI_ASSERT(env, valueType == napi_object, WIFI_OPT_INVALID_PARAM, SYSCAP_WIFI_P2P);
340
341 WifiP2pConfig config;
342 JsObjToP2pConfig(env, argv[0], config);
343 ErrCode ret = wifiP2pPtr->P2pConnect(config);
344 if (ret != WIFI_OPT_SUCCESS) {
345 WIFI_LOGE("Connect to device fail: %{public}d", ret);
346 }
347 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
348 }
349
P2pCancelConnect(napi_env env,napi_callback_info info)350 napi_value P2pCancelConnect(napi_env env, napi_callback_info info)
351 {
352 TRACE_FUNC_CALL;
353 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
354 ErrCode ret = wifiP2pPtr->P2pCancelConnect();
355 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
356 }
357
CreateGroup(napi_env env,napi_callback_info info)358 NO_SANITIZE("cfi") napi_value CreateGroup(napi_env env, napi_callback_info info)
359 {
360 TRACE_FUNC_CALL;
361 size_t argc = 1;
362 napi_value argv[1];
363 napi_value thisVar;
364 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
365 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
366
367 napi_valuetype valueType;
368 napi_typeof(env, argv[0], &valueType);
369 WIFI_NAPI_ASSERT(env, valueType == napi_object, WIFI_OPT_INVALID_PARAM, SYSCAP_WIFI_P2P);
370
371 WifiP2pConfig config;
372 JsObjToP2pConfig(env, argv[0], config);
373 ErrCode ret = wifiP2pPtr->CreateGroup(config);
374 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
375 }
376
RemoveGroup(napi_env env,napi_callback_info info)377 NO_SANITIZE("cfi") napi_value RemoveGroup(napi_env env, napi_callback_info info)
378 {
379 TRACE_FUNC_CALL;
380 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
381 ErrCode ret = wifiP2pPtr->RemoveGroup();
382 WIFI_NAPI_RETURN(env, ret == WIFI_OPT_SUCCESS, ret, SYSCAP_WIFI_P2P);
383 }
384
LinkedInfoToJs(const napi_env & env,WifiP2pLinkedInfo & linkedInfo,napi_value & result)385 static void LinkedInfoToJs(const napi_env& env, WifiP2pLinkedInfo& linkedInfo, napi_value& result)
386 {
387 SetValueInt32(env, "connectState", static_cast<int>(linkedInfo.GetConnectState()), result);
388 SetValueBool(env, "isGroupOwner", linkedInfo.IsGroupOwner(), result);
389 SetValueUtf8String(env, "groupOwnerAddr", linkedInfo.GetGroupOwnerAddress().c_str(), result);
390 }
391
GetP2pLinkedInfo(napi_env env,napi_callback_info info)392 NO_SANITIZE("cfi") napi_value GetP2pLinkedInfo(napi_env env, napi_callback_info info)
393 {
394 TRACE_FUNC_CALL;
395 size_t argc = 1;
396 napi_value argv[argc];
397 napi_value thisVar = nullptr;
398 void *data = nullptr;
399 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data));
400 WIFI_NAPI_ASSERT(env, wifiP2pPtr != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
401
402 P2pLinkedInfoAsyncContext *asyncContext = new P2pLinkedInfoAsyncContext(env);
403 WIFI_NAPI_ASSERT(env, asyncContext != nullptr, WIFI_OPT_FAILED, SYSCAP_WIFI_P2P);
404 napi_create_string_latin1(env, "queryP2pLinkedInfo", NAPI_AUTO_LENGTH, &asyncContext->resourceName);
405
406 asyncContext->executeFunc = [&](void* data) -> void {
407 P2pLinkedInfoAsyncContext *context = static_cast<P2pLinkedInfoAsyncContext *>(data);
408 TRACE_FUNC_CALL_NAME("wifiP2pPtr->QueryP2pLinkedInfo");
409 context->errorCode = wifiP2pPtr->QueryP2pLinkedInfo(context->linkedInfo);
410 };
411
412 asyncContext->completeFunc = [&](void* data) -> void {
413 P2pLinkedInfoAsyncContext *context = static_cast<P2pLinkedInfoAsyncContext *>(data);
414 napi_create_object(context->env, &context->result);
415 if (context->errorCode == WIFI_OPT_SUCCESS) {
416 LinkedInfoToJs(context->env, context->linkedInfo, context->result);
417 }
418 WIFI_LOGI("Push get linkedInfo result to client");
419 };
420
421 size_t nonCallbackArgNum = 0;
422 asyncContext->sysCap = SYSCAP_WIFI_P2P;
423 return DoAsyncWork(env, asyncContext, argc, argv, nonCallbackArgNum);
424 }
425 } // namespace Wifi
426 } // namespace OHOS
427