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 "../../../interfaces/kits/c/wifi_hid2d.h"
17 #include "../../include/wifi_hid2d.h"
18 #include "define.h"
19 #include "wifi_logger.h"
20 #include "wifi_c_utils.h"
21 #include "wifi_common_util.h"
22 #include "../../../interfaces/kits/c/wifi_device.h"
23
24 DEFINE_WIFILOG_LABEL("WifiCHid2d");
25
26 std::unique_ptr<OHOS::Wifi::Hid2d> wifiHid2dPtr = OHOS::Wifi::Hid2d::GetInstance(WIFI_P2P_ABILITY_ID);
27
Hid2dRequestGcIp(const unsigned char gcMac[MAC_LEN],unsigned int ipAddr[IPV4_ARRAY_LEN])28 WifiErrorCode Hid2dRequestGcIp(const unsigned char gcMac[MAC_LEN], unsigned int ipAddr[IPV4_ARRAY_LEN])
29 {
30 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
31
32 std::string strMac = OHOS::Wifi::MacArrayToStr(gcMac);
33 std::string strIpAddr;
34 OHOS::Wifi::ErrCode ret = wifiHid2dPtr->Hid2dRequestGcIp(strMac, strIpAddr);
35 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
36 WIFI_LOGE("Request gc ip failed!");
37 return ERROR_WIFI_UNKNOWN;
38 }
39 return OHOS::Wifi::IpStrToArray(strIpAddr, ipAddr);
40 }
41
Hid2dSharedlinkIncrease(void)42 WifiErrorCode Hid2dSharedlinkIncrease(void)
43 {
44 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
45 return GetCErrorCode(wifiHid2dPtr->Hid2dSharedlinkIncrease());
46 }
47
Hid2dSharedlinkDecrease(void)48 WifiErrorCode Hid2dSharedlinkDecrease(void)
49 {
50 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
51 return GetCErrorCode(wifiHid2dPtr->Hid2dSharedlinkDecrease());
52 }
53
Hid2dCreateGroup(const int frequency,FreqType type)54 WifiErrorCode Hid2dCreateGroup(const int frequency, FreqType type)
55 {
56 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
57 return GetCErrorCode(wifiHid2dPtr->Hid2dCreateGroup(frequency, OHOS::Wifi::FreqType(static_cast<int>(type))));
58 }
59
Hid2dRemoveGcGroup(const char gcIfName[IF_NAME_LEN])60 WifiErrorCode Hid2dRemoveGcGroup(const char gcIfName[IF_NAME_LEN])
61 {
62 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
63 return GetCErrorCode(wifiHid2dPtr->Hid2dRemoveGcGroup(gcIfName));
64 }
65
Hid2dConnect(const Hid2dConnectConfig * config)66 WifiErrorCode Hid2dConnect(const Hid2dConnectConfig *config)
67 {
68 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
69 CHECK_PTR_RETURN(config, ERROR_WIFI_INVALID_ARGS);
70
71 OHOS::Wifi::Hid2dConnectConfig cppConfig;
72 cppConfig.SetSsid(config->ssid);
73 cppConfig.SetBssid(OHOS::Wifi::MacArrayToStr(config->bssid));
74 cppConfig.SetPreSharedKey(config->preSharedKey);
75 cppConfig.SetFrequency(config->frequency);
76 cppConfig.SetDhcpMode(OHOS::Wifi::DhcpMode(static_cast<int>(config->dhcpMode)));
77 return GetCErrorCode(wifiHid2dPtr->Hid2dConnect(cppConfig));
78 }
79
Hid2dConfigIPAddr(const char ifName[IF_NAME_LEN],const IpAddrInfo * ipInfo)80 WifiErrorCode Hid2dConfigIPAddr(const char ifName[IF_NAME_LEN], const IpAddrInfo* ipInfo)
81 {
82 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
83 CHECK_PTR_RETURN(ipInfo, ERROR_WIFI_INVALID_ARGS);
84
85 OHOS::Wifi::IpAddrInfo ipAddrInfo;
86 ipAddrInfo.ip = OHOS::Wifi::IpArrayToStr(ipInfo->ip);
87 ipAddrInfo.gateway = OHOS::Wifi::IpArrayToStr(ipInfo->gateway);
88 ipAddrInfo.netmask = OHOS::Wifi::IpArrayToStr(ipInfo->netmask);
89 return GetCErrorCode(wifiHid2dPtr->Hid2dConfigIPAddr(ifName, ipAddrInfo));
90 }
91
Hid2dReleaseIPAddr(const char ifName[IF_NAME_LEN])92 WifiErrorCode Hid2dReleaseIPAddr(const char ifName[IF_NAME_LEN])
93 {
94 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
95 return GetCErrorCode(wifiHid2dPtr->Hid2dReleaseIPAddr(ifName));
96 }
97
ConvertRecommendChannelRequest(const RecommendChannelRequest * request,OHOS::Wifi::RecommendChannelRequest & req)98 static void ConvertRecommendChannelRequest(const RecommendChannelRequest *request,
99 OHOS::Wifi::RecommendChannelRequest& req)
100 {
101 CHECK_PTR_RETURN_VOID(request);
102 req.remoteIfName = request->remoteIfName;
103 req.remoteIfMode = request->remoteIfMode;
104 req.localIfName = request->localIfName;
105 req.localIfMode = request->localIfMode;
106 req.prefBand = request->prefBand;
107 req.prefBandwidth = OHOS::Wifi::PreferBandwidth(static_cast<int>(request->prefBandwidth));
108 }
109
ConvertRecommendChannelResponse(const OHOS::Wifi::RecommendChannelResponse & rsp,RecommendChannelResponse * response)110 static void ConvertRecommendChannelResponse(const OHOS::Wifi::RecommendChannelResponse& rsp,
111 RecommendChannelResponse* response)
112 {
113 CHECK_PTR_RETURN_VOID(response);
114 response->status = RecommendStatus(static_cast<int>(rsp.status));
115 response->index = rsp.index;
116 response->centerFreq = rsp.centerFreq;
117 response->centerFreq1 = rsp.centerFreq1;
118 response->centerFreq2 = rsp.centerFreq2;
119 response->bandwidth = rsp.bandwidth;
120 }
121
Hid2dGetRecommendChannel(const RecommendChannelRequest * request,RecommendChannelResponse * response)122 WifiErrorCode Hid2dGetRecommendChannel(const RecommendChannelRequest *request, RecommendChannelResponse *response)
123 {
124 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
125 CHECK_PTR_RETURN(request, ERROR_WIFI_INVALID_ARGS);
126 CHECK_PTR_RETURN(response, ERROR_WIFI_INVALID_ARGS);
127 OHOS::Wifi::RecommendChannelRequest req;
128 OHOS::Wifi::RecommendChannelResponse rsp;
129 ConvertRecommendChannelRequest(request, req);
130 OHOS::Wifi::ErrCode retCode = wifiHid2dPtr->Hid2dGetRecommendChannel(req, rsp);
131 if (retCode != OHOS::Wifi::WIFI_OPT_SUCCESS) {
132 return GetCErrorCode(retCode);
133 }
134 ConvertRecommendChannelResponse(rsp, response);
135 return WIFI_SUCCESS;
136 }
137
Hid2dGetChannelListFor5G(int * chanList,int len)138 WifiErrorCode Hid2dGetChannelListFor5G(int *chanList, int len)
139 {
140 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
141 CHECK_PTR_RETURN(chanList, ERROR_WIFI_INVALID_ARGS);
142
143 std::vector<int> vecChannelList;
144 OHOS::Wifi::ErrCode ret = wifiHid2dPtr->Hid2dGetChannelListFor5G(vecChannelList);
145 if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
146 size_t idx = 0;
147 for (; idx != vecChannelList.size() && (int)(idx + 1) < len; ++idx) {
148 *chanList = vecChannelList[idx];
149 ++chanList;
150 }
151 if (idx != vecChannelList.size()) {
152 WIFI_LOGW("Get channel list for 5G, `chanList` is too small!");
153 }
154 *chanList = 0;
155 }
156 return GetCErrorCode(ret);
157 }
158
Hid2dGetSelfWifiCfgInfo(SelfCfgType cfgType,char cfgData[CFG_DATA_MAX_BYTES],int * getDatValidLen)159 WifiErrorCode Hid2dGetSelfWifiCfgInfo(SelfCfgType cfgType, char cfgData[CFG_DATA_MAX_BYTES], int* getDatValidLen)
160 {
161 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
162 CHECK_PTR_RETURN(getDatValidLen, ERROR_WIFI_INVALID_ARGS);
163 return GetCErrorCode(wifiHid2dPtr->Hid2dGetSelfWifiCfgInfo(
164 OHOS::Wifi::SelfCfgType(static_cast<int>(cfgType)), cfgData, getDatValidLen));
165 }
166
Hid2dSetPeerWifiCfgInfo(PeerCfgType cfgType,char cfgData[CFG_DATA_MAX_BYTES],int setDataValidLen)167 WifiErrorCode Hid2dSetPeerWifiCfgInfo(PeerCfgType cfgType, char cfgData[CFG_DATA_MAX_BYTES], int setDataValidLen)
168 {
169 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
170 return GetCErrorCode(wifiHid2dPtr->Hid2dSetPeerWifiCfgInfo(
171 OHOS::Wifi::PeerCfgType(static_cast<int>(cfgType)), cfgData, setDataValidLen));
172 }
173
Hid2dIsWideBandwidthSupported(void)174 int Hid2dIsWideBandwidthSupported(void)
175 {
176 constexpr int NOT_SUPPORT = 0; // false
177 return NOT_SUPPORT;
178 }
179
Hid2dSetUpperScene(const char ifName[IF_NAME_LEN],const Hid2dUpperScene * scene)180 WifiErrorCode Hid2dSetUpperScene(const char ifName[IF_NAME_LEN], const Hid2dUpperScene *scene)
181 {
182 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
183 CHECK_PTR_RETURN(scene, ERROR_WIFI_INVALID_ARGS);
184 OHOS::Wifi::Hid2dUpperScene upperScene;
185 upperScene.mac = OHOS::Wifi::MacArrayToStr(scene->mac);
186 upperScene.scene = scene->scene;
187 upperScene.fps = scene->fps;
188 upperScene.bw = scene->bw;
189 return GetCErrorCode(wifiHid2dPtr->Hid2dSetUpperScene(ifName, upperScene));
190 }
191