• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef OHOS_WIFI_IDL_CLIENT_H
17 #define OHOS_WIFI_IDL_CLIENT_H
18 
19 #include <string>
20 #include <vector>
21 #include "wifi_msg.h"
22 #include "wifi_internal_msg.h"
23 #include "wifi_error_no.h"
24 #include "supplicant_event_callback.h"
25 #include "wifi_chip_event_callback.h"
26 #include "wifi_event_callback.h"
27 #include "wifi_ap_event_callback.h"
28 #include "wifi_p2p_event_callback.h"
29 #include "wifi_scan_param.h"
30 #include "wifi_sta_request.h"
31 #include "client.h"
32 #include "i_wifi_chip.h"
33 #include "i_wifi_hotspot_iface.h"
34 #include "i_wifi_struct.h"
35 #include "wifi_global_func.h"
36 #include "wifi_hid2d_msg.h"
37 
38 namespace OHOS {
39 namespace Wifi {
40 class WifiIdlClient {
41 public:
42     /**
43      * @Description Construct a new Wifi Idl Client object.
44      *
45      */
46     WifiIdlClient();
47     /**
48      * @Description Destroy the Wifi Idl Client object.
49      *
50      */
51     ~WifiIdlClient();
52 
53     /**
54      * @Description Init Client.
55      *
56      * @return int - 0 Success, -1 Failed.
57      */
58     int InitClient(void);
59     /**
60      * @Description Exit All Client.
61      *
62      */
63     void ExitAllClient(void);
64     /* ************************ Sta Interface ************************** */
65 
66     /**
67      * @Description Open Wifi.
68      *
69      * @return WifiErrorNo
70      */
71     WifiErrorNo StartWifi(void);
72 
73     /**
74      * @Description Close Wifi.
75      *
76      * @return WifiErrorNo
77      */
78     WifiErrorNo StopWifi(void);
79 
80     /**
81      * @Description Connect Wifi.
82      *
83      * @param networkId
84      * @return WifiErrorNo
85      */
86     WifiErrorNo ReqConnect(int networkId);
87 
88     /**
89      * @Description Reconnect Wifi.
90      *
91      * @return WifiErrorNo
92      */
93     WifiErrorNo ReqReconnect(void);
94 
95     /**
96      * @Description Reassociate Wifi.
97      *
98      * @return WifiErrorNo
99      */
100     WifiErrorNo ReqReassociate(void);
101 
102     /**
103      * @Description Disconnect Wifi.
104      *
105      * @return WifiErrorNo
106      */
107     WifiErrorNo ReqDisconnect(void);
108 
109     /**
110      * @Description Obtaining the STA Support Capability.
111      *
112      * @param capabilities
113      * @return WifiErrorNo
114      */
115     WifiErrorNo GetStaCapabilities(unsigned int &capabilities);
116 
117     /**
118      * @Description Obtaining the MAC Address of a STA.
119      *
120      * @param mac
121      * @return WifiErrorNo
122      */
123     WifiErrorNo GetStaDeviceMacAddress(std::string &mac);
124 
125     /**
126      * @Description Obtains the frequencies supported by a specified
127      *              frequency band.
128      *
129      * @param band
130      * @param frequencies
131      * @return WifiErrorNo
132      */
133     WifiErrorNo GetSupportFrequencies(int band, std::vector<int> &frequencies);
134 
135     /**
136      * @Description Sets the MAC address of the Wi-Fi connection.
137      *
138      * @param mac
139      * @return WifiErrorNo
140      */
141     WifiErrorNo SetConnectMacAddr(const std::string &mac);
142 
143     /**
144      * @Description Sets the MAC address for Wi-Fi scanning.
145      *
146      * @param mac
147      * @return WifiErrorNo
148      */
149     WifiErrorNo SetScanMacAddress(const std::string &mac);
150 
151     /**
152      * @Description Disconnect the BSSID of the last roaming subscriber.
153      *
154      * @param mac
155      * @return WifiErrorNo
156      */
157     WifiErrorNo DisconnectLastRoamingBssid(const std::string &mac);
158 
159     /**
160      * @Description Get total supported feature, and call user can determine whether
161      *              support a feature.
162      *
163      * @param feature
164      * @return WifiErrorNo
165      */
166     WifiErrorNo ReqGetSupportFeature(long &feature);
167 
168     /**
169      * @Description Send instructions to the Wi-Fi driver or chip.
170      *
171      * @param request
172      * @return WifiErrorNo
173      */
174     WifiErrorNo SendRequest(const WifiStaRequest &request);
175 
176     /**
177      * @Description Set the Wi-Fi transmit power.
178      *
179      * @param power
180      * @return WifiErrorNo
181      */
182     WifiErrorNo SetTxPower(int power);
183 
184     /**
185      * @Description Scan by specified parameter.
186      *
187      * @param scanParam
188      * @return WifiErrorNo
189      */
190     WifiErrorNo Scan(const WifiScanParam &scanParam);
191 
192     /**
193      * @Description Obtain the scanning result.
194      *
195      * @param scanInfos
196      * @return WifiErrorNo
197      */
198     WifiErrorNo QueryScanInfos(std::vector<InterScanInfo> &scanInfos);
199 
200     /**
201      * @Description Initiate PNO scanning.
202      *
203      * @param scanParam
204      * @return WifiErrorNo
205      */
206     WifiErrorNo ReqStartPnoScan(const WifiPnoScanParam &scanParam);
207 
208     /**
209      * @Description Stop PNO Scanning.
210      *
211      * @return WifiErrorNo
212      */
213     WifiErrorNo ReqStopPnoScan(void);
214 
215     /**
216      * @Description Deleting a Network.
217      *
218      * @param networkId
219      * @return WifiErrorNo
220      */
221     WifiErrorNo RemoveDevice(int networkId);
222 
223     /**
224      * @Description Clears the network configuration information saved by wpa_supplicant.
225      *
226      * @return WifiErrorNo
227      */
228     WifiErrorNo ClearDeviceConfig(void) const;
229 
230     /**
231      * @Description Request to obtain the next network ID.
232      *
233      * @param networkId
234      * @return WifiErrorNo
235      */
236     WifiErrorNo GetNextNetworkId(int &networkId);
237 
238     /**
239      * @Description Enable a network.
240      *
241      * @param networkId
242      * @return WifiErrorNo
243      */
244     WifiErrorNo ReqEnableNetwork(int networkId);
245 
246     /**
247      * @Description Disable a network.
248      *
249      * @param networkId
250      * @return WifiErrorNo
251      */
252     WifiErrorNo ReqDisableNetwork(int networkId);
253 
254     /**
255      * @Description Get the network.
256      *
257      * @param config
258      * @return WifiErrorNo
259      */
260     WifiErrorNo GetDeviceConfig(WifiIdlGetDeviceConfig &config);
261 
262     /**
263      * @Description Setting the network.
264      *
265      * @param networkId
266      * @param config - Setting Network Parameters.
267      * @return WifiErrorNo
268      */
269     WifiErrorNo SetDeviceConfig(int networkId, const WifiIdlDeviceConfig &config);
270 
271     /**
272      * @Description Save the network.
273      *
274      * @return WifiErrorNo
275      */
276     WifiErrorNo SaveDeviceConfig(void);
277 
278     /**
279      * @Description Registering the Sta Event Callback.
280      *
281      * @param callback - Registering an Event Callback Function.
282      * @return WifiErrorNo
283      */
284     WifiErrorNo ReqRegisterStaEventCallback(const WifiEventCallback &callback);
285 
286     /**
287      * @Description Enabling WPS in PBC Mode.
288      *
289      * @param config
290      * @return WifiErrorNo
291      */
292     WifiErrorNo ReqStartWpsPbcMode(const WifiIdlWpsConfig &config);
293 
294     /**
295      * @Description Enable PIN mode WPS.
296      *
297      * @param config
298      * @param pinCode
299      * @return WifiErrorNo
300      */
301     WifiErrorNo ReqStartWpsPinMode(const WifiIdlWpsConfig &config, int &pinCode);
302 
303     /**
304      * @Description Close wps.
305      *
306      * @return WifiErrorNo
307      */
308     WifiErrorNo ReqStopWps(void);
309 
310     /**
311      * @Description Obtains the roaming support capability.
312      *
313      * @param capability - Roaming Support Capability.
314      * @return WifiErrorNo
315      */
316     WifiErrorNo ReqGetRoamingCapabilities(WifiIdlRoamCapability &capability);
317 
318     /**
319      * @Description Setting Roaming Configurations.
320      *
321      * @param config
322      * @return WifiErrorNo
323      */
324     WifiErrorNo ReqSetRoamConfig(const WifiIdlRoamConfig &config);
325 
326     /**
327      * @Description Get current connect signal info, rssi, linkspeed, noise ...
328      *
329      * @param endBssid - peer end bssid, i.e. linked ap's bssid
330      * @param info - signal info
331      * @return WifiErrorNo
332      */
333     WifiErrorNo ReqGetConnectSignalInfo(const std::string &endBssid, WifiWpaSignalInfo &info) const;
334 
335     /* -------------------AP Interface-------------------------- */
336 
337     /**
338      * @Description Start Ap.
339      *
340      * @return WifiErrorNo
341      */
342     WifiErrorNo StartAp(void);
343 
344     /**
345      * @Description Close Ap.
346      *
347      * @return WifiErrorNo
348      */
349     WifiErrorNo StopAp(void);
350 
351     /**
352      * @Description Setting SoftAP Configurations.
353      *
354      * @param config
355      * @return WifiErrorNo
356      */
357     WifiErrorNo SetSoftApConfig(const HotspotConfig &config);
358 
359     /**
360      * @Description Obtains information about all connected STAs.
361      *
362      * @param result
363      * @return WifiErrorNo
364      */
365     WifiErrorNo GetStationList(std::vector<std::string> &result);
366 
367     /**
368      * @Description To set the blocklist filtering in AP mode to prohibit the MAC
369      *              address connection.
370      *
371      * @param mac - Blocklisted address.
372      * @return WifiErrorNo
373      */
374     WifiErrorNo AddBlockByMac(const std::string &mac);
375 
376     /**
377      * @Description To set blocklist filtering in AP mode and delete a specified MAC
378      *              address from the blocklist.
379      *
380      * @param mac - Blocklisted address.
381      * @return WifiErrorNo
382      */
383     WifiErrorNo DelBlockByMac(const std::string &mac);
384 
385     /**
386      * @Description Disconnect the STA with a specified MAC address.
387      *
388      * @param mac
389      * @return WifiErrorNo
390      */
391     WifiErrorNo RemoveStation(const std::string &mac);
392 
393     /**
394      * @Description Obtains the hotspot frequency supported by a specified frequency band.
395      *
396      * @param band
397      * @param frequencies
398      * @return WifiErrorNo
399      */
400     WifiErrorNo GetFrequenciesByBand(int band, std::vector<int> &frequencies);
401 
402     /**
403      * @Description Listening to Wi-Fi disconnection or connection events
404      *              of the STA in AP mode.
405      *
406      * @param callback
407      * @return WifiErrorNo
408      */
409     WifiErrorNo RegisterApEvent(IWifiApMonitorEventCallback callback) const;
410 
411     /**
412      * @Description Sets the Wi-Fi country code.
413      *
414      * @param code
415      * @return WifiErrorNo
416      */
417     WifiErrorNo SetWifiCountryCode(const std::string &code);
418 
419     /**
420      * @Description Disconnect the STA connection based on the MAC address.
421      *
422      * @param mac
423      * @return WifiErrorNo
424      */
425     WifiErrorNo ReqDisconnectStaByMac(const std::string &mac);
426 
427     /* ************************** ChipMode interface **************************** */
428 
429     /**
430      * @Description Obtains the chip object by ID.
431      *
432      * @param id
433      * @param chip
434      * @return WifiErrorNo
435      */
436     WifiErrorNo GetWifiChipObject(int id, IWifiChip &chip);
437 
438     /**
439      * @Description Obtains the Wi-Fi chip ID set.
440      *
441      * @param ids
442      * @return WifiErrorNo
443      */
444     WifiErrorNo GetChipIds(std::vector<int> &ids);
445 
446     /**
447      * @Description Obtains the chip ID.
448      *
449      * @param id
450      * @return WifiErrorNo
451      */
452     WifiErrorNo GetUsedChipId(int &id);
453 
454     /**
455      * @Description Obtains chip capabilities.
456      *
457      * @param capabilities
458      * @return WifiErrorNo
459      */
460     WifiErrorNo GetChipCapabilities(int &capabilities);
461 
462     /**
463      * @Description Obtains the joint mode supported by the chip, for
464      *              example, sta+sta/sta+p2p/sta+ap/sta+nan/ap+nan.
465      *
466      * @param modes
467      * @return WifiErrorNo
468      */
469     WifiErrorNo GetSupportedModes(std::vector<int> &modes);
470 
471     /**
472      * @Description Configure the current joint mode of the chip.
473      *
474      * @param mode
475      * @return WifiErrorNo
476      */
477     WifiErrorNo ConfigRunModes(int mode);
478 
479     /**
480      * @Description Gets the current federation mode.
481      *
482      * @param mode
483      * @return WifiErrorNo
484      */
485     WifiErrorNo GetCurrentMode(int &mode);
486 
487     /**
488      * @Description Registering a Wi-Fi Chip Event.
489      *
490      * @param callback
491      * @return WifiErrorNo
492      */
493     WifiErrorNo RegisterChipEventCallback(WifiChipEventCallback &callback);
494 
495     /**
496      * @Description Requesting the debugging information of the firmware chip.
497      *
498      * @param debugInfo
499      * @return WifiErrorNo
500      */
501     WifiErrorNo RequestFirmwareDebugInfo(std::string &debugInfo);
502 
503     /**
504      * @Description Setting the Power Mode.
505      *
506      * @param mode
507      * @return WifiErrorNo
508      */
509     WifiErrorNo SetWifiPowerMode(int mode);
510 
511     /* ******************************* Supplicant interface********************** */
512 
513     /**
514      * @Description Starting the Supplementary Service.
515      *
516      * @return WifiErrorNo
517      */
518     WifiErrorNo ReqStartSupplicant(void);
519 
520     /**
521      * @Description Disabling the Supplementary Service.
522      *
523      * @return WifiErrorNo
524      */
525     WifiErrorNo ReqStopSupplicant(void);
526 
527     /**
528      * @Description Connecting to the Supplier.
529      *
530      * @return WifiErrorNo
531      */
532     WifiErrorNo ReqConnectSupplicant(void);
533 
534     /**
535      * @Description Disconnecting the Supply.
536      *
537      * @return WifiErrorNo
538      */
539     WifiErrorNo ReqDisconnectSupplicant(void);
540 
541     /**
542      * @Description Send a request to the supplier.
543      *
544      * @param request
545      * @return WifiErrorNo
546      */
547     WifiErrorNo ReqRequestToSupplicant(const std::string &request);
548 
549     /**
550      * @Description Registers the supplementary event callback function.
551      *
552      * @param callback
553      * @return WifiErrorNo
554      */
555     WifiErrorNo ReqRegisterSupplicantEventCallback(SupplicantEventCallback &callback);
556 
557     /**
558      * @Description Deregisters the supplementary event callback function.
559      *
560      * @return WifiErrorNo
561      */
562     WifiErrorNo ReqUnRegisterSupplicantEventCallback(void);
563 
564     /**
565      * @Description Turn on/off power save mode for the interface.
566      *
567      * @param enable
568      * @return WifiErrorNo
569      */
570     WifiErrorNo ReqSetPowerSave(bool enable);
571 
572     /**
573      * @Description Setting the country code.
574      *
575      * @param countCode
576      * @return WifiErrorNo
577      */
578     WifiErrorNo ReqWpaSetCountryCode(const std::string &countCode);
579 
580     /**
581      * @Description Obtains the country code.
582      *
583      * @param countCode
584      * @return WifiErrorNo
585      */
586     WifiErrorNo ReqWpaGetCountryCode(std::string &countCode);
587 
588     /**
589      * @Description Wpa_s disable/enable(0/1) automatic reconnection.
590      *
591      * @param enable
592      * @return WifiErrorNo
593      */
594     WifiErrorNo ReqWpaAutoConnect(int enable);
595 
596 
597     /**
598      * @Description Clearing the wpa Blocklist.
599      *
600      * @return WifiErrorNo
601      */
602     WifiErrorNo ReqWpaBlocklistClear(void);
603 
604     /**
605      * @Description Obtaining the Network List.
606      *
607      * @param networkList
608      * @return WifiErrorNo
609      */
610     WifiErrorNo ReqGetNetworkList(std::vector<WifiWpaNetworkInfo> &networkList);
611 
612     /* ******************************* P2P interface************************** */
613 
614     /**
615      * @Description Open P2p
616      *
617      * @return WifiErrorNo
618      */
619     WifiErrorNo ReqP2pStart(void) const;
620 
621     /**
622      * @Description Close p2p
623      *
624      * @return WifiErrorNo
625      */
626     WifiErrorNo ReqP2pStop(void) const;
627 
628     /**
629      * @Description P2P hal-layer registration event
630      *
631      * @return WifiErrorNo
632      */
633     WifiErrorNo ReqP2pRegisterCallback(const P2pHalCallback &callbacks) const;
634 
635     /**
636      * @Description Send a request for setup wps pbc to the P2P
637      *
638      * @param groupInterface
639      * @param bssid
640      * @return WifiErrorNo
641      */
642     WifiErrorNo ReqP2pSetupWpsPbc(const std::string &groupInterface, const std::string &bssid) const;
643 
644     /**
645      * @Description Enable Wps Pin mode
646      *
647      * @param groupInterface - p2p group
648      * @param address
649      * @param pin - pin code
650      * @param result - when pin is empty, represent use pin display mode, this return pin code
651      * @return WifiErrorNo
652      */
653     WifiErrorNo ReqP2pSetupWpsPin(const std::string &groupInterface, const std::string &address, const std::string &pin,
654         std::string &result) const;
655 
656     /**
657      * @Description Send a request for remove a p2p network to the P2P
658      *
659      * @param networkId
660      * @return WifiErrorNo
661      */
662     WifiErrorNo ReqP2pRemoveNetwork(int networkId) const;
663 
664     /**
665      * @Description Send a request for get p2p network list to the P2P
666      *
667      * @param mapGroups
668      * @return WifiErrorNo
669      */
670     WifiErrorNo ReqP2pListNetworks(std::map<int, WifiP2pGroupInfo> &mapGroups) const;
671 
672     /**
673      * @Description Requesting P2P Setting Device Name
674      *
675      * @param name
676      * @return WifiErrorNo
677      */
678     WifiErrorNo ReqP2pSetDeviceName(const std::string &name) const;
679 
680     /**
681      * @Description Send a request for setting the WPS primary device type in P2P mode
682      *
683      * @param type
684      * @return WifiErrorNo
685      */
686     WifiErrorNo ReqP2pSetWpsDeviceType(const std::string &type) const;
687 
688     /**
689      * @Description Send a request for setting the WPS secondary device type in P2P mode
690      *
691      * @param type
692      * @return WifiErrorNo
693      */
694     WifiErrorNo ReqP2pSetWpsSecondaryDeviceType(const std::string &type) const;
695 
696     /**
697      * @Description Send a request for setting the WPS configuration method to the P2P.
698      *
699      * @param config
700      * @return WifiErrorNo
701      */
702     WifiErrorNo ReqP2pSetWpsConfigMethods(const std::string &config) const;
703 
704     /**
705      * @Description Send a P2P request for setting the SSID suffix
706      *
707      * @param postfixName
708      * @return WifiErrorNo
709      */
710     WifiErrorNo ReqP2pSetSsidPostfixName(const std::string &postfixName) const;
711 
712     /**
713      * @Description Send a request for set group max idle to the P2P
714      *
715      * @param groupInterface
716      * @param time
717      * @return WifiErrorNo
718      */
719     WifiErrorNo ReqP2pSetGroupMaxIdle(const std::string &groupInterface, size_t time) const;
720 
721     /**
722      * @Description Send a request for set power save to the P2P
723      *
724      * @param groupInterface
725      * @param enable
726      * @return WifiErrorNo
727      */
728     WifiErrorNo ReqP2pSetPowerSave(const std::string &groupInterface, bool enable) const;
729 
730     /**
731      * @Description enable/disable Wi-Fi Display
732      *
733      * @param enable
734      * @return WifiErrorNo
735      */
736     WifiErrorNo ReqP2pSetWfdEnable(bool enable) const;
737 
738     /**
739      * @Description Send a request for set Wi-Fi Display config
740      *
741      * @param config
742      * @return WifiErrorNo
743      */
744     WifiErrorNo ReqP2pSetWfdDeviceConfig(const std::string &config) const;
745 
746     /**
747      * @Description Send a request for start p2p find to the P2P
748      *
749      * @param timeout
750      * @return WifiErrorNo
751      */
752     WifiErrorNo ReqP2pStartFind(size_t timeout) const;
753 
754     /**
755      * @Description Send a request for stop p2p find to the P2P
756      *
757      * @return WifiErrorNo
758      */
759     WifiErrorNo ReqP2pStopFind() const;
760 
761     /**
762      * @Description Send a request for set ext listen to the P2P
763      *
764      * @param enable
765      * @param period
766      * @param interval
767      * @return WifiErrorNo
768      */
769     WifiErrorNo ReqP2pSetExtListen(bool enable, size_t period, size_t interval) const;
770 
771     /**
772      * @Description Send a request for set listen channel to the P2P
773      *
774      * @param channel
775      * @param regClass
776      * @return WifiErrorNo
777      */
778     WifiErrorNo ReqP2pSetListenChannel(size_t channel, unsigned char regClass) const;
779 
780     /**
781      * @Description Send a request for flush to the P2P.
782      *
783      * @return WifiErrorNo
784      */
785     WifiErrorNo ReqP2pFlush() const;
786 
787     /**
788      * @Description Send a request for connect to the P2P
789      *
790      * @param config
791      * @param isJoinExistingGroup
792      * @param pin
793      * @return WifiErrorNo
794      */
795     WifiErrorNo ReqP2pConnect(const WifiP2pConfigInternal &config, bool isJoinExistingGroup, std::string &pin) const;
796 
797     /**
798      * @Description Send a request for cancel connect to the P2P
799      *
800      * @return WifiErrorNo
801      */
802     WifiErrorNo ReqP2pCancelConnect() const;
803 
804     /**
805      * @Description Send a request for Provision Discovery to the P2P
806      *
807      */
808     WifiErrorNo ReqP2pProvisionDiscovery(const WifiP2pConfigInternal &config) const;
809 
810     /**
811      * @Description Send a request for add a P2P group to the P2P
812      *
813      * @param isPersistent
814      * @param networkId
815      * @param freq
816      * @return WifiErrorNo
817      */
818     WifiErrorNo ReqP2pAddGroup(bool isPersistent, int networkId, int freq) const;
819 
820     /**
821      * @Description Send a request for remove group to the P2P
822      *
823      * @param groupInterface
824      * @return WifiErrorNo
825      */
826     WifiErrorNo ReqP2pRemoveGroup(const std::string &groupInterface) const;
827 
828     /**
829      * @Description Send a request for invite to the P2P
830      *
831      * @return WifiErrorNo
832      */
833     WifiErrorNo ReqP2pInvite(const WifiP2pGroupInfo &group, const std::string &deviceAddr) const;
834 
835     /**
836      * @Description Send a request for reinvoke to the P2P
837      *
838      * @param networkId
839      * @param deviceAddr
840      * @return WifiErrorNo
841      */
842     WifiErrorNo ReqP2pReinvoke(int networkId, const std::string &deviceAddr) const;
843 
844     /**
845      * @Description Send a request for get device address to the P2P.
846      *
847      * @param deviceAddress
848      * @return WifiErrorNo
849      */
850     WifiErrorNo ReqP2pGetDeviceAddress(std::string &deviceAddress) const;
851 
852     /**
853      * @Description Send a request for get group capability to the P2P
854      *
855      * @param deviceAddress
856      * @param cap
857      * @return WifiErrorNo
858      */
859     WifiErrorNo ReqP2pGetGroupCapability(const std::string &deviceAddress, uint32_t &cap) const;
860 
861     /**
862      * @Description Send a request for add service to the P2P
863      *
864      * @param WifiP2pServiceInfo
865      * @return WifiErrorNo
866      */
867     WifiErrorNo ReqP2pAddService(const WifiP2pServiceInfo &info) const;
868 
869     /**
870      * @Description Send a request for remove service to the P2P
871      *
872      * @param RemoveService
873      * @return WifiErrorNo
874      */
875     WifiErrorNo ReqP2pRemoveService(const WifiP2pServiceInfo &info) const;
876 
877     /**
878      * @Description Send a request for flush service to the P2P
879      *
880      * @return WifiErrorNo
881      */
882     WifiErrorNo ReqP2pFlushService() const;
883 
884     /**
885      * @Description Send a request for save config to the P2P
886      *
887      * @return WifiErrorNo
888      */
889     WifiErrorNo ReqP2pSaveConfig() const;
890 
891     /**
892      * @Description Send a request for request service discovery to the P2P
893      *
894      * @param macAddr
895      * @param queryMsg
896      * @return WifiErrorNo
897      */
898     WifiErrorNo ReqP2pReqServiceDiscovery(
899         const std::string &deviceAddress, const std::vector<unsigned char> &tlvs, std::string &reqID) const;
900 
901     /**
902      * @Description Send a request for cancel request service discovery to the P2P
903      *
904      * @param id
905      * @return WifiErrorNo
906      */
907     WifiErrorNo ReqP2pCancelServiceDiscovery(const std::string &id) const;
908 
909     /**
910      * @Description set enable/disable using random mac address
911      *
912      * @param enable
913      * @return WifiErrorNo
914      */
915     WifiErrorNo ReqP2pSetRandomMac(bool enable) const;
916 
917     /**
918      * @Description Send a request for set the miracast type to the P2P
919      *
920      * @param type
921      * @return WifiErrorNo
922      */
923     WifiErrorNo ReqP2pSetMiracastType(int type) const;
924 
925     /**
926      * @Description Set the Persistent Reconnect mode.
927      *
928      * @param mode
929      * @return WifiErrorNo
930      */
931     WifiErrorNo ReqSetPersistentReconnect(int mode) const;
932 
933     /**
934      * @Description
935      *
936      * @param deviceAddress
937      * @param frequency
938      * @param dialogToken
939      * @param tlvs
940      * @param tlvsLength
941      * @return WifiErrorNo
942      */
943     WifiErrorNo ReqRespServiceDiscovery(
944         const WifiP2pDevice &device, int frequency, int dialogToken, const std::vector<unsigned char> &tlvs) const;
945 
946     /**
947      * @Description Set P2p server discovery external.
948      *
949      * @param isExternalProcess
950      * @return WifiErrorNo
951      */
952     WifiErrorNo ReqSetServiceDiscoveryExternal(bool isExternalProcess) const;
953 
954      /**
955      * @Description Show information about known P2P peer
956      *
957      * @param deviceAddress
958      * @param device
959      * @return WifiErrorNo
960      */
961     WifiErrorNo ReqGetP2pPeer(const std::string &deviceAddress, WifiP2pDevice &device) const;
962 
963     /**
964      * @Description Obtains the P2P frequency supported by a specified frequency band.
965      *
966      * @param band - Frequency band.
967      * @param frequencies - Frequency list.
968      * @return WifiErrorNo
969      */
970     WifiErrorNo ReqP2pGetSupportFrequencies(int band, std::vector<int> &frequencies) const;
971 
972     /**
973      * @Description Setting the P2P group config.
974      *
975      * @param networkId
976      * @param config
977      * @return WifiErrorNo
978      */
979     WifiErrorNo ReqP2pSetGroupConfig(int networkId, const IdlP2pGroupConfig &config) const;
980 
981     /**
982      * @Description Getting the P2P group config.
983      *
984      * @param networkId
985      * @param config
986      * @return WifiErrorNo
987      */
988     WifiErrorNo ReqP2pGetGroupConfig(int networkId, IdlP2pGroupConfig &config) const;
989 
990     /**
991      * @Description Request to obtain the next network ID.
992      *
993      * @param networkId
994      * @return WifiErrorNo
995      */
996     WifiErrorNo ReqP2pAddNetwork(int &networkId) const;
997 
998     /**
999      * @Description Send a request for hid2d connect
1000      *
1001      * @param config
1002      * @return WifiErrorNo
1003      */
1004     WifiErrorNo ReqP2pHid2dConnect(const Hid2dConnectConfig &config) const;
1005 
1006 public:
1007     RpcClient *pRpcClient;
1008 
1009 private:
1010     char **ConVectorToCArrayString(const std::vector<std::string> &vec) const;
1011     WifiErrorNo ConvertPnoScanParam(const WifiPnoScanParam &param, PnoScanSettings *pSettings) const;
1012     int PushDeviceConfigString(HidlSetNetworkConfig *pConfig, DeviceConfigType type, const std::string &msg) const;
1013     int PushDeviceConfigInt(HidlSetNetworkConfig *pConfig, DeviceConfigType type, int i) const;
1014     int PushDeviceConfigAuthAlgorithm(HidlSetNetworkConfig *pConfig, DeviceConfigType type, unsigned int alg) const;
1015     WifiErrorNo CheckValidDeviceConfig(const WifiIdlDeviceConfig &config) const;
1016     int PushP2pGroupConfigString(HidlP2pGroupConfig *pConfig, P2pGroupConfigType type, const std::string &str) const;
1017     int PushP2pGroupConfigInt(HidlP2pGroupConfig *pConfig, P2pGroupConfigType type, int i) const;
1018 };
1019 }  // namespace Wifi
1020 }  // namespace OHOS
1021 
1022 #endif