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