Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 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 | |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 17 | #include <android-base/logging.h> |
| 18 | |
Roshan Pius | 907d4a2 | 2016-10-27 12:48:12 -0700 | [diff] [blame] | 19 | #include "hidl_return_util.h" |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 20 | #include "hidl_struct_util.h" |
Roshan Pius | 907d4a2 | 2016-10-27 12:48:12 -0700 | [diff] [blame] | 21 | #include "wifi_nan_iface.h" |
Roshan Pius | 734fea0 | 2016-10-11 08:30:28 -0700 | [diff] [blame] | 22 | #include "wifi_status_util.h" |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 23 | |
| 24 | namespace android { |
| 25 | namespace hardware { |
| 26 | namespace wifi { |
| 27 | namespace V1_0 { |
| 28 | namespace implementation { |
Roshan Pius | 907d4a2 | 2016-10-27 12:48:12 -0700 | [diff] [blame] | 29 | using hidl_return_util::validateAndCall; |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 30 | |
Roshan Pius | 6cedc97 | 2016-10-28 10:11:17 -0700 | [diff] [blame] | 31 | WifiNanIface::WifiNanIface( |
| 32 | const std::string& ifname, |
| 33 | const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal) |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 34 | : ifname_(ifname), legacy_hal_(legacy_hal), is_valid_(true) { |
| 35 | // Register all the callbacks here. these should be valid for the lifetime |
| 36 | // of the object. Whenever the mode changes legacy HAL will remove |
| 37 | // all of these callbacks. |
| 38 | legacy_hal::NanCallbackHandlers callback_handlers; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 39 | android::wp<WifiNanIface> weak_ptr_this(this); |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 40 | |
| 41 | // Callback for response. |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 42 | callback_handlers.on_notify_response = [weak_ptr_this]( |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 43 | legacy_hal::transaction_id id, const legacy_hal::NanResponseMsg& msg) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 44 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 45 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 46 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 47 | return; |
| 48 | } |
| 49 | WifiNanStatus wifiNanStatus; |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 50 | if (!hidl_struct_util::convertLegacyNanResponseHeaderToHidl(msg, |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 51 | &wifiNanStatus)) { |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 52 | LOG(ERROR) << "Failed to convert nan response header"; |
| 53 | return; |
| 54 | } |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 55 | |
| 56 | switch (msg.response_type) { |
| 57 | case legacy_hal::NAN_RESPONSE_ENABLED: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 58 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 59 | if (!callback->notifyEnableResponse(id, wifiNanStatus).isOk()) { |
| 60 | LOG(ERROR) << "Failed to invoke the callback"; |
| 61 | } |
| 62 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 63 | break; |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 64 | } |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 65 | case legacy_hal::NAN_RESPONSE_DISABLED: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 66 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 67 | if (!callback->notifyDisableResponse(id, wifiNanStatus).isOk()) { |
| 68 | LOG(ERROR) << "Failed to invoke the callback"; |
| 69 | } |
| 70 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 71 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 72 | } |
| 73 | case legacy_hal::NAN_RESPONSE_PUBLISH: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 74 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 75 | if (!callback->notifyStartPublishResponse(id, wifiNanStatus, |
| 76 | msg.body.publish_response.publish_id).isOk()) { |
| 77 | LOG(ERROR) << "Failed to invoke the callback"; |
| 78 | } |
| 79 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 80 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 81 | } |
| 82 | case legacy_hal::NAN_RESPONSE_PUBLISH_CANCEL: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 83 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 84 | if (!callback->notifyStopPublishResponse(id, wifiNanStatus).isOk()) { |
| 85 | LOG(ERROR) << "Failed to invoke the callback"; |
| 86 | } |
| 87 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 88 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 89 | } |
| 90 | case legacy_hal::NAN_RESPONSE_TRANSMIT_FOLLOWUP: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 91 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 92 | if (!callback->notifyTransmitFollowupResponse(id, wifiNanStatus).isOk()) { |
| 93 | LOG(ERROR) << "Failed to invoke the callback"; |
| 94 | } |
| 95 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 96 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 97 | } |
| 98 | case legacy_hal::NAN_RESPONSE_SUBSCRIBE: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 99 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 100 | if (!callback->notifyStartSubscribeResponse(id, wifiNanStatus, |
| 101 | msg.body.subscribe_response.subscribe_id).isOk()) { |
| 102 | LOG(ERROR) << "Failed to invoke the callback"; |
| 103 | } |
| 104 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 105 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 106 | } |
| 107 | case legacy_hal::NAN_RESPONSE_SUBSCRIBE_CANCEL: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 108 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 109 | if (!callback->notifyStopSubscribeResponse(id, wifiNanStatus).isOk()) { |
| 110 | LOG(ERROR) << "Failed to invoke the callback"; |
| 111 | } |
| 112 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 113 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 114 | } |
| 115 | case legacy_hal::NAN_RESPONSE_CONFIG: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 116 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 117 | if (!callback->notifyConfigResponse(id, wifiNanStatus).isOk()) { |
| 118 | LOG(ERROR) << "Failed to invoke the callback"; |
| 119 | } |
| 120 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 121 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 122 | } |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 123 | case legacy_hal::NAN_GET_CAPABILITIES: { |
| 124 | NanCapabilities hidl_struct; |
| 125 | if (!hidl_struct_util::convertLegacyNanCapabilitiesResponseToHidl( |
| 126 | msg.body.nan_capabilities, &hidl_struct)) { |
| 127 | LOG(ERROR) << "Failed to convert nan capabilities response"; |
| 128 | return; |
| 129 | } |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 130 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 131 | if (!callback->notifyCapabilitiesResponse(id, wifiNanStatus, |
| 132 | hidl_struct).isOk()) { |
| 133 | LOG(ERROR) << "Failed to invoke the callback"; |
| 134 | } |
| 135 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 136 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 137 | } |
| 138 | case legacy_hal::NAN_DP_INTERFACE_CREATE: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 139 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 140 | if (!callback->notifyCreateDataInterfaceResponse(id, wifiNanStatus).isOk()) { |
| 141 | LOG(ERROR) << "Failed to invoke the callback"; |
| 142 | } |
| 143 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 144 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 145 | } |
| 146 | case legacy_hal::NAN_DP_INTERFACE_DELETE: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 147 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 148 | if (!callback->notifyDeleteDataInterfaceResponse(id, wifiNanStatus).isOk()) { |
| 149 | LOG(ERROR) << "Failed to invoke the callback"; |
| 150 | } |
| 151 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 152 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 153 | } |
| 154 | case legacy_hal::NAN_DP_INITIATOR_RESPONSE: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 155 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 156 | if (!callback->notifyInitiateDataPathResponse(id, wifiNanStatus, |
| 157 | msg.body.data_request_response.ndp_instance_id).isOk()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 158 | LOG(ERROR) << "Failed to invoke the callback"; |
| 159 | } |
| 160 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 161 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 162 | } |
| 163 | case legacy_hal::NAN_DP_RESPONDER_RESPONSE: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 164 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 165 | if (!callback->notifyRespondToDataPathIndicationResponse(id, wifiNanStatus).isOk()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 166 | LOG(ERROR) << "Failed to invoke the callback"; |
| 167 | } |
| 168 | } |
Etan Cohen | 3c5d8ae | 2017-02-22 12:54:20 -0800 | [diff] [blame] | 169 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 170 | } |
| 171 | case legacy_hal::NAN_DP_END: { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 172 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 173 | if (!callback->notifyTerminateDataPathResponse(id, wifiNanStatus).isOk()) { |
| 174 | LOG(ERROR) << "Failed to invoke the callback"; |
| 175 | } |
| 176 | } |
Etan Cohen | 4bbc209 | 2017-01-30 13:28:37 -0800 | [diff] [blame] | 177 | break; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 178 | } |
Etan Cohen | ccb1562 | 2017-02-09 09:35:35 -0800 | [diff] [blame] | 179 | case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD: |
| 180 | /* fall through */ |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 181 | case legacy_hal::NAN_RESPONSE_TCA: |
| 182 | /* fall through */ |
| 183 | case legacy_hal::NAN_RESPONSE_STATS: |
| 184 | /* fall through */ |
| 185 | case legacy_hal::NAN_RESPONSE_ERROR: |
| 186 | /* fall through */ |
| 187 | default: |
| 188 | LOG(ERROR) << "Unknown or unhandled response type: " << msg.response_type; |
| 189 | return; |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 190 | } |
| 191 | }; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 192 | |
| 193 | callback_handlers.on_event_disc_eng_event = [weak_ptr_this]( |
| 194 | const legacy_hal::NanDiscEngEventInd& msg) { |
| 195 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 196 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 197 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 198 | return; |
| 199 | } |
| 200 | NanClusterEventInd hidl_struct; |
| 201 | // event types defined identically - hence can be cast |
| 202 | hidl_struct.eventType = (NanClusterEventType) msg.event_type; |
| 203 | hidl_struct.addr = msg.data.mac_addr.addr; |
| 204 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 205 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 206 | if (!callback->eventClusterEvent(hidl_struct).isOk()) { |
| 207 | LOG(ERROR) << "Failed to invoke the callback"; |
| 208 | } |
| 209 | } |
| 210 | }; |
| 211 | |
| 212 | callback_handlers.on_event_disabled = [weak_ptr_this]( |
| 213 | const legacy_hal::NanDisabledInd& msg) { |
| 214 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 215 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 216 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 217 | return; |
| 218 | } |
| 219 | WifiNanStatus status; |
Etan Cohen | bbc0f09 | 2017-04-26 16:52:34 -0700 | [diff] [blame] | 220 | hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason), |
| 221 | &status); |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 222 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 223 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 224 | if (!callback->eventDisabled(status).isOk()) { |
| 225 | LOG(ERROR) << "Failed to invoke the callback"; |
| 226 | } |
| 227 | } |
| 228 | }; |
| 229 | |
| 230 | callback_handlers.on_event_publish_terminated = [weak_ptr_this]( |
| 231 | const legacy_hal::NanPublishTerminatedInd& msg) { |
| 232 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 233 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 234 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 235 | return; |
| 236 | } |
| 237 | WifiNanStatus status; |
Etan Cohen | bbc0f09 | 2017-04-26 16:52:34 -0700 | [diff] [blame] | 238 | hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason), |
| 239 | &status); |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 240 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 241 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 242 | if (!callback->eventPublishTerminated(msg.publish_id, status).isOk()) { |
| 243 | LOG(ERROR) << "Failed to invoke the callback"; |
| 244 | } |
| 245 | } |
| 246 | }; |
| 247 | |
| 248 | callback_handlers.on_event_subscribe_terminated = [weak_ptr_this]( |
| 249 | const legacy_hal::NanSubscribeTerminatedInd& msg) { |
| 250 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 251 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 252 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 253 | return; |
| 254 | } |
| 255 | WifiNanStatus status; |
Etan Cohen | bbc0f09 | 2017-04-26 16:52:34 -0700 | [diff] [blame] | 256 | hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason), |
| 257 | &status); |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 258 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 259 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 260 | if (!callback->eventSubscribeTerminated(msg.subscribe_id, status).isOk()) { |
| 261 | LOG(ERROR) << "Failed to invoke the callback"; |
| 262 | } |
| 263 | } |
| 264 | }; |
| 265 | |
| 266 | callback_handlers.on_event_match = [weak_ptr_this]( |
| 267 | const legacy_hal::NanMatchInd& msg) { |
| 268 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 269 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 270 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 271 | return; |
| 272 | } |
| 273 | NanMatchInd hidl_struct; |
| 274 | if (!hidl_struct_util::convertLegacyNanMatchIndToHidl( |
| 275 | msg, &hidl_struct)) { |
| 276 | LOG(ERROR) << "Failed to convert nan capabilities response"; |
| 277 | return; |
| 278 | } |
| 279 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 280 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 281 | if (!callback->eventMatch(hidl_struct).isOk()) { |
| 282 | LOG(ERROR) << "Failed to invoke the callback"; |
| 283 | } |
| 284 | } |
| 285 | }; |
| 286 | |
| 287 | callback_handlers.on_event_match_expired = [weak_ptr_this]( |
| 288 | const legacy_hal::NanMatchExpiredInd& msg) { |
| 289 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 290 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 291 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 292 | return; |
| 293 | } |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 294 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 295 | if (!callback->eventMatchExpired(msg.publish_subscribe_id, |
| 296 | msg.requestor_instance_id).isOk()) { |
| 297 | LOG(ERROR) << "Failed to invoke the callback"; |
| 298 | } |
| 299 | } |
| 300 | }; |
| 301 | |
| 302 | callback_handlers.on_event_followup = [weak_ptr_this]( |
| 303 | const legacy_hal::NanFollowupInd& msg) { |
| 304 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 305 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 306 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 307 | return; |
| 308 | } |
| 309 | NanFollowupReceivedInd hidl_struct; |
| 310 | if (!hidl_struct_util::convertLegacyNanFollowupIndToHidl( |
| 311 | msg, &hidl_struct)) { |
| 312 | LOG(ERROR) << "Failed to convert nan capabilities response"; |
| 313 | return; |
| 314 | } |
| 315 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 316 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 317 | if (!callback->eventFollowupReceived(hidl_struct).isOk()) { |
| 318 | LOG(ERROR) << "Failed to invoke the callback"; |
| 319 | } |
| 320 | } |
| 321 | }; |
| 322 | |
| 323 | callback_handlers.on_event_transmit_follow_up = [weak_ptr_this]( |
| 324 | const legacy_hal::NanTransmitFollowupInd& msg) { |
| 325 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 326 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 327 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 328 | return; |
| 329 | } |
| 330 | WifiNanStatus status; |
Etan Cohen | bbc0f09 | 2017-04-26 16:52:34 -0700 | [diff] [blame] | 331 | hidl_struct_util::convertToWifiNanStatus(msg.reason, msg.nan_reason, sizeof(msg.nan_reason), |
| 332 | &status); |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 333 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 334 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 335 | if (!callback->eventTransmitFollowup(msg.id, status).isOk()) { |
| 336 | LOG(ERROR) << "Failed to invoke the callback"; |
| 337 | } |
| 338 | } |
| 339 | }; |
| 340 | |
| 341 | callback_handlers.on_event_data_path_request = [weak_ptr_this]( |
| 342 | const legacy_hal::NanDataPathRequestInd& msg) { |
| 343 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 344 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 345 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 346 | return; |
| 347 | } |
| 348 | NanDataPathRequestInd hidl_struct; |
| 349 | if (!hidl_struct_util::convertLegacyNanDataPathRequestIndToHidl( |
| 350 | msg, &hidl_struct)) { |
| 351 | LOG(ERROR) << "Failed to convert nan capabilities response"; |
| 352 | return; |
| 353 | } |
| 354 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 355 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 356 | if (!callback->eventDataPathRequest(hidl_struct).isOk()) { |
| 357 | LOG(ERROR) << "Failed to invoke the callback"; |
| 358 | } |
| 359 | } |
| 360 | }; |
| 361 | |
| 362 | callback_handlers.on_event_data_path_confirm = [weak_ptr_this]( |
| 363 | const legacy_hal::NanDataPathConfirmInd& msg) { |
| 364 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 365 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 366 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 367 | return; |
| 368 | } |
| 369 | NanDataPathConfirmInd hidl_struct; |
| 370 | if (!hidl_struct_util::convertLegacyNanDataPathConfirmIndToHidl( |
| 371 | msg, &hidl_struct)) { |
| 372 | LOG(ERROR) << "Failed to convert nan capabilities response"; |
| 373 | return; |
| 374 | } |
| 375 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 376 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 377 | if (!callback->eventDataPathConfirm(hidl_struct).isOk()) { |
| 378 | LOG(ERROR) << "Failed to invoke the callback"; |
| 379 | } |
| 380 | } |
| 381 | }; |
| 382 | |
| 383 | callback_handlers.on_event_data_path_end = [weak_ptr_this]( |
| 384 | const legacy_hal::NanDataPathEndInd& msg) { |
| 385 | const auto shared_ptr_this = weak_ptr_this.promote(); |
| 386 | if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { |
| 387 | LOG(ERROR) << "Callback invoked on an invalid object"; |
| 388 | return; |
| 389 | } |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 390 | for (const auto& callback : shared_ptr_this->getEventCallbacks()) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 391 | for (int i = 0; i < msg.num_ndp_instances; ++i) { |
| 392 | if (!callback->eventDataPathTerminated(msg.ndp_instance_id[i]).isOk()) { |
| 393 | LOG(ERROR) << "Failed to invoke the callback"; |
| 394 | } |
| 395 | } |
| 396 | } |
| 397 | }; |
| 398 | |
| 399 | callback_handlers.on_event_beacon_sdf_payload = [weak_ptr_this]( |
Etan Cohen | ccb1562 | 2017-02-09 09:35:35 -0800 | [diff] [blame] | 400 | const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) { |
| 401 | LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called"; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 402 | }; |
| 403 | |
Etan Cohen | c190f93 | 2017-02-17 13:06:55 -0800 | [diff] [blame] | 404 | callback_handlers.on_event_range_request = [weak_ptr_this]( |
| 405 | const legacy_hal::NanRangeRequestInd& /* msg */) { |
| 406 | LOG(ERROR) << "on_event_range_request - should not be called"; |
| 407 | }; |
| 408 | |
| 409 | callback_handlers.on_event_range_report = [weak_ptr_this]( |
| 410 | const legacy_hal::NanRangeReportInd& /* msg */) { |
| 411 | LOG(ERROR) << "on_event_range_report - should not be called"; |
| 412 | }; |
| 413 | |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 414 | legacy_hal::wifi_error legacy_status = |
| 415 | legacy_hal_.lock()->nanRegisterCallbackHandlers(callback_handlers); |
| 416 | if (legacy_status != legacy_hal::WIFI_SUCCESS) { |
| 417 | LOG(ERROR) << "Failed to register nan callbacks. Invalidating object"; |
| 418 | invalidate(); |
| 419 | } |
| 420 | } |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 421 | |
| 422 | void WifiNanIface::invalidate() { |
Etan Cohen | c4d9f87 | 2017-06-15 08:39:23 -0700 | [diff] [blame^] | 423 | // send commands to HAL to actually disable and destroy interfaces |
| 424 | legacy_hal_.lock()->nanDisableRequest(0xFFFF); |
| 425 | legacy_hal_.lock()->nanDataInterfaceDelete(0xFFFE, "aware_data0"); |
| 426 | legacy_hal_.lock()->nanDataInterfaceDelete(0xFFFD, "aware_data1"); |
| 427 | |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 428 | legacy_hal_.reset(); |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 429 | event_cb_handler_.invalidate(); |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 430 | is_valid_ = false; |
| 431 | } |
| 432 | |
Roshan Pius | 907d4a2 | 2016-10-27 12:48:12 -0700 | [diff] [blame] | 433 | bool WifiNanIface::isValid() { |
| 434 | return is_valid_; |
| 435 | } |
| 436 | |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 437 | std::set<sp<IWifiNanIfaceEventCallback>> WifiNanIface::getEventCallbacks() { |
| 438 | return event_cb_handler_.getCallbacks(); |
| 439 | } |
| 440 | |
Roshan Pius | 734fea0 | 2016-10-11 08:30:28 -0700 | [diff] [blame] | 441 | Return<void> WifiNanIface::getName(getName_cb hidl_status_cb) { |
Roshan Pius | 907d4a2 | 2016-10-27 12:48:12 -0700 | [diff] [blame] | 442 | return validateAndCall(this, |
| 443 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 444 | &WifiNanIface::getNameInternal, |
| 445 | hidl_status_cb); |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 446 | } |
| 447 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 448 | Return<void> WifiNanIface::getType(getType_cb hidl_status_cb) { |
| 449 | return validateAndCall(this, |
| 450 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 451 | &WifiNanIface::getTypeInternal, |
| 452 | hidl_status_cb); |
| 453 | } |
| 454 | |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 455 | Return<void> WifiNanIface::registerEventCallback( |
| 456 | const sp<IWifiNanIfaceEventCallback>& callback, |
| 457 | registerEventCallback_cb hidl_status_cb) { |
| 458 | return validateAndCall(this, |
| 459 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 460 | &WifiNanIface::registerEventCallbackInternal, |
| 461 | hidl_status_cb, |
| 462 | callback); |
| 463 | } |
| 464 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 465 | Return<void> WifiNanIface::getCapabilitiesRequest(uint16_t cmd_id, |
| 466 | getCapabilitiesRequest_cb hidl_status_cb) { |
| 467 | return validateAndCall(this, |
| 468 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 469 | &WifiNanIface::getCapabilitiesRequestInternal, |
| 470 | hidl_status_cb, |
| 471 | cmd_id); |
| 472 | } |
| 473 | |
| 474 | Return<void> WifiNanIface::enableRequest(uint16_t cmd_id, |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 475 | const NanEnableRequest& msg, |
| 476 | enableRequest_cb hidl_status_cb) { |
| 477 | return validateAndCall(this, |
| 478 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 479 | &WifiNanIface::enableRequestInternal, |
| 480 | hidl_status_cb, |
| 481 | cmd_id, |
| 482 | msg); |
| 483 | } |
| 484 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 485 | Return<void> WifiNanIface::configRequest(uint16_t cmd_id, |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 486 | const NanConfigRequest& msg, |
| 487 | configRequest_cb hidl_status_cb) { |
| 488 | return validateAndCall(this, |
| 489 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 490 | &WifiNanIface::configRequestInternal, |
| 491 | hidl_status_cb, |
| 492 | cmd_id, |
| 493 | msg); |
| 494 | } |
| 495 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 496 | Return<void> WifiNanIface::disableRequest(uint16_t cmd_id, |
| 497 | disableRequest_cb hidl_status_cb) { |
| 498 | return validateAndCall(this, |
| 499 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 500 | &WifiNanIface::disableRequestInternal, |
| 501 | hidl_status_cb, |
| 502 | cmd_id); |
| 503 | } |
| 504 | |
| 505 | Return<void> WifiNanIface::startPublishRequest(uint16_t cmd_id, |
| 506 | const NanPublishRequest& msg, |
| 507 | startPublishRequest_cb hidl_status_cb) { |
| 508 | return validateAndCall(this, |
| 509 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 510 | &WifiNanIface::startPublishRequestInternal, |
| 511 | hidl_status_cb, |
| 512 | cmd_id, |
| 513 | msg); |
| 514 | } |
| 515 | |
| 516 | Return<void> WifiNanIface::stopPublishRequest( |
| 517 | uint16_t cmd_id, |
Etan Cohen | 073bb99 | 2017-02-09 10:05:59 -0800 | [diff] [blame] | 518 | uint8_t sessionId, |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 519 | stopPublishRequest_cb hidl_status_cb) { |
| 520 | return validateAndCall(this, |
| 521 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 522 | &WifiNanIface::stopPublishRequestInternal, |
| 523 | hidl_status_cb, |
| 524 | cmd_id, |
| 525 | sessionId); |
| 526 | } |
| 527 | |
| 528 | Return<void> WifiNanIface::startSubscribeRequest( |
| 529 | uint16_t cmd_id, |
| 530 | const NanSubscribeRequest& msg, |
| 531 | startSubscribeRequest_cb hidl_status_cb) { |
| 532 | return validateAndCall(this, |
| 533 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 534 | &WifiNanIface::startSubscribeRequestInternal, |
| 535 | hidl_status_cb, |
| 536 | cmd_id, |
| 537 | msg); |
| 538 | } |
| 539 | |
| 540 | Return<void> WifiNanIface::stopSubscribeRequest( |
| 541 | uint16_t cmd_id, |
Etan Cohen | 073bb99 | 2017-02-09 10:05:59 -0800 | [diff] [blame] | 542 | uint8_t sessionId, |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 543 | stopSubscribeRequest_cb hidl_status_cb) { |
| 544 | return validateAndCall(this, |
| 545 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 546 | &WifiNanIface::stopSubscribeRequestInternal, |
| 547 | hidl_status_cb, |
| 548 | cmd_id, |
| 549 | sessionId); |
| 550 | } |
| 551 | |
| 552 | Return<void> WifiNanIface::transmitFollowupRequest( |
| 553 | uint16_t cmd_id, |
| 554 | const NanTransmitFollowupRequest& msg, |
| 555 | transmitFollowupRequest_cb hidl_status_cb) { |
| 556 | return validateAndCall(this, |
| 557 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 558 | &WifiNanIface::transmitFollowupRequestInternal, |
| 559 | hidl_status_cb, |
| 560 | cmd_id, |
| 561 | msg); |
| 562 | } |
| 563 | |
| 564 | Return<void> WifiNanIface::createDataInterfaceRequest( |
| 565 | uint16_t cmd_id, |
| 566 | const hidl_string& iface_name, |
| 567 | createDataInterfaceRequest_cb hidl_status_cb) { |
| 568 | return validateAndCall(this, |
| 569 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 570 | &WifiNanIface::createDataInterfaceRequestInternal, |
| 571 | hidl_status_cb, |
| 572 | cmd_id, |
| 573 | iface_name); |
| 574 | } |
| 575 | |
| 576 | Return<void> WifiNanIface::deleteDataInterfaceRequest( |
| 577 | uint16_t cmd_id, |
| 578 | const hidl_string& iface_name, |
| 579 | deleteDataInterfaceRequest_cb hidl_status_cb) { |
| 580 | return validateAndCall(this, |
| 581 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 582 | &WifiNanIface::deleteDataInterfaceRequestInternal, |
| 583 | hidl_status_cb, |
| 584 | cmd_id, |
| 585 | iface_name); |
| 586 | } |
| 587 | |
| 588 | Return<void> WifiNanIface::initiateDataPathRequest( |
| 589 | uint16_t cmd_id, |
| 590 | const NanInitiateDataPathRequest& msg, |
| 591 | initiateDataPathRequest_cb hidl_status_cb) { |
| 592 | return validateAndCall(this, |
| 593 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 594 | &WifiNanIface::initiateDataPathRequestInternal, |
| 595 | hidl_status_cb, |
| 596 | cmd_id, |
| 597 | msg); |
| 598 | } |
| 599 | |
| 600 | Return<void> WifiNanIface::respondToDataPathIndicationRequest( |
| 601 | uint16_t cmd_id, |
| 602 | const NanRespondToDataPathIndicationRequest& msg, |
| 603 | respondToDataPathIndicationRequest_cb hidl_status_cb) { |
| 604 | return validateAndCall(this, |
| 605 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 606 | &WifiNanIface::respondToDataPathIndicationRequestInternal, |
| 607 | hidl_status_cb, |
| 608 | cmd_id, |
| 609 | msg); |
| 610 | } |
| 611 | |
| 612 | Return<void> WifiNanIface::terminateDataPathRequest(uint16_t cmd_id, uint32_t ndpInstanceId, |
| 613 | terminateDataPathRequest_cb hidl_status_cb) { |
| 614 | return validateAndCall(this, |
| 615 | WifiStatusCode::ERROR_WIFI_IFACE_INVALID, |
| 616 | &WifiNanIface::terminateDataPathRequestInternal, |
| 617 | hidl_status_cb, |
| 618 | cmd_id, |
| 619 | ndpInstanceId); |
| 620 | } |
| 621 | |
Roshan Pius | 907d4a2 | 2016-10-27 12:48:12 -0700 | [diff] [blame] | 622 | std::pair<WifiStatus, std::string> WifiNanIface::getNameInternal() { |
| 623 | return {createWifiStatus(WifiStatusCode::SUCCESS), ifname_}; |
| 624 | } |
| 625 | |
| 626 | std::pair<WifiStatus, IfaceType> WifiNanIface::getTypeInternal() { |
| 627 | return {createWifiStatus(WifiStatusCode::SUCCESS), IfaceType::NAN}; |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 628 | } |
| 629 | |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 630 | WifiStatus WifiNanIface::registerEventCallbackInternal( |
| 631 | const sp<IWifiNanIfaceEventCallback>& callback) { |
Roshan Pius | d37341f | 2017-01-31 13:13:28 -0800 | [diff] [blame] | 632 | if (!event_cb_handler_.addCallback(callback)) { |
| 633 | return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN); |
| 634 | } |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 635 | return createWifiStatus(WifiStatusCode::SUCCESS); |
| 636 | } |
| 637 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 638 | WifiStatus WifiNanIface::getCapabilitiesRequestInternal(uint16_t cmd_id) { |
| 639 | legacy_hal::wifi_error legacy_status = |
| 640 | legacy_hal_.lock()->nanGetCapabilities(cmd_id); |
| 641 | return createWifiStatusFromLegacyError(legacy_status); |
| 642 | } |
| 643 | |
| 644 | WifiStatus WifiNanIface::enableRequestInternal(uint16_t cmd_id, |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 645 | const NanEnableRequest& msg) { |
| 646 | legacy_hal::NanEnableRequest legacy_msg; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 647 | if (!hidl_struct_util::convertHidlNanEnableRequestToLegacy(msg, &legacy_msg)) { |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 648 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 649 | } |
| 650 | legacy_hal::wifi_error legacy_status = |
| 651 | legacy_hal_.lock()->nanEnableRequest(cmd_id, legacy_msg); |
| 652 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 653 | } |
| 654 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 655 | WifiStatus WifiNanIface::configRequestInternal( |
| 656 | uint16_t cmd_id, const NanConfigRequest& msg) { |
| 657 | legacy_hal::NanConfigRequest legacy_msg; |
| 658 | if (!hidl_struct_util::convertHidlNanConfigRequestToLegacy(msg, |
| 659 | &legacy_msg)) { |
| 660 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 661 | } |
| 662 | legacy_hal::wifi_error legacy_status = |
| 663 | legacy_hal_.lock()->nanConfigRequest(cmd_id, legacy_msg); |
| 664 | return createWifiStatusFromLegacyError(legacy_status); |
| 665 | } |
| 666 | |
| 667 | WifiStatus WifiNanIface::disableRequestInternal(uint16_t cmd_id) { |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 668 | legacy_hal::wifi_error legacy_status = |
| 669 | legacy_hal_.lock()->nanDisableRequest(cmd_id); |
| 670 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 671 | } |
| 672 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 673 | WifiStatus WifiNanIface::startPublishRequestInternal(uint16_t cmd_id, |
| 674 | const NanPublishRequest& msg) { |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 675 | legacy_hal::NanPublishRequest legacy_msg; |
| 676 | if (!hidl_struct_util::convertHidlNanPublishRequestToLegacy(msg, |
| 677 | &legacy_msg)) { |
| 678 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 679 | } |
| 680 | legacy_hal::wifi_error legacy_status = |
| 681 | legacy_hal_.lock()->nanPublishRequest(cmd_id, legacy_msg); |
| 682 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 683 | } |
| 684 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 685 | WifiStatus WifiNanIface::stopPublishRequestInternal( |
Etan Cohen | 073bb99 | 2017-02-09 10:05:59 -0800 | [diff] [blame] | 686 | uint16_t cmd_id, uint8_t sessionId) { |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 687 | legacy_hal::NanPublishCancelRequest legacy_msg; |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 688 | legacy_msg.publish_id = sessionId; |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 689 | legacy_hal::wifi_error legacy_status = |
| 690 | legacy_hal_.lock()->nanPublishCancelRequest(cmd_id, legacy_msg); |
| 691 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 692 | } |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 693 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 694 | WifiStatus WifiNanIface::startSubscribeRequestInternal( |
| 695 | uint16_t cmd_id, const NanSubscribeRequest& msg) { |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 696 | legacy_hal::NanSubscribeRequest legacy_msg; |
| 697 | if (!hidl_struct_util::convertHidlNanSubscribeRequestToLegacy(msg, |
| 698 | &legacy_msg)) { |
| 699 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 700 | } |
| 701 | legacy_hal::wifi_error legacy_status = |
| 702 | legacy_hal_.lock()->nanSubscribeRequest(cmd_id, legacy_msg); |
| 703 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 704 | } |
Roshan Pius | f5f51fd | 2016-12-01 13:54:24 -0800 | [diff] [blame] | 705 | |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 706 | WifiStatus WifiNanIface::stopSubscribeRequestInternal( |
Etan Cohen | 073bb99 | 2017-02-09 10:05:59 -0800 | [diff] [blame] | 707 | uint16_t cmd_id, uint8_t sessionId) { |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 708 | legacy_hal::NanSubscribeCancelRequest legacy_msg; |
| 709 | legacy_msg.subscribe_id = sessionId; |
| 710 | legacy_hal::wifi_error legacy_status = |
| 711 | legacy_hal_.lock()->nanSubscribeCancelRequest(cmd_id, legacy_msg); |
| 712 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 713 | } |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 714 | |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 715 | WifiStatus WifiNanIface::transmitFollowupRequestInternal( |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 716 | uint16_t cmd_id, const NanTransmitFollowupRequest& msg) { |
| 717 | legacy_hal::NanTransmitFollowupRequest legacy_msg; |
| 718 | if (!hidl_struct_util::convertHidlNanTransmitFollowupRequestToLegacy(msg, &legacy_msg)) { |
| 719 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 720 | } |
| 721 | legacy_hal::wifi_error legacy_status = |
| 722 | legacy_hal_.lock()->nanTransmitFollowupRequest(cmd_id, legacy_msg); |
| 723 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 724 | } |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 725 | |
| 726 | WifiStatus WifiNanIface::createDataInterfaceRequestInternal( |
| 727 | uint16_t cmd_id, const std::string& iface_name) { |
| 728 | legacy_hal::wifi_error legacy_status = |
| 729 | legacy_hal_.lock()->nanDataInterfaceCreate(cmd_id, iface_name); |
| 730 | return createWifiStatusFromLegacyError(legacy_status); |
| 731 | } |
| 732 | WifiStatus WifiNanIface::deleteDataInterfaceRequestInternal( |
| 733 | uint16_t cmd_id, const std::string& iface_name) { |
| 734 | legacy_hal::wifi_error legacy_status = |
| 735 | legacy_hal_.lock()->nanDataInterfaceDelete(cmd_id, iface_name); |
| 736 | return createWifiStatusFromLegacyError(legacy_status); |
| 737 | } |
| 738 | WifiStatus WifiNanIface::initiateDataPathRequestInternal( |
| 739 | uint16_t cmd_id, const NanInitiateDataPathRequest& msg) { |
| 740 | legacy_hal::NanDataPathInitiatorRequest legacy_msg; |
| 741 | if (!hidl_struct_util::convertHidlNanDataPathInitiatorRequestToLegacy(msg, &legacy_msg)) { |
| 742 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 743 | } |
| 744 | legacy_hal::wifi_error legacy_status = |
| 745 | legacy_hal_.lock()->nanDataRequestInitiator(cmd_id, legacy_msg); |
| 746 | return createWifiStatusFromLegacyError(legacy_status); |
| 747 | } |
| 748 | WifiStatus WifiNanIface::respondToDataPathIndicationRequestInternal( |
| 749 | uint16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg) { |
| 750 | legacy_hal::NanDataPathIndicationResponse legacy_msg; |
| 751 | if (!hidl_struct_util::convertHidlNanDataPathIndicationResponseToLegacy(msg, &legacy_msg)) { |
| 752 | return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); |
| 753 | } |
| 754 | legacy_hal::wifi_error legacy_status = |
| 755 | legacy_hal_.lock()->nanDataIndicationResponse(cmd_id, legacy_msg); |
| 756 | return createWifiStatusFromLegacyError(legacy_status); |
| 757 | } |
| 758 | WifiStatus WifiNanIface::terminateDataPathRequestInternal( |
| 759 | uint16_t cmd_id, uint32_t ndpInstanceId) { |
| 760 | legacy_hal::NanDataPathEndRequest* legacy_msg = (legacy_hal::NanDataPathEndRequest*)malloc( |
| 761 | sizeof(legacy_hal::NanDataPathEndRequest) + sizeof(uint32_t)); |
| 762 | legacy_msg->num_ndp_instances = 1; |
| 763 | legacy_msg->ndp_instance_id[0] = ndpInstanceId; |
| 764 | |
| 765 | legacy_hal::wifi_error legacy_status = |
| 766 | legacy_hal_.lock()->nanDataEnd(cmd_id, *legacy_msg); |
| 767 | free(legacy_msg); |
| 768 | return createWifiStatusFromLegacyError(legacy_status); |
Roshan Pius | 0c92d44 | 2016-10-27 17:38:53 -0700 | [diff] [blame] | 769 | } |
Etan Cohen | f01bcaa | 2016-12-25 09:42:21 -0800 | [diff] [blame] | 770 | |
Roshan Pius | 3e2d671 | 2016-10-06 13:16:23 -0700 | [diff] [blame] | 771 | } // namespace implementation |
| 772 | } // namespace V1_0 |
| 773 | } // namespace wifi |
| 774 | } // namespace hardware |
| 775 | } // namespace android |