1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <android-base/logging.h>
18
19 #include "hidl_return_util.h"
20 #include "hidl_struct_util.h"
21 #include "wifi_rtt_controller.h"
22 #include "wifi_status_util.h"
23
24 namespace android {
25 namespace hardware {
26 namespace wifi {
27 namespace V1_3 {
28 namespace implementation {
29 using hidl_return_util::validateAndCall;
30
WifiRttController(const std::string & iface_name,const sp<IWifiIface> & bound_iface,const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)31 WifiRttController::WifiRttController(
32 const std::string& iface_name, const sp<IWifiIface>& bound_iface,
33 const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal)
34 : ifname_(iface_name),
35 bound_iface_(bound_iface),
36 legacy_hal_(legacy_hal),
37 is_valid_(true) {}
38
invalidate()39 void WifiRttController::invalidate() {
40 legacy_hal_.reset();
41 event_callbacks_.clear();
42 is_valid_ = false;
43 }
44
isValid()45 bool WifiRttController::isValid() { return is_valid_; }
46
47 std::vector<sp<IWifiRttControllerEventCallback>>
getEventCallbacks()48 WifiRttController::getEventCallbacks() {
49 return event_callbacks_;
50 }
51
getIfaceName()52 std::string WifiRttController::getIfaceName() { return ifname_; }
53
getBoundIface(getBoundIface_cb hidl_status_cb)54 Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {
55 return validateAndCall(
56 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
57 &WifiRttController::getBoundIfaceInternal, hidl_status_cb);
58 }
59
registerEventCallback(const sp<IWifiRttControllerEventCallback> & callback,registerEventCallback_cb hidl_status_cb)60 Return<void> WifiRttController::registerEventCallback(
61 const sp<IWifiRttControllerEventCallback>& callback,
62 registerEventCallback_cb hidl_status_cb) {
63 return validateAndCall(this,
64 WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
65 &WifiRttController::registerEventCallbackInternal,
66 hidl_status_cb, callback);
67 }
68
rangeRequest(uint32_t cmd_id,const hidl_vec<RttConfig> & rtt_configs,rangeRequest_cb hidl_status_cb)69 Return<void> WifiRttController::rangeRequest(
70 uint32_t cmd_id, const hidl_vec<RttConfig>& rtt_configs,
71 rangeRequest_cb hidl_status_cb) {
72 return validateAndCall(this,
73 WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
74 &WifiRttController::rangeRequestInternal,
75 hidl_status_cb, cmd_id, rtt_configs);
76 }
77
rangeCancel(uint32_t cmd_id,const hidl_vec<hidl_array<uint8_t,6>> & addrs,rangeCancel_cb hidl_status_cb)78 Return<void> WifiRttController::rangeCancel(
79 uint32_t cmd_id, const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
80 rangeCancel_cb hidl_status_cb) {
81 return validateAndCall(
82 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
83 &WifiRttController::rangeCancelInternal, hidl_status_cb, cmd_id, addrs);
84 }
85
getCapabilities(getCapabilities_cb hidl_status_cb)86 Return<void> WifiRttController::getCapabilities(
87 getCapabilities_cb hidl_status_cb) {
88 return validateAndCall(
89 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
90 &WifiRttController::getCapabilitiesInternal, hidl_status_cb);
91 }
92
setLci(uint32_t cmd_id,const RttLciInformation & lci,setLci_cb hidl_status_cb)93 Return<void> WifiRttController::setLci(uint32_t cmd_id,
94 const RttLciInformation& lci,
95 setLci_cb hidl_status_cb) {
96 return validateAndCall(
97 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
98 &WifiRttController::setLciInternal, hidl_status_cb, cmd_id, lci);
99 }
100
setLcr(uint32_t cmd_id,const RttLcrInformation & lcr,setLcr_cb hidl_status_cb)101 Return<void> WifiRttController::setLcr(uint32_t cmd_id,
102 const RttLcrInformation& lcr,
103 setLcr_cb hidl_status_cb) {
104 return validateAndCall(
105 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
106 &WifiRttController::setLcrInternal, hidl_status_cb, cmd_id, lcr);
107 }
108
getResponderInfo(getResponderInfo_cb hidl_status_cb)109 Return<void> WifiRttController::getResponderInfo(
110 getResponderInfo_cb hidl_status_cb) {
111 return validateAndCall(
112 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
113 &WifiRttController::getResponderInfoInternal, hidl_status_cb);
114 }
115
enableResponder(uint32_t cmd_id,const WifiChannelInfo & channel_hint,uint32_t max_duration_seconds,const RttResponder & info,enableResponder_cb hidl_status_cb)116 Return<void> WifiRttController::enableResponder(
117 uint32_t cmd_id, const WifiChannelInfo& channel_hint,
118 uint32_t max_duration_seconds, const RttResponder& info,
119 enableResponder_cb hidl_status_cb) {
120 return validateAndCall(
121 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
122 &WifiRttController::enableResponderInternal, hidl_status_cb, cmd_id,
123 channel_hint, max_duration_seconds, info);
124 }
125
disableResponder(uint32_t cmd_id,disableResponder_cb hidl_status_cb)126 Return<void> WifiRttController::disableResponder(
127 uint32_t cmd_id, disableResponder_cb hidl_status_cb) {
128 return validateAndCall(
129 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
130 &WifiRttController::disableResponderInternal, hidl_status_cb, cmd_id);
131 }
132
133 std::pair<WifiStatus, sp<IWifiIface>>
getBoundIfaceInternal()134 WifiRttController::getBoundIfaceInternal() {
135 return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_};
136 }
137
registerEventCallbackInternal(const sp<IWifiRttControllerEventCallback> & callback)138 WifiStatus WifiRttController::registerEventCallbackInternal(
139 const sp<IWifiRttControllerEventCallback>& callback) {
140 // TODO(b/31632518): remove the callback when the client is destroyed
141 event_callbacks_.emplace_back(callback);
142 return createWifiStatus(WifiStatusCode::SUCCESS);
143 }
144
rangeRequestInternal(uint32_t cmd_id,const std::vector<RttConfig> & rtt_configs)145 WifiStatus WifiRttController::rangeRequestInternal(
146 uint32_t cmd_id, const std::vector<RttConfig>& rtt_configs) {
147 std::vector<legacy_hal::wifi_rtt_config> legacy_configs;
148 if (!hidl_struct_util::convertHidlVectorOfRttConfigToLegacy(
149 rtt_configs, &legacy_configs)) {
150 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
151 }
152 android::wp<WifiRttController> weak_ptr_this(this);
153 const auto& on_results_callback =
154 [weak_ptr_this](
155 legacy_hal::wifi_request_id id,
156 const std::vector<const legacy_hal::wifi_rtt_result*>& results) {
157 const auto shared_ptr_this = weak_ptr_this.promote();
158 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
159 LOG(ERROR) << "Callback invoked on an invalid object";
160 return;
161 }
162 std::vector<RttResult> hidl_results;
163 if (!hidl_struct_util::convertLegacyVectorOfRttResultToHidl(
164 results, &hidl_results)) {
165 LOG(ERROR) << "Failed to convert rtt results to HIDL structs";
166 return;
167 }
168 for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
169 callback->onResults(id, hidl_results);
170 }
171 };
172 legacy_hal::wifi_error legacy_status =
173 legacy_hal_.lock()->startRttRangeRequest(
174 ifname_, cmd_id, legacy_configs, on_results_callback);
175 return createWifiStatusFromLegacyError(legacy_status);
176 }
177
rangeCancelInternal(uint32_t cmd_id,const std::vector<hidl_array<uint8_t,6>> & addrs)178 WifiStatus WifiRttController::rangeCancelInternal(
179 uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs) {
180 std::vector<std::array<uint8_t, 6>> legacy_addrs;
181 for (const auto& addr : addrs) {
182 legacy_addrs.push_back(addr);
183 }
184 legacy_hal::wifi_error legacy_status =
185 legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id,
186 legacy_addrs);
187 return createWifiStatusFromLegacyError(legacy_status);
188 }
189
190 std::pair<WifiStatus, RttCapabilities>
getCapabilitiesInternal()191 WifiRttController::getCapabilitiesInternal() {
192 legacy_hal::wifi_error legacy_status;
193 legacy_hal::wifi_rtt_capabilities legacy_caps;
194 std::tie(legacy_status, legacy_caps) =
195 legacy_hal_.lock()->getRttCapabilities(ifname_);
196 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
197 return {createWifiStatusFromLegacyError(legacy_status), {}};
198 }
199 RttCapabilities hidl_caps;
200 if (!hidl_struct_util::convertLegacyRttCapabilitiesToHidl(legacy_caps,
201 &hidl_caps)) {
202 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
203 }
204 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
205 }
206
setLciInternal(uint32_t cmd_id,const RttLciInformation & lci)207 WifiStatus WifiRttController::setLciInternal(uint32_t cmd_id,
208 const RttLciInformation& lci) {
209 legacy_hal::wifi_lci_information legacy_lci;
210 if (!hidl_struct_util::convertHidlRttLciInformationToLegacy(lci,
211 &legacy_lci)) {
212 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
213 }
214 legacy_hal::wifi_error legacy_status =
215 legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci);
216 return createWifiStatusFromLegacyError(legacy_status);
217 }
218
setLcrInternal(uint32_t cmd_id,const RttLcrInformation & lcr)219 WifiStatus WifiRttController::setLcrInternal(uint32_t cmd_id,
220 const RttLcrInformation& lcr) {
221 legacy_hal::wifi_lcr_information legacy_lcr;
222 if (!hidl_struct_util::convertHidlRttLcrInformationToLegacy(lcr,
223 &legacy_lcr)) {
224 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
225 }
226 legacy_hal::wifi_error legacy_status =
227 legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr);
228 return createWifiStatusFromLegacyError(legacy_status);
229 }
230
231 std::pair<WifiStatus, RttResponder>
getResponderInfoInternal()232 WifiRttController::getResponderInfoInternal() {
233 legacy_hal::wifi_error legacy_status;
234 legacy_hal::wifi_rtt_responder legacy_responder;
235 std::tie(legacy_status, legacy_responder) =
236 legacy_hal_.lock()->getRttResponderInfo(ifname_);
237 if (legacy_status != legacy_hal::WIFI_SUCCESS) {
238 return {createWifiStatusFromLegacyError(legacy_status), {}};
239 }
240 RttResponder hidl_responder;
241 if (!hidl_struct_util::convertLegacyRttResponderToHidl(legacy_responder,
242 &hidl_responder)) {
243 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
244 }
245 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_responder};
246 }
247
enableResponderInternal(uint32_t cmd_id,const WifiChannelInfo & channel_hint,uint32_t max_duration_seconds,const RttResponder & info)248 WifiStatus WifiRttController::enableResponderInternal(
249 uint32_t cmd_id, const WifiChannelInfo& channel_hint,
250 uint32_t max_duration_seconds, const RttResponder& info) {
251 legacy_hal::wifi_channel_info legacy_channel_info;
252 if (!hidl_struct_util::convertHidlWifiChannelInfoToLegacy(
253 channel_hint, &legacy_channel_info)) {
254 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
255 }
256 legacy_hal::wifi_rtt_responder legacy_responder;
257 if (!hidl_struct_util::convertHidlRttResponderToLegacy(info,
258 &legacy_responder)) {
259 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
260 }
261 legacy_hal::wifi_error legacy_status =
262 legacy_hal_.lock()->enableRttResponder(
263 ifname_, cmd_id, legacy_channel_info, max_duration_seconds,
264 legacy_responder);
265 return createWifiStatusFromLegacyError(legacy_status);
266 }
267
disableResponderInternal(uint32_t cmd_id)268 WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) {
269 legacy_hal::wifi_error legacy_status =
270 legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id);
271 return createWifiStatusFromLegacyError(legacy_status);
272 }
273 } // namespace implementation
274 } // namespace V1_3
275 } // namespace wifi
276 } // namespace hardware
277 } // namespace android
278