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