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 <mutex>
17 #include "wifi_ap_hal_interface.h"
18 #include "hal_device_manage.h"
19 #include "wifi_log.h"
20 #include "wifi_error_no.h"
21
22 #undef LOG_TAG
23 #define LOG_TAG "WifiApHalInterface"
24
25 namespace OHOS {
26 namespace Wifi {
27 static IWifiApMonitorEventCallback g_cb = {nullptr, nullptr};
GetInstance(void)28 WifiApHalInterface &WifiApHalInterface::GetInstance(void)
29 {
30 static WifiApHalInterface inst;
31 static int initFlag = 0;
32 static std::mutex initMutex;
33 if (initFlag == 0) {
34 std::unique_lock<std::mutex> lock(initMutex);
35 if (initFlag == 0) {
36 #ifdef HDI_WPA_INTERFACE_SUPPORT
37 if (inst.InitHdiWpaClient()) {
38 initFlag = 1;
39 }
40 #else
41 if (inst.InitIdlClient()) {
42 initFlag = 1;
43 }
44 #endif
45 }
46 }
47 return inst;
48 }
49
StartAp(int id,const std::string & ifaceName)50 WifiErrorNo WifiApHalInterface::StartAp(int id, const std::string &ifaceName)
51 {
52 #ifdef HDI_WPA_INTERFACE_SUPPORT
53 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
54 WifiErrorNo ret = mHdiWpaClient->StartAp(id, ifaceName);
55 #else
56 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
57 WifiErrorNo ret = mIdlClient->StartAp(id, ifaceName);
58 #endif
59 return ret;
60 }
61
StopAp(int id)62 WifiErrorNo WifiApHalInterface::StopAp(int id)
63 {
64 #ifdef HDI_WPA_INTERFACE_SUPPORT
65 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
66 WifiErrorNo ret = mHdiWpaClient->StopAp(id);
67 #else
68 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
69 WifiErrorNo ret = mIdlClient->StopAp(id);
70 #endif
71 return ret;
72 }
73
SetSoftApConfig(const std::string & ifName,const HotspotConfig & config,int id)74 WifiErrorNo WifiApHalInterface::SetSoftApConfig(const std::string &ifName, const HotspotConfig &config, int id)
75 {
76 #ifdef HDI_WPA_INTERFACE_SUPPORT
77 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
78 return mHdiWpaClient->SetSoftApConfig(ifName, config, id);
79 #else
80 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
81 return mIdlClient->SetSoftApConfig(config, id);
82 #endif
83 }
84
EnableAp(int id)85 WifiErrorNo WifiApHalInterface::EnableAp(int id)
86 {
87 #ifdef HDI_WPA_INTERFACE_SUPPORT
88 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
89 return mHdiWpaClient->EnableAp(id);
90 #else
91 return WIFI_HAL_OPT_OK;
92 #endif
93 }
94
GetStationList(std::vector<std::string> & result,int id)95 WifiErrorNo WifiApHalInterface::GetStationList(std::vector<std::string> &result, int id)
96 {
97 #ifdef HDI_WPA_INTERFACE_SUPPORT
98 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
99 return mHdiWpaClient->GetStationList(result, id);
100 #else
101 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
102 return mIdlClient->GetStationList(result, id);
103 #endif
104 }
105
AddBlockByMac(const std::string & mac,int id)106 WifiErrorNo WifiApHalInterface::AddBlockByMac(const std::string &mac, int id)
107 {
108 #ifdef HDI_WPA_INTERFACE_SUPPORT
109 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
110 return mHdiWpaClient->AddBlockByMac(mac, id);
111 #else
112 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
113 return mIdlClient->AddBlockByMac(mac, id);
114 #endif
115 }
116
DelBlockByMac(const std::string & mac,int id)117 WifiErrorNo WifiApHalInterface::DelBlockByMac(const std::string &mac, int id)
118 {
119 #ifdef HDI_WPA_INTERFACE_SUPPORT
120 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
121 return mHdiWpaClient->DelBlockByMac(mac, id);
122 #else
123 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
124 return mIdlClient->DelBlockByMac(mac, id);
125 #endif
126 }
127
RemoveStation(const std::string & mac,int id)128 WifiErrorNo WifiApHalInterface::RemoveStation(const std::string &mac, int id)
129 {
130 #ifdef HDI_WPA_INTERFACE_SUPPORT
131 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
132 return mHdiWpaClient->RemoveStation(mac, id);
133 #else
134 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
135 return mIdlClient->RemoveStation(mac, id);
136 #endif
137 }
138
GetFrequenciesByBand(const std::string & ifaceName,int band,std::vector<int> & frequencies)139 WifiErrorNo WifiApHalInterface::GetFrequenciesByBand(const std::string &ifaceName, int band,
140 std::vector<int> &frequencies)
141 {
142 #ifdef HDI_CHIP_INTERFACE_SUPPORT
143 if (!DelayedSingleton<HalDeviceManager>::GetInstance()->GetFrequenciesByBand(ifaceName, band, frequencies)) {
144 return WIFI_HAL_OPT_FAILED;
145 }
146 return WIFI_HAL_OPT_OK;
147 #else
148 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
149 return mIdlClient->GetFrequenciesByBand(band, frequencies);
150 #endif
151 }
152
RegisterApEvent(IWifiApMonitorEventCallback callback,int id)153 WifiErrorNo WifiApHalInterface::RegisterApEvent(IWifiApMonitorEventCallback callback, int id)
154 {
155 #ifdef HDI_WPA_INTERFACE_SUPPORT
156 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
157 WifiErrorNo err = mHdiWpaClient->RegisterApEvent(callback, id);
158 #else
159 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
160 WifiErrorNo err = mIdlClient->RegisterApEvent(callback, id);
161 #endif
162 if (err == WIFI_HAL_OPT_OK || callback.onStaJoinOrLeave == nullptr) {
163 mApCallback[id] = callback;
164 }
165 return err;
166 }
167
SetWifiCountryCode(const std::string & ifaceName,const std::string & code)168 WifiErrorNo WifiApHalInterface::SetWifiCountryCode(const std::string &ifaceName, const std::string &code)
169 {
170 #ifdef HDI_CHIP_INTERFACE_SUPPORT
171 if (!DelayedSingleton<HalDeviceManager>::GetInstance()->SetWifiCountryCode(ifaceName, code)) {
172 return WIFI_HAL_OPT_FAILED;
173 }
174 return WIFI_HAL_OPT_OK;
175 #else
176 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
177 return mIdlClient->SetWifiCountryCode(code);
178 #endif
179 }
180
DisconnectStaByMac(const std::string & mac,int id)181 WifiErrorNo WifiApHalInterface::DisconnectStaByMac(const std::string &mac, int id)
182 {
183 #ifdef HDI_WPA_INTERFACE_SUPPORT
184 CHECK_NULL_AND_RETURN(mHdiWpaClient, WIFI_HAL_OPT_FAILED);
185 return mHdiWpaClient->ReqDisconnectStaByMac(mac, id);
186 #else
187 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
188 return mIdlClient->ReqDisconnectStaByMac(mac, id);
189 #endif
190 }
191
GetApCallbackInst(int id) const192 const IWifiApMonitorEventCallback &WifiApHalInterface::GetApCallbackInst(int id) const
193 {
194 auto iter = mApCallback.find(id);
195 if (iter != mApCallback.end()) {
196 return iter->second;
197 }
198 return g_cb;
199 }
200
GetPowerModel(const std::string & ifaceName,int & model)201 WifiErrorNo WifiApHalInterface::GetPowerModel(const std::string &ifaceName, int& model)
202 {
203 #ifdef HDI_CHIP_INTERFACE_SUPPORT
204 if (!DelayedSingleton<HalDeviceManager>::GetInstance()->GetPowerModel(ifaceName, model)) {
205 return WIFI_HAL_OPT_FAILED;
206 }
207 return WIFI_HAL_OPT_OK;
208 #else
209 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
210 return mIdlClient->ReqGetPowerModel(model);
211 #endif
212 }
213
SetPowerModel(const std::string & ifaceName,int model)214 WifiErrorNo WifiApHalInterface::SetPowerModel(const std::string &ifaceName, int model)
215 {
216 #ifdef HDI_CHIP_INTERFACE_SUPPORT
217 if (!DelayedSingleton<HalDeviceManager>::GetInstance()->SetPowerModel(ifaceName, model)) {
218 return WIFI_HAL_OPT_FAILED;
219 }
220 return WIFI_HAL_OPT_OK;
221 #else
222 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
223 return mIdlClient->ReqSetPowerModel(model);
224 #endif
225 }
226
SetConnectMacAddr(const std::string & ifaceName,const std::string & mac)227 WifiErrorNo WifiApHalInterface::SetConnectMacAddr(const std::string &ifaceName, const std::string &mac)
228 {
229 #ifdef HDI_CHIP_INTERFACE_SUPPORT
230 if (!DelayedSingleton<HalDeviceManager>::GetInstance()->SetApMacAddress(ifaceName, mac)) {
231 return WIFI_HAL_OPT_FAILED;
232 }
233 return WIFI_HAL_OPT_OK;
234 #else
235 CHECK_NULL_AND_RETURN(mIdlClient, WIFI_HAL_OPT_FAILED);
236 return mIdlClient->SetConnectMacAddr(mac, HAL_PORT_TYPE_AP);
237 #endif
238 }
239 } // namespace Wifi
240 } // namespace OHOS