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 "native_c/wifi_p2p.h"
17 #include "wifi_logger.h"
18 #include "native_cpp/wifi_standard/include/wifi_p2p.h"
19 #include "wifi_c_utils.h"
20 #include "wifi_common_util.h"
21
22 constexpr int INVALID_VALUE = -1;
23
24 DEFINE_WIFILOG_LABEL("WifiCP2P");
25 std::unique_ptr<OHOS::Wifi::WifiP2p> wifiP2pPtr = OHOS::Wifi::WifiP2p::GetInstance(WIFI_P2P_ABILITY_ID);
26
EnableP2p()27 WifiErrorCode EnableP2p()
28 {
29 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
30 return GetCErrorCode(wifiP2pPtr->EnableP2p());
31 }
32
DisableP2p()33 WifiErrorCode DisableP2p()
34 {
35 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
36 return GetCErrorCode(wifiP2pPtr->DisableP2p());
37 }
38
GetP2pEnableStatus(P2pState * state)39 WifiErrorCode GetP2pEnableStatus(P2pState* state)
40 {
41 CHECK_PTR_RETURN(state, ERROR_WIFI_INVALID_ARGS);
42 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
43
44 int p2pEnableStatus = INVALID_VALUE;
45 OHOS::Wifi::ErrCode ret = wifiP2pPtr->GetP2pEnableStatus(p2pEnableStatus);
46 *state = P2pState(p2pEnableStatus);
47 return GetCErrorCode(ret);
48 }
49
DiscoverDevices()50 WifiErrorCode DiscoverDevices()
51 {
52 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
53 return GetCErrorCode(wifiP2pPtr->DiscoverDevices());
54 }
55
StopDiscoverDevices()56 WifiErrorCode StopDiscoverDevices()
57 {
58 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
59 return GetCErrorCode(wifiP2pPtr->StopDiscoverDevices());
60 }
61
DiscoverServices()62 WifiErrorCode DiscoverServices()
63 {
64 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
65 return GetCErrorCode(wifiP2pPtr->DiscoverServices());
66 }
67
StopDiscoverServices()68 WifiErrorCode StopDiscoverServices()
69 {
70 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
71 return GetCErrorCode(wifiP2pPtr->StopDiscoverServices());
72 }
73
StartP2pListen(int period,int interval)74 WifiErrorCode StartP2pListen(int period, int interval)
75 {
76 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
77 return GetCErrorCode(wifiP2pPtr->StartP2pListen(period, interval));
78 }
79
StopP2pListen()80 WifiErrorCode StopP2pListen()
81 {
82 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
83 return GetCErrorCode(wifiP2pPtr->StopP2pListen());
84 }
85
ConvertConfigCToCpp(const WifiP2pConfig * config,OHOS::Wifi::WifiP2pConfig & cppConfig)86 static void ConvertConfigCToCpp(const WifiP2pConfig* config, OHOS::Wifi::WifiP2pConfig& cppConfig)
87 {
88 cppConfig.SetDeviceAddress(OHOS::Wifi::MacArrayToStr(config->devAddr));
89 cppConfig.SetGoBand(OHOS::Wifi::GroupOwnerBand(static_cast<int>(config->goBand)));
90 cppConfig.SetNetId(config->netId);
91 cppConfig.SetPassphrase(config->passphrase);
92 cppConfig.SetGroupOwnerIntent(config->groupOwnerIntent);
93 cppConfig.SetGroupName(config->groupName);
94 }
95
CreateGroup(const WifiP2pConfig * config)96 WifiErrorCode CreateGroup(const WifiP2pConfig* config)
97 {
98 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
99 OHOS::Wifi::WifiP2pConfig cppConfig;
100 ConvertConfigCToCpp(config, cppConfig);
101 return GetCErrorCode(wifiP2pPtr->FormGroup(cppConfig));
102 }
103
RemoveGroup()104 WifiErrorCode RemoveGroup()
105 {
106 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
107 return GetCErrorCode(wifiP2pPtr->RemoveGroup());
108 }
109
ConvertP2PDeviceCToCpp(const WifiP2pDevice & p2pDevice,OHOS::Wifi::WifiP2pDevice & cppDevice)110 static void ConvertP2PDeviceCToCpp(const WifiP2pDevice& p2pDevice, OHOS::Wifi::WifiP2pDevice& cppDevice)
111 {
112 cppDevice.SetDeviceName(p2pDevice.deviceName);
113 cppDevice.SetDeviceAddress(OHOS::Wifi::MacArrayToStr(p2pDevice.devAddr));
114 cppDevice.SetPrimaryDeviceType(p2pDevice.primaryDeviceType);
115 cppDevice.SetSecondaryDeviceType(p2pDevice.secondaryDeviceType);
116 cppDevice.SetP2pDeviceStatus(OHOS::Wifi::P2pDeviceStatus(static_cast<int>(p2pDevice.status)));
117
118 OHOS::Wifi::WifiP2pWfdInfo wfdInfo;
119 wfdInfo.SetWfdEnabled((bool)p2pDevice.wfdInfo.wfdEnabled);
120 wfdInfo.SetDeviceInfo(p2pDevice.wfdInfo.deviceInfo);
121 wfdInfo.SetCtrlPort(p2pDevice.wfdInfo.ctrlPort);
122 wfdInfo.SetMaxThroughput(p2pDevice.wfdInfo.maxThroughput);
123 cppDevice.SetWfdInfo(wfdInfo);
124
125 cppDevice.SetWpsConfigMethod(p2pDevice.supportWpsConfigMethods);
126 cppDevice.SetDeviceCapabilitys(p2pDevice.deviceCapabilitys);
127 cppDevice.SetGroupCapabilitys(p2pDevice.groupCapabilitys);
128 }
129
ConvertGroupInfoCToCpp(const WifiP2pGroupInfo * group,OHOS::Wifi::WifiP2pGroupInfo & cppGroup)130 static void ConvertGroupInfoCToCpp(const WifiP2pGroupInfo* group, OHOS::Wifi::WifiP2pGroupInfo& cppGroup)
131 {
132 OHOS::Wifi::WifiP2pDevice owner;
133 ConvertP2PDeviceCToCpp(group->owner, owner);
134 cppGroup.SetOwner(owner);
135 cppGroup.SetIsGroupOwner((bool)group->isP2pGroupOwner);
136 cppGroup.SetPassphrase(group->passphrase);
137 cppGroup.SetInterface(group->interface);
138 cppGroup.SetGroupName(group->groupName);
139 cppGroup.SetNetworkId(group->networkId);
140 cppGroup.SetFrequency(group->frequency);
141 cppGroup.SetIsPersistent((bool)group->isP2pPersistent);
142 cppGroup.SetP2pGroupStatus(OHOS::Wifi::P2pGroupStatus(static_cast<int>(group->groupStatus)));
143 std::vector<OHOS::Wifi::WifiP2pDevice> clientDevices;
144 for (int i = 0; i != group->clientDevicesSize && i < MAX_DEVICES_NUM; ++i) {
145 OHOS::Wifi::WifiP2pDevice p2pDevice;
146 ConvertP2PDeviceCToCpp(group->clientDevices[i], p2pDevice);
147 clientDevices.emplace_back(p2pDevice);
148 }
149 cppGroup.SetClientDevices(clientDevices);
150 cppGroup.SetGoIpAddress(group->goIpAddress);
151 }
152
DeleteGroup(const WifiP2pGroupInfo * group)153 WifiErrorCode DeleteGroup(const WifiP2pGroupInfo* group)
154 {
155 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
156 OHOS::Wifi::WifiP2pGroupInfo groupInfo;
157 ConvertGroupInfoCToCpp(group, groupInfo);
158 return GetCErrorCode(wifiP2pPtr->DeleteGroup(groupInfo));
159 }
160
P2pConnect(const WifiP2pConfig * config)161 WifiErrorCode P2pConnect(const WifiP2pConfig* config)
162 {
163 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
164 OHOS::Wifi::WifiP2pConfig deviceConfig;
165 ConvertConfigCToCpp(config, deviceConfig);
166 return GetCErrorCode(wifiP2pPtr->P2pConnect(deviceConfig));
167 }
168
P2pDisConnect()169 WifiErrorCode P2pDisConnect()
170 {
171 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
172 return GetCErrorCode(wifiP2pPtr->P2pDisConnect());
173 }
174
ConvertP2PDeviceCppToC(const OHOS::Wifi::WifiP2pDevice & cppDevice,WifiP2pDevice * p2pDevice)175 static OHOS::Wifi::ErrCode ConvertP2PDeviceCppToC(const OHOS::Wifi::WifiP2pDevice& cppDevice, WifiP2pDevice* p2pDevice)
176 {
177 if (memcpy_s(p2pDevice->deviceName, P2P_NAME_LENGTH,
178 cppDevice.GetDeviceName().c_str(), cppDevice.GetDeviceName().size() + 1) != EOK) {
179 WIFI_LOGE("memcpy_s device name failed!");
180 return OHOS::Wifi::WIFI_OPT_FAILED;
181 }
182 if (OHOS::Wifi::MacStrToArray(cppDevice.GetDeviceAddress(), p2pDevice->devAddr) != EOK) {
183 WIFI_LOGE("Mac str to array failed!");
184 return OHOS::Wifi::WIFI_OPT_FAILED;
185 }
186 if (memcpy_s(p2pDevice->primaryDeviceType, DEVICE_TYPE_LENGTH,
187 cppDevice.GetPrimaryDeviceType().c_str(), cppDevice.GetPrimaryDeviceType().size() + 1) != EOK) {
188 WIFI_LOGE("memcpy_s primary device type failed!");
189 return OHOS::Wifi::WIFI_OPT_FAILED;
190 }
191 if (memcpy_s(p2pDevice->secondaryDeviceType, DEVICE_TYPE_LENGTH,
192 cppDevice.GetSecondaryDeviceType().c_str(), cppDevice.GetSecondaryDeviceType().size() + 1) != EOK) {
193 WIFI_LOGE("memcpy_s secondary device type failed!");
194 return OHOS::Wifi::WIFI_OPT_FAILED;
195 }
196
197 p2pDevice->status = P2pDeviceStatus(static_cast<int>(cppDevice.GetP2pDeviceStatus()));
198 p2pDevice->wfdInfo.wfdEnabled = cppDevice.GetWfdInfo().GetWfdEnabled();
199 p2pDevice->wfdInfo.deviceInfo = cppDevice.GetWfdInfo().GetDeviceInfo();
200 p2pDevice->wfdInfo.ctrlPort = cppDevice.GetWfdInfo().GetCtrlPort();
201 p2pDevice->wfdInfo.maxThroughput = cppDevice.GetWfdInfo().GetMaxThroughput();
202 p2pDevice->supportWpsConfigMethods = cppDevice.GetWpsConfigMethod();
203 p2pDevice->deviceCapabilitys = cppDevice.GetDeviceCapabilitys();
204 p2pDevice->groupCapabilitys = cppDevice.GetGroupCapabilitys();
205 return OHOS::Wifi::WIFI_OPT_SUCCESS;
206 }
207
ConvertGroupInfoCppToC(const OHOS::Wifi::WifiP2pGroupInfo & cppGroup,WifiP2pGroupInfo * group)208 static OHOS::Wifi::ErrCode ConvertGroupInfoCppToC(const OHOS::Wifi::WifiP2pGroupInfo& cppGroup, WifiP2pGroupInfo* group)
209 {
210 if (ConvertP2PDeviceCppToC(cppGroup.GetOwner(), &group->owner) != OHOS::Wifi::WIFI_OPT_SUCCESS) {
211 return OHOS::Wifi::WIFI_OPT_FAILED;
212 }
213 group->isP2pGroupOwner = cppGroup.IsGroupOwner();
214 if (memcpy_s(group->passphrase, PASSPHRASE_LENGTH,
215 cppGroup.GetPassphrase().c_str(), cppGroup.GetPassphrase().size() + 1) != EOK) {
216 WIFI_LOGE("memcpy_s passphrase failed!");
217 return OHOS::Wifi::WIFI_OPT_FAILED;
218 }
219 if (memcpy_s(group->interface, INTERFACE_LENGTH,
220 cppGroup.GetInterface().c_str(), cppGroup.GetInterface().size() + 1) != EOK) {
221 WIFI_LOGE("memcpy_s interface failed!");
222 return OHOS::Wifi::WIFI_OPT_FAILED;
223 }
224 if (memcpy_s(group->groupName, P2P_NAME_LENGTH,
225 cppGroup.GetGroupName().c_str(), cppGroup.GetGroupName().size() + 1) != EOK) {
226 WIFI_LOGE("memcpy_s group name failed!");
227 return OHOS::Wifi::WIFI_OPT_FAILED;
228 }
229 group->networkId = cppGroup.GetNetworkId();
230 group->frequency = cppGroup.GetFrequency();
231 group->isP2pPersistent = cppGroup.IsPersistent();
232 group->groupStatus = P2pGroupStatus(static_cast<int>(cppGroup.GetP2pGroupStatus()));
233 const std::vector<OHOS::Wifi::WifiP2pDevice>& vecDevices = cppGroup.GetClientDevices();
234 for (size_t i = 0; i != vecDevices.size() && i < MAX_DEVICES_NUM; ++i) {
235 if (ConvertP2PDeviceCppToC(vecDevices[i], &group->clientDevices[i]) != OHOS::Wifi::WIFI_OPT_SUCCESS) {
236 WIFI_LOGE("convert p2p device failed!");
237 return OHOS::Wifi::WIFI_OPT_FAILED;
238 }
239 }
240 group->clientDevicesSize = (int)vecDevices.size();
241 if (memcpy_s(group->goIpAddress, IP_ADDR_STR_LEN,
242 cppGroup.GetGoIpAddress().c_str(), cppGroup.GetGoIpAddress().size() + 1) != EOK) {
243 WIFI_LOGE("memcpy_s interface failed!");
244 return OHOS::Wifi::WIFI_OPT_FAILED;
245 }
246 return OHOS::Wifi::WIFI_OPT_SUCCESS;
247 }
248
GetCurrentGroup(WifiP2pGroupInfo * groupInfo)249 WifiErrorCode GetCurrentGroup(WifiP2pGroupInfo* groupInfo)
250 {
251 if (groupInfo == nullptr) {
252 WIFI_LOGE("get current group input args is null!");
253 return ERROR_WIFI_INVALID_ARGS;
254 }
255
256 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
257 OHOS::Wifi::WifiP2pGroupInfo cppGroupInfo;
258 OHOS::Wifi::ErrCode ret = wifiP2pPtr->GetCurrentGroup(cppGroupInfo);
259 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
260 WIFI_LOGE("get current group info failed!");
261 return ERROR_WIFI_NOT_AVAILABLE;
262 }
263 return GetCErrorCode(ConvertGroupInfoCppToC(cppGroupInfo, groupInfo));
264 }
265
GetP2pConnectedStatus(int * status)266 WifiErrorCode GetP2pConnectedStatus(int* status)
267 {
268 if (status == nullptr) {
269 WIFI_LOGE("input args is null!");
270 return ERROR_WIFI_INVALID_ARGS;
271 }
272
273 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
274 int p2pStatus = -1;
275 OHOS::Wifi::ErrCode ret = wifiP2pPtr->GetP2pConnectedStatus(p2pStatus);
276 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
277 WIFI_LOGE("get p2p status failed!");
278 }
279 *status = p2pStatus;
280 return GetCErrorCode(ret);
281 }
282
QueryP2pDevices(WifiP2pDevice * clientDevices,int size,int * retSize)283 WifiErrorCode QueryP2pDevices(WifiP2pDevice* clientDevices, int size, int* retSize)
284 {
285 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
286 std::vector<OHOS::Wifi::WifiP2pDevice> vecDevices;
287 OHOS::Wifi::ErrCode ret = wifiP2pPtr->QueryP2pDevices(vecDevices);
288 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
289 WIFI_LOGE("query p2p devices failed!");
290 return ERROR_WIFI_UNKNOWN;
291 }
292
293 for (int i = 0; i != (int)vecDevices.size() && i < size; ++i) {
294 if (ConvertP2PDeviceCppToC(vecDevices[i], clientDevices++) != OHOS::Wifi::WIFI_OPT_SUCCESS) {
295 WIFI_LOGE("convert p2p device failed!");
296 return ERROR_WIFI_UNKNOWN;
297 }
298 }
299 *retSize = std::min(size, (int)vecDevices.size());
300 return WIFI_SUCCESS;
301 }
302
QueryP2pGroups(WifiP2pGroupInfo * groupInfo,int size)303 WifiErrorCode QueryP2pGroups(WifiP2pGroupInfo* groupInfo, int size)
304 {
305 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
306 std::vector<OHOS::Wifi::WifiP2pGroupInfo> groups;
307 OHOS::Wifi::ErrCode ret = wifiP2pPtr->QueryP2pGroups(groups);
308 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
309 WIFI_LOGE("query p2p devices failed!");
310 return ERROR_WIFI_UNKNOWN;
311 }
312
313 for (int i = 0; i != (int)groups.size() && i < size; ++i) {
314 ret = ConvertGroupInfoCppToC(groups[i], groupInfo++);
315 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
316 WIFI_LOGE("convert group info failed!");
317 return ERROR_WIFI_UNKNOWN;
318 }
319 }
320 return WIFI_SUCCESS;
321 }
322
323 class WifiP2pCEventCallback : public OHOS::Wifi::IWifiP2pCallback {
324 public:
OnP2pStateChanged(int state)325 void OnP2pStateChanged(int state) override {
326 WIFI_LOGI("received state changed event: %{public}d", state);
327 if (stateChangeCb != nullptr) {
328 stateChangeCb(P2pState(state));
329 }
330 }
331
OnP2pPersistentGroupsChanged(void)332 void OnP2pPersistentGroupsChanged(void) override {
333 WIFI_LOGI("received group changed event");
334 if (groupChangeCb != nullptr) {
335 groupChangeCb();
336 }
337 }
338
OnP2pThisDeviceChanged(const OHOS::Wifi::WifiP2pDevice & device)339 void OnP2pThisDeviceChanged(const OHOS::Wifi::WifiP2pDevice &device) override {
340 }
341
OnP2pPeersChanged(const std::vector<OHOS::Wifi::WifiP2pDevice> & devices)342 void OnP2pPeersChanged(const std::vector<OHOS::Wifi::WifiP2pDevice> &devices) override {
343 WIFI_LOGI("received peers changed event: %{public}d", (int)devices.size());
344 WifiP2pDevice *devicePtr = nullptr;
345 if (!devices.empty()) {
346 devicePtr = new WifiP2pDevice[(int)devices.size()];
347 }
348 WifiP2pDevice *p = devicePtr;
349 for (auto& each : devices) {
350 if (ConvertP2PDeviceCppToC(each, p++) != OHOS::Wifi::WIFI_OPT_SUCCESS) {
351 WIFI_LOGE("peers changed convert p2p device failed!");
352 return;
353 }
354 }
355 if (peersChangeCb != nullptr) {
356 peersChangeCb(devicePtr, (int)devices.size());
357 }
358 if (devicePtr != nullptr) {
359 delete[] devicePtr;
360 devicePtr = nullptr;
361 }
362 }
363
OnP2pServicesChanged(const std::vector<OHOS::Wifi::WifiP2pServiceInfo> & srvInfo)364 void OnP2pServicesChanged(const std::vector<OHOS::Wifi::WifiP2pServiceInfo> &srvInfo) override {
365 }
366
OnP2pConnectionChanged(const OHOS::Wifi::WifiP2pLinkedInfo & info)367 void OnP2pConnectionChanged(const OHOS::Wifi::WifiP2pLinkedInfo &info) override {
368 WIFI_LOGI("received connection changed event");
369 if (connectionChangeCb != nullptr) {
370 connectionChangeCb(ConvertP2pLinkedInfo(info));
371 }
372 }
373
OnP2pDiscoveryChanged(bool isChange)374 void OnP2pDiscoveryChanged(bool isChange) override {
375 }
376
OnP2pActionResult(OHOS::Wifi::P2pActionCallback action,OHOS::Wifi::ErrCode code)377 void OnP2pActionResult(OHOS::Wifi::P2pActionCallback action, OHOS::Wifi::ErrCode code) override {
378 }
379
AsObject()380 OHOS::sptr<OHOS::IRemoteObject> AsObject() override {
381 return nullptr;
382 }
383
384 public:
WifiP2pCEventCallback()385 WifiP2pCEventCallback() {
386 stateChangeCb = nullptr;
387 groupChangeCb = nullptr;
388 connectionChangeCb = nullptr;
389 peersChangeCb = nullptr;
390 }
391
~WifiP2pCEventCallback()392 virtual ~WifiP2pCEventCallback() {
393 }
394
395 public:
396 P2pStateChangedCallback stateChangeCb;
397 P2pPersistentGroupsChangedCallback groupChangeCb;
398 P2pConnectionChangedCallback connectionChangeCb;
399 P2pPeersChangedCallback peersChangeCb;
400
401 private:
ConvertP2pLinkedInfo(const OHOS::Wifi::WifiP2pLinkedInfo & linkedInfo)402 WifiP2pLinkedInfo ConvertP2pLinkedInfo(const OHOS::Wifi::WifiP2pLinkedInfo& linkedInfo) {
403 WifiP2pLinkedInfo info;
404 info.connectState = P2pConnectionState(static_cast<int>(linkedInfo.GetConnectState()));
405 info.isP2pGroupOwner = linkedInfo.IsGroupOwner();
406 OHOS::Wifi::MacStrToArray(linkedInfo.GetGroupOwnerAddress(), info.groupOwnerAddress);
407 return info;
408 }
409 };
410
411 OHOS::sptr<WifiP2pCEventCallback> sptrCallback =
412 OHOS::sptr<WifiP2pCEventCallback>(new (std::nothrow) WifiP2pCEventCallback());
413
RegisterP2pStateChangedCallback(const P2pStateChangedCallback callback)414 WifiErrorCode RegisterP2pStateChangedCallback(const P2pStateChangedCallback callback)
415 {
416 CHECK_PTR_RETURN(callback, ERROR_WIFI_INVALID_ARGS);
417 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
418 sptrCallback->stateChangeCb = callback;
419 wifiP2pPtr->RegisterCallBack(sptrCallback);
420 return WIFI_SUCCESS;
421 }
422
RegisterP2pPersistentGroupsChangedCallback(const P2pPersistentGroupsChangedCallback callback)423 WifiErrorCode RegisterP2pPersistentGroupsChangedCallback(const P2pPersistentGroupsChangedCallback callback)
424 {
425 CHECK_PTR_RETURN(callback, ERROR_WIFI_INVALID_ARGS);
426 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
427 sptrCallback->groupChangeCb = callback;
428 wifiP2pPtr->RegisterCallBack(sptrCallback);
429 return WIFI_SUCCESS;
430 }
431
RegisterP2pConnectionChangedCallback(const P2pConnectionChangedCallback callback)432 WifiErrorCode RegisterP2pConnectionChangedCallback(const P2pConnectionChangedCallback callback)
433 {
434 CHECK_PTR_RETURN(callback, ERROR_WIFI_INVALID_ARGS);
435 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
436 sptrCallback->connectionChangeCb = callback;
437 wifiP2pPtr->RegisterCallBack(sptrCallback);
438 return WIFI_SUCCESS;
439 }
440
RegisterP2pPeersChangedCallback(const P2pPeersChangedCallback callback)441 WifiErrorCode RegisterP2pPeersChangedCallback(const P2pPeersChangedCallback callback)
442 {
443 CHECK_PTR_RETURN(callback, ERROR_WIFI_INVALID_ARGS);
444 CHECK_PTR_RETURN(wifiP2pPtr, ERROR_WIFI_NOT_AVAILABLE);
445 sptrCallback->peersChangeCb = callback;
446 wifiP2pPtr->RegisterCallBack(sptrCallback);
447 return WIFI_SUCCESS;
448 }
449