1 /*
2 * Copyright (c) 2024 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_p2p_iface.h"
17
18 namespace OHOS {
19 namespace HDI {
20 namespace Wlan {
21 namespace Chip {
22 namespace V2_0 {
WifiP2pIface(const std::string & ifname,const std::weak_ptr<WifiVendorHal> vendorHal,const std::weak_ptr<IfaceUtil> ifaceUtil)23 WifiP2pIface::WifiP2pIface(
24 const std::string& ifname, const std::weak_ptr<WifiVendorHal> vendorHal,
25 const std::weak_ptr<IfaceUtil> ifaceUtil)
26 : ifname_(ifname),
27 vendorHal_(vendorHal),
28 ifaceUtil_(ifaceUtil),
29 isValid_(true) {}
30
Invalidate()31 void WifiP2pIface::Invalidate()
32 {
33 vendorHal_.reset();
34 isValid_ = false;
35 }
36
IsValid()37 bool WifiP2pIface::IsValid()
38 {
39 return isValid_;
40 }
41
GetName()42 std::string WifiP2pIface::GetName()
43 {
44 return ifname_;
45 }
46
GetIfaceType(IfaceType & type)47 int32_t WifiP2pIface::GetIfaceType(IfaceType& type)
48 {
49 type = IfaceType::P2P;
50 return HDF_SUCCESS;
51 }
52
GetIfaceName(std::string & name)53 int32_t WifiP2pIface::GetIfaceName(std::string& name)
54 {
55 name = ifname_;
56 return HDF_SUCCESS;
57 }
58
GetSupportFreqs(int band,std::vector<uint32_t> & frequencies)59 int32_t WifiP2pIface::GetSupportFreqs(int band, std::vector<uint32_t>& frequencies)
60 {
61 WifiError status;
62 std::vector<uint32_t> validFrequencies;
63 std::tie(status, validFrequencies) = vendorHal_.lock()->GetValidFrequenciesForBand(
64 ifname_, band);
65 frequencies = validFrequencies;
66 if (status == HAL_SUCCESS) {
67 return HDF_SUCCESS;
68 }
69 return HDF_FAILURE;
70 }
71
GetIfaceCap(uint32_t & capabilities)72 int32_t WifiP2pIface::GetIfaceCap(uint32_t& capabilities)
73 {
74 return HDF_SUCCESS;
75 }
76
SetMacAddress(const std::string & mac)77 int32_t WifiP2pIface::SetMacAddress(const std::string& mac)
78 {
79 return HDF_ERR_NOT_SUPPORT;
80 }
81
SetCountryCode(const std::string & code)82 int32_t WifiP2pIface::SetCountryCode(const std::string& code)
83 {
84 return HDF_ERR_NOT_SUPPORT;
85 }
86
GetPowerMode(int32_t & powerMode)87 int32_t WifiP2pIface::GetPowerMode(int32_t& powerMode)
88 {
89 return HDF_ERR_NOT_SUPPORT;
90 }
91
SetPowerMode(int32_t powerMode)92 int32_t WifiP2pIface::SetPowerMode(int32_t powerMode)
93 {
94 return HDF_ERR_NOT_SUPPORT;
95 }
96
RegisterChipIfaceCallBack(const sptr<IChipIfaceCallback> & chipIfaceCallback)97 int32_t WifiP2pIface::RegisterChipIfaceCallBack(const sptr<IChipIfaceCallback>& chipIfaceCallback)
98 {
99 return HDF_ERR_NOT_SUPPORT;
100 }
101
UnRegisterChipIfaceCallBack(const sptr<IChipIfaceCallback> & chipIfaceCallback)102 int32_t WifiP2pIface::UnRegisterChipIfaceCallBack(const sptr<IChipIfaceCallback>& chipIfaceCallback)
103 {
104 return HDF_ERR_NOT_SUPPORT;
105 }
106
StartScan(const ScanParams & scanParam)107 int32_t WifiP2pIface::StartScan(const ScanParams& scanParam)
108 {
109 return HDF_ERR_NOT_SUPPORT;
110 }
111
GetScanInfos(std::vector<ScanResultsInfo> & scanResultsInfo)112 int32_t WifiP2pIface::GetScanInfos(std::vector<ScanResultsInfo>& scanResultsInfo)
113 {
114 return HDF_ERR_NOT_SUPPORT;
115 }
116
StartPnoScan(const PnoScanParams & pnoParams)117 int32_t WifiP2pIface::StartPnoScan(const PnoScanParams& pnoParams)
118 {
119 return HDF_ERR_NOT_SUPPORT;
120 }
121
StopPnoScan()122 int32_t WifiP2pIface::StopPnoScan()
123 {
124 return HDF_ERR_NOT_SUPPORT;
125 }
126
GetSignalPollInfo(SignalPollResult & signalPollResult)127 int32_t WifiP2pIface::GetSignalPollInfo(SignalPollResult& signalPollResult)
128 {
129 return HDF_ERR_NOT_SUPPORT;
130 }
131
EnablePowerMode(int32_t mode)132 int32_t WifiP2pIface::EnablePowerMode(int32_t mode)
133 {
134 return HDF_ERR_NOT_SUPPORT;
135 }
136
SetDpiMarkRule(int32_t uid,int32_t protocol,int32_t enable)137 int32_t WifiP2pIface::SetDpiMarkRule(int32_t uid, int32_t protocol, int32_t enable)
138 {
139 return HDF_ERR_NOT_SUPPORT;
140 }
141
SetTxPower(int32_t power)142 int32_t WifiP2pIface::SetTxPower(int32_t power)
143 {
144 {
145 WifiError status = vendorHal_.lock()->SetTxPower(ifname_, power);
146 return status;
147 }
148 }
149
SetIfaceState(bool state)150 int32_t WifiP2pIface::SetIfaceState(bool state)
151 {
152 return HDF_ERR_NOT_SUPPORT;
153 }
154
SendCmdToDriver(const std::string & ifName,int32_t cmdId,const std::vector<int8_t> & paramBuf,std::vector<int8_t> & result)155 int32_t WifiP2pIface::SendCmdToDriver(const std::string& ifName, int32_t cmdId,
156 const std::vector<int8_t>& paramBuf, std::vector<int8_t>& result)
157 {
158 WifiError status = vendorHal_.lock()->SendCmdToDriver(ifName, cmdId, paramBuf, result);
159 if (status == HAL_SUCCESS) {
160 return HDF_SUCCESS;
161 }
162 return HDF_FAILURE;
163 }
164
SendActionFrame(const std::string & ifName,uint32_t freq,const std::vector<uint8_t> & frameData)165 int32_t WifiP2pIface::SendActionFrame(const std::string& ifName, uint32_t freq, const std::vector<uint8_t>& frameData)
166 {
167 return HDF_ERR_NOT_SUPPORT;
168 }
169
RegisterActionFrameReceiver(const std::string & ifName,const std::vector<uint8_t> & match)170 int32_t WifiP2pIface::RegisterActionFrameReceiver(const std::string& ifName, const std::vector<uint8_t>& match)
171 {
172 return HDF_ERR_NOT_SUPPORT;
173 }
174
GetCoexictenceChannelList(const std::string & ifName,std::vector<uint8_t> & paramBuf)175 int32_t WifiP2pIface::GetCoexictenceChannelList(const std::string& ifName, std::vector<uint8_t>& paramBuf)
176 {
177 return HDF_ERR_NOT_SUPPORT;
178 }
179
SetProjectionScreenParam(const std::string & ifName,const ProjectionScreenCmdParam & param)180 int32_t WifiP2pIface::SetProjectionScreenParam(const std::string& ifName, const ProjectionScreenCmdParam& param)
181 {
182 return HDF_ERR_NOT_SUPPORT;
183 }
184 }
185 }
186 }
187 }
188 }