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_2 { 28 namespace implementation { 29 using hidl_return_util::validateAndCall; 30 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 39 void WifiRttController::invalidate() { 40 legacy_hal_.reset(); 41 event_callbacks_.clear(); 42 is_valid_ = false; 43 } 44 45 bool WifiRttController::isValid() { return is_valid_; } 46 47 std::vector<sp<IWifiRttControllerEventCallback>> 48 WifiRttController::getEventCallbacks() { 49 return event_callbacks_; 50 } 51 52 Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) { 53 return validateAndCall( 54 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 55 &WifiRttController::getBoundIfaceInternal, hidl_status_cb); 56 } 57 58 Return<void> WifiRttController::registerEventCallback( 59 const sp<IWifiRttControllerEventCallback>& callback, 60 registerEventCallback_cb hidl_status_cb) { 61 return validateAndCall(this, 62 WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 63 &WifiRttController::registerEventCallbackInternal, 64 hidl_status_cb, callback); 65 } 66 67 Return<void> WifiRttController::rangeRequest( 68 uint32_t cmd_id, const hidl_vec<RttConfig>& rtt_configs, 69 rangeRequest_cb hidl_status_cb) { 70 return validateAndCall(this, 71 WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 72 &WifiRttController::rangeRequestInternal, 73 hidl_status_cb, cmd_id, rtt_configs); 74 } 75 76 Return<void> WifiRttController::rangeCancel( 77 uint32_t cmd_id, const hidl_vec<hidl_array<uint8_t, 6>>& addrs, 78 rangeCancel_cb hidl_status_cb) { 79 return validateAndCall( 80 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 81 &WifiRttController::rangeCancelInternal, hidl_status_cb, cmd_id, addrs); 82 } 83 84 Return<void> WifiRttController::getCapabilities( 85 getCapabilities_cb hidl_status_cb) { 86 return validateAndCall( 87 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 88 &WifiRttController::getCapabilitiesInternal, hidl_status_cb); 89 } 90 91 Return<void> WifiRttController::setLci(uint32_t cmd_id, 92 const RttLciInformation& lci, 93 setLci_cb hidl_status_cb) { 94 return validateAndCall( 95 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 96 &WifiRttController::setLciInternal, hidl_status_cb, cmd_id, lci); 97 } 98 99 Return<void> WifiRttController::setLcr(uint32_t cmd_id, 100 const RttLcrInformation& lcr, 101 setLcr_cb hidl_status_cb) { 102 return validateAndCall( 103 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 104 &WifiRttController::setLcrInternal, hidl_status_cb, cmd_id, lcr); 105 } 106 107 Return<void> WifiRttController::getResponderInfo( 108 getResponderInfo_cb hidl_status_cb) { 109 return validateAndCall( 110 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 111 &WifiRttController::getResponderInfoInternal, hidl_status_cb); 112 } 113 114 Return<void> WifiRttController::enableResponder( 115 uint32_t cmd_id, const WifiChannelInfo& channel_hint, 116 uint32_t max_duration_seconds, const RttResponder& info, 117 enableResponder_cb hidl_status_cb) { 118 return validateAndCall( 119 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 120 &WifiRttController::enableResponderInternal, hidl_status_cb, cmd_id, 121 channel_hint, max_duration_seconds, info); 122 } 123 124 Return<void> WifiRttController::disableResponder( 125 uint32_t cmd_id, disableResponder_cb hidl_status_cb) { 126 return validateAndCall( 127 this, WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID, 128 &WifiRttController::disableResponderInternal, hidl_status_cb, cmd_id); 129 } 130 131 std::pair<WifiStatus, sp<IWifiIface>> 132 WifiRttController::getBoundIfaceInternal() { 133 return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_}; 134 } 135 136 WifiStatus WifiRttController::registerEventCallbackInternal( 137 const sp<IWifiRttControllerEventCallback>& callback) { 138 // TODO(b/31632518): remove the callback when the client is destroyed 139 event_callbacks_.emplace_back(callback); 140 return createWifiStatus(WifiStatusCode::SUCCESS); 141 } 142 143 WifiStatus WifiRttController::rangeRequestInternal( 144 uint32_t cmd_id, const std::vector<RttConfig>& rtt_configs) { 145 std::vector<legacy_hal::wifi_rtt_config> legacy_configs; 146 if (!hidl_struct_util::convertHidlVectorOfRttConfigToLegacy( 147 rtt_configs, &legacy_configs)) { 148 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); 149 } 150 android::wp<WifiRttController> weak_ptr_this(this); 151 const auto& on_results_callback = 152 [weak_ptr_this]( 153 legacy_hal::wifi_request_id id, 154 const std::vector<const legacy_hal::wifi_rtt_result*>& results) { 155 const auto shared_ptr_this = weak_ptr_this.promote(); 156 if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { 157 LOG(ERROR) << "Callback invoked on an invalid object"; 158 return; 159 } 160 std::vector<RttResult> hidl_results; 161 if (!hidl_struct_util::convertLegacyVectorOfRttResultToHidl( 162 results, &hidl_results)) { 163 LOG(ERROR) << "Failed to convert rtt results to HIDL structs"; 164 return; 165 } 166 for (const auto& callback : shared_ptr_this->getEventCallbacks()) { 167 callback->onResults(id, hidl_results); 168 } 169 }; 170 legacy_hal::wifi_error legacy_status = 171 legacy_hal_.lock()->startRttRangeRequest( 172 ifname_, cmd_id, legacy_configs, on_results_callback); 173 return createWifiStatusFromLegacyError(legacy_status); 174 } 175 176 WifiStatus WifiRttController::rangeCancelInternal( 177 uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs) { 178 std::vector<std::array<uint8_t, 6>> legacy_addrs; 179 for (const auto& addr : addrs) { 180 legacy_addrs.push_back(addr); 181 } 182 legacy_hal::wifi_error legacy_status = 183 legacy_hal_.lock()->cancelRttRangeRequest(ifname_, cmd_id, 184 legacy_addrs); 185 return createWifiStatusFromLegacyError(legacy_status); 186 } 187 188 std::pair<WifiStatus, RttCapabilities> 189 WifiRttController::getCapabilitiesInternal() { 190 legacy_hal::wifi_error legacy_status; 191 legacy_hal::wifi_rtt_capabilities legacy_caps; 192 std::tie(legacy_status, legacy_caps) = 193 legacy_hal_.lock()->getRttCapabilities(ifname_); 194 if (legacy_status != legacy_hal::WIFI_SUCCESS) { 195 return {createWifiStatusFromLegacyError(legacy_status), {}}; 196 } 197 RttCapabilities hidl_caps; 198 if (!hidl_struct_util::convertLegacyRttCapabilitiesToHidl(legacy_caps, 199 &hidl_caps)) { 200 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; 201 } 202 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps}; 203 } 204 205 WifiStatus WifiRttController::setLciInternal(uint32_t cmd_id, 206 const RttLciInformation& lci) { 207 legacy_hal::wifi_lci_information legacy_lci; 208 if (!hidl_struct_util::convertHidlRttLciInformationToLegacy(lci, 209 &legacy_lci)) { 210 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); 211 } 212 legacy_hal::wifi_error legacy_status = 213 legacy_hal_.lock()->setRttLci(ifname_, cmd_id, legacy_lci); 214 return createWifiStatusFromLegacyError(legacy_status); 215 } 216 217 WifiStatus WifiRttController::setLcrInternal(uint32_t cmd_id, 218 const RttLcrInformation& lcr) { 219 legacy_hal::wifi_lcr_information legacy_lcr; 220 if (!hidl_struct_util::convertHidlRttLcrInformationToLegacy(lcr, 221 &legacy_lcr)) { 222 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); 223 } 224 legacy_hal::wifi_error legacy_status = 225 legacy_hal_.lock()->setRttLcr(ifname_, cmd_id, legacy_lcr); 226 return createWifiStatusFromLegacyError(legacy_status); 227 } 228 229 std::pair<WifiStatus, RttResponder> 230 WifiRttController::getResponderInfoInternal() { 231 legacy_hal::wifi_error legacy_status; 232 legacy_hal::wifi_rtt_responder legacy_responder; 233 std::tie(legacy_status, legacy_responder) = 234 legacy_hal_.lock()->getRttResponderInfo(ifname_); 235 if (legacy_status != legacy_hal::WIFI_SUCCESS) { 236 return {createWifiStatusFromLegacyError(legacy_status), {}}; 237 } 238 RttResponder hidl_responder; 239 if (!hidl_struct_util::convertLegacyRttResponderToHidl(legacy_responder, 240 &hidl_responder)) { 241 return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}}; 242 } 243 return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_responder}; 244 } 245 246 WifiStatus WifiRttController::enableResponderInternal( 247 uint32_t cmd_id, const WifiChannelInfo& channel_hint, 248 uint32_t max_duration_seconds, const RttResponder& info) { 249 legacy_hal::wifi_channel_info legacy_channel_info; 250 if (!hidl_struct_util::convertHidlWifiChannelInfoToLegacy( 251 channel_hint, &legacy_channel_info)) { 252 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); 253 } 254 legacy_hal::wifi_rtt_responder legacy_responder; 255 if (!hidl_struct_util::convertHidlRttResponderToLegacy(info, 256 &legacy_responder)) { 257 return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); 258 } 259 legacy_hal::wifi_error legacy_status = 260 legacy_hal_.lock()->enableRttResponder( 261 ifname_, cmd_id, legacy_channel_info, max_duration_seconds, 262 legacy_responder); 263 return createWifiStatusFromLegacyError(legacy_status); 264 } 265 266 WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) { 267 legacy_hal::wifi_error legacy_status = 268 legacy_hal_.lock()->disableRttResponder(ifname_, cmd_id); 269 return createWifiStatusFromLegacyError(legacy_status); 270 } 271 } // namespace implementation 272 } // namespace V1_2 273 } // namespace wifi 274 } // namespace hardware 275 } // namespace android 276
