| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <cinttypes> |
| #include <cstddef> |
| #include <cstring> |
| |
| #include "chre/core/event_loop_manager.h" |
| #include "chre/core/wifi_request_manager.h" |
| #include "chre/platform/fatal_error.h" |
| #include "chre/platform/log.h" |
| #include "chre/platform/system_time.h" |
| #include "chre/util/system/debug_dump.h" |
| #include "chre_api/chre/version.h" |
| |
| namespace chre { |
| |
| WifiRequestManager::WifiRequestManager() { |
| // Reserve space for at least one scan monitoring nanoapp. This ensures that |
| // the first asynchronous push_back will succeed. Future push_backs will be |
| // synchronous and failures will be returned to the client. |
| if (!mScanMonitorNanoapps.reserve(1)) { |
| FATAL_ERROR_OOM(); |
| } |
| } |
| |
| void WifiRequestManager::init() { |
| mPlatformWifi.init(); |
| } |
| |
| uint32_t WifiRequestManager::getCapabilities() { |
| return mPlatformWifi.getCapabilities(); |
| } |
| |
| bool WifiRequestManager::configureScanMonitor(Nanoapp *nanoapp, bool enable, |
| const void *cookie) { |
| CHRE_ASSERT(nanoapp); |
| |
| bool success = false; |
| uint32_t instanceId = nanoapp->getInstanceId(); |
| bool hasScanMonitorRequest = nanoappHasScanMonitorRequest(instanceId); |
| if (!mPendingScanMonitorRequests.empty()) { |
| success = addScanMonitorRequestToQueue(nanoapp, enable, cookie); |
| } else if (scanMonitorIsInRequestedState(enable, hasScanMonitorRequest)) { |
| // The scan monitor is already in the requested state. A success event can |
| // be posted immediately. |
| success = postScanMonitorAsyncResultEvent(instanceId, true /* success */, |
| enable, CHRE_ERROR_NONE, cookie); |
| } else if (scanMonitorStateTransitionIsRequired(enable, |
| hasScanMonitorRequest)) { |
| success = addScanMonitorRequestToQueue(nanoapp, enable, cookie); |
| if (success) { |
| success = mPlatformWifi.configureScanMonitor(enable); |
| if (!success) { |
| mPendingScanMonitorRequests.pop_back(); |
| LOGE("Failed to enable the scan monitor for nanoapp instance %" PRIu32, |
| instanceId); |
| } |
| } |
| } else { |
| CHRE_ASSERT_LOG(false, "Invalid scan monitor configuration"); |
| } |
| |
| return success; |
| } |
| |
| bool WifiRequestManager::requestRanging( |
| Nanoapp *nanoapp, const struct chreWifiRangingParams *params, |
| const void *cookie) { |
| CHRE_ASSERT(nanoapp); |
| |
| bool success = false; |
| if (!mPendingRangingRequests.emplace()) { |
| LOGE("Can't issue new RTT request; pending queue full"); |
| } else { |
| PendingRangingRequest& req = mPendingRangingRequests.back(); |
| req.nanoappInstanceId = nanoapp->getInstanceId(); |
| req.cookie = cookie; |
| |
| if (mPendingRangingRequests.size() == 1) { |
| // First in line; dispatch request immediately |
| success = mPlatformWifi.requestRanging(params); |
| if (!success) { |
| LOGE("WiFi RTT request failed"); |
| mPendingRangingRequests.pop_back(); |
| } else { |
| mRangingResponseTimeout = SystemTime::getMonotonicTime() |
| + Nanoseconds(CHRE_WIFI_RANGING_RESULT_TIMEOUT_NS); |
| } |
| } else { |
| // Dispatch request later, after prior requests finish |
| // TODO(b/65331248): use a timer to ensure the platform is meeting its |
| // contract |
| CHRE_ASSERT_LOG(SystemTime::getMonotonicTime() <= mRangingResponseTimeout, |
| "WiFi platform didn't give callback in time"); |
| success = req.targetList.copy_array(params->targetList, |
| params->targetListLen); |
| if (!success) { |
| LOGE("Couldn't make copy of target list"); |
| mPendingRangingRequests.pop_back(); |
| } |
| } |
| } |
| |
| return success; |
| } |
| |
| bool WifiRequestManager::requestScan(Nanoapp *nanoapp, |
| const struct chreWifiScanParams *params, |
| const void *cookie) { |
| CHRE_ASSERT(nanoapp); |
| |
| // TODO(b/65331248): replace with a timer to actively check response timeout |
| bool timedOut = (mScanRequestingNanoappInstanceId.has_value() |
| && mLastScanRequestTime |
| + Nanoseconds(CHRE_WIFI_SCAN_RESULT_TIMEOUT_NS) |
| < SystemTime::getMonotonicTime()); |
| if (timedOut) { |
| LOGE("Scan request async response timed out"); |
| mScanRequestingNanoappInstanceId.reset(); |
| } |
| |
| // Handle compatibility with nanoapps compiled against API v1.1, which doesn't |
| // include the radioChainPref parameter in chreWifiScanParams |
| struct chreWifiScanParams paramsCompat; |
| if (nanoapp->getTargetApiVersion() < CHRE_API_VERSION_1_2) { |
| memcpy(¶msCompat, params, offsetof(chreWifiScanParams, radioChainPref)); |
| paramsCompat.radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT; |
| params = ¶msCompat; |
| } |
| |
| bool success = false; |
| if (mScanRequestingNanoappInstanceId.has_value()) { |
| LOGE("Active wifi scan request made while a request is in flight"); |
| } else { |
| success = mPlatformWifi.requestScan(params); |
| if (!success) { |
| LOGE("Wifi scan request failed"); |
| } else { |
| mScanRequestingNanoappInstanceId = nanoapp->getInstanceId(); |
| mScanRequestingNanoappCookie = cookie; |
| mLastScanRequestTime = SystemTime::getMonotonicTime(); |
| } |
| } |
| |
| return success; |
| } |
| |
| void WifiRequestManager::handleScanMonitorStateChange(bool enabled, |
| uint8_t errorCode) { |
| struct CallbackState { |
| bool enabled; |
| uint8_t errorCode; |
| }; |
| |
| auto *cbState = memoryAlloc<CallbackState>(); |
| if (cbState == nullptr) { |
| LOGE("Failed to allocate callback state for scan monitor state change"); |
| } else { |
| cbState->enabled = enabled; |
| cbState->errorCode = errorCode; |
| |
| auto callback = [](uint16_t /* eventType */, void *eventData) { |
| auto *state = static_cast<CallbackState *>(eventData); |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .handleScanMonitorStateChangeSync(state->enabled, state->errorCode); |
| memoryFree(state); |
| }; |
| |
| EventLoopManagerSingleton::get()->deferCallback( |
| SystemCallbackType::WifiScanMonitorStateChange, cbState, callback); |
| } |
| } |
| |
| void WifiRequestManager::handleScanResponse(bool pending, |
| uint8_t errorCode) { |
| struct CallbackState { |
| bool pending; |
| uint8_t errorCode; |
| }; |
| |
| auto *cbState = memoryAlloc<CallbackState>(); |
| if (cbState == nullptr) { |
| LOGE("Failed to allocate callback state for wifi scan response"); |
| } else { |
| cbState->pending = pending; |
| cbState->errorCode = errorCode; |
| |
| auto callback = [](uint16_t /* eventType */, void *eventData) { |
| auto *state = static_cast<CallbackState *>(eventData); |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .handleScanResponseSync(state->pending, state->errorCode); |
| memoryFree(state); |
| }; |
| |
| EventLoopManagerSingleton::get()->deferCallback( |
| SystemCallbackType::WifiRequestScanResponse, cbState, callback); |
| } |
| } |
| |
| void WifiRequestManager::handleRangingEvent( |
| uint8_t errorCode, struct chreWifiRangingEvent *event) { |
| // Use two different callbacks to avoid needing a temporary allocation to |
| // carry the error code into the event loop context |
| if (errorCode != CHRE_ERROR_NONE) { |
| // Enables passing the error code through the event data pointer to avoid |
| // allocating memory |
| union NestedErrorCode { |
| void *eventData; |
| uint8_t errorCode; |
| }; |
| |
| auto errorCb = [](uint16_t /* eventType */, void *eventData) { |
| NestedErrorCode cbErrorCode; |
| cbErrorCode.eventData = eventData; |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .handleRangingEventSync(cbErrorCode.errorCode, nullptr); |
| }; |
| |
| NestedErrorCode error = {}; |
| error.errorCode = errorCode; |
| EventLoopManagerSingleton::get()->deferCallback( |
| SystemCallbackType::WifiHandleFailedRanging, error.eventData, errorCb); |
| } else { |
| auto successCb = [](uint16_t /* eventType */, void *eventData) { |
| auto *rttEvent = static_cast<struct chreWifiRangingEvent *>(eventData); |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .handleRangingEventSync(CHRE_ERROR_NONE, rttEvent); |
| }; |
| |
| EventLoopManagerSingleton::get()->deferCallback( |
| SystemCallbackType::WifiHandleRangingEvent, event, successCb); |
| } |
| } |
| |
| void WifiRequestManager::handleScanEvent(chreWifiScanEvent *event) { |
| auto callback = [](uint16_t eventType, void *eventData) { |
| chreWifiScanEvent *scanEvent = static_cast<chreWifiScanEvent *>(eventData); |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .postScanEventFatal(scanEvent); |
| }; |
| |
| EventLoopManagerSingleton::get()->deferCallback( |
| SystemCallbackType::WifiHandleScanEvent, event, callback); |
| } |
| |
| bool WifiRequestManager::logStateToBuffer(char *buffer, size_t *bufferPos, |
| size_t bufferSize) const { |
| bool success = debugDumpPrint(buffer, bufferPos, bufferSize, "\nWifi: " |
| "scan monitor %s\n", scanMonitorIsEnabled() ? |
| "enabled" : "disabled"); |
| |
| success &= debugDumpPrint(buffer, bufferPos, bufferSize, |
| " Wifi scan monitor enabled nanoapps:\n"); |
| for (const auto& instanceId : mScanMonitorNanoapps) { |
| success &= debugDumpPrint(buffer, bufferPos, bufferSize, |
| " nanoappId=%" PRIu32 "\n", instanceId); |
| } |
| |
| if (mScanRequestingNanoappInstanceId.has_value()) { |
| success &= debugDumpPrint(buffer, bufferPos, bufferSize, |
| " Wifi request pending nanoappId=%" PRIu32 "\n", |
| mScanRequestingNanoappInstanceId.value()); |
| } |
| |
| success &= debugDumpPrint(buffer, bufferPos, bufferSize, |
| " Wifi transition queue:\n"); |
| for (const auto& transition : mPendingScanMonitorRequests) { |
| success &= debugDumpPrint(buffer, bufferPos, bufferSize, |
| " enable=%s nanoappId=%" PRIu32 "\n", |
| transition.enable ? "true" : "false", |
| transition.nanoappInstanceId); |
| } |
| |
| return success; |
| } |
| |
| bool WifiRequestManager::scanMonitorIsEnabled() const { |
| return !mScanMonitorNanoapps.empty(); |
| } |
| |
| bool WifiRequestManager::nanoappHasScanMonitorRequest( |
| uint32_t instanceId, size_t *nanoappIndex) const { |
| size_t index = mScanMonitorNanoapps.find(instanceId); |
| bool hasScanMonitorRequest = (index != mScanMonitorNanoapps.size()); |
| if (hasScanMonitorRequest && nanoappIndex != nullptr) { |
| *nanoappIndex = index; |
| } |
| |
| return hasScanMonitorRequest; |
| } |
| |
| bool WifiRequestManager::scanMonitorIsInRequestedState( |
| bool requestedState, bool nanoappHasRequest) const { |
| return (requestedState == scanMonitorIsEnabled() || (!requestedState |
| && (!nanoappHasRequest || mScanMonitorNanoapps.size() > 1))); |
| } |
| |
| bool WifiRequestManager::scanMonitorStateTransitionIsRequired( |
| bool requestedState, bool nanoappHasRequest) const { |
| return ((requestedState && mScanMonitorNanoapps.empty()) |
| || (!requestedState && nanoappHasRequest |
| && mScanMonitorNanoapps.size() == 1)); |
| } |
| |
| bool WifiRequestManager::addScanMonitorRequestToQueue(Nanoapp *nanoapp, |
| bool enable, |
| const void *cookie) { |
| PendingScanMonitorRequest scanMonitorStateTransition; |
| scanMonitorStateTransition.nanoappInstanceId = nanoapp->getInstanceId(); |
| scanMonitorStateTransition.cookie = cookie; |
| scanMonitorStateTransition.enable = enable; |
| |
| bool success = mPendingScanMonitorRequests.push(scanMonitorStateTransition); |
| if (!success) { |
| LOGW("Too many scan monitor state transitions"); |
| } |
| |
| return success; |
| } |
| |
| bool WifiRequestManager::updateNanoappScanMonitoringList(bool enable, |
| uint32_t instanceId) { |
| bool success = true; |
| Nanoapp *nanoapp = EventLoopManagerSingleton::get()->getEventLoop() |
| .findNanoappByInstanceId(instanceId); |
| if (nanoapp == nullptr) { |
| LOGW("Failed to update scan monitoring list for non-existent nanoapp"); |
| } else { |
| size_t nanoappIndex; |
| bool hasExistingRequest = nanoappHasScanMonitorRequest(instanceId, |
| &nanoappIndex); |
| if (enable) { |
| if (!hasExistingRequest) { |
| // The scan monitor was successfully enabled for this nanoapp and |
| // there is no existing request. Add it to the list of scan monitoring |
| // nanoapps. |
| success = mScanMonitorNanoapps.push_back(instanceId); |
| if (!success) { |
| LOGE("Failed to add nanoapp to the list of scan monitoring " |
| "nanoapps"); |
| } else { |
| nanoapp->registerForBroadcastEvent(CHRE_EVENT_WIFI_SCAN_RESULT); |
| } |
| } |
| } else { |
| if (!hasExistingRequest) { |
| success = false; |
| LOGE("Received a scan monitor state change for a non-existent nanoapp"); |
| } else { |
| // The scan monitor was successfully disabled for a previously enabled |
| // nanoapp. Remove it from the list of scan monitoring nanoapps. |
| mScanMonitorNanoapps.erase(nanoappIndex); |
| nanoapp->unregisterForBroadcastEvent(CHRE_EVENT_WIFI_SCAN_RESULT); |
| } |
| } |
| } |
| |
| return success; |
| } |
| |
| bool WifiRequestManager::postScanMonitorAsyncResultEvent( |
| uint32_t nanoappInstanceId, bool success, bool enable, uint8_t errorCode, |
| const void *cookie) { |
| // Allocate and post an event to the nanoapp requesting wifi. |
| bool eventPosted = false; |
| if (!success || updateNanoappScanMonitoringList(enable, nanoappInstanceId)) { |
| chreAsyncResult *event = memoryAlloc<chreAsyncResult>(); |
| if (event == nullptr) { |
| LOGE("Failed to allocate wifi scan monitor async result event"); |
| } else { |
| event->requestType = CHRE_WIFI_REQUEST_TYPE_CONFIGURE_SCAN_MONITOR; |
| event->success = success; |
| event->errorCode = errorCode; |
| event->reserved = 0; |
| event->cookie = cookie; |
| |
| // Post the event. |
| eventPosted = EventLoopManagerSingleton::get()->getEventLoop() |
| .postEvent(CHRE_EVENT_WIFI_ASYNC_RESULT, event, freeEventDataCallback, |
| kSystemInstanceId, nanoappInstanceId); |
| if (!eventPosted) { |
| memoryFree(event); |
| } |
| } |
| } |
| |
| return eventPosted; |
| } |
| |
| void WifiRequestManager::postScanMonitorAsyncResultEventFatal( |
| uint32_t nanoappInstanceId, bool success, bool enable, uint8_t errorCode, |
| const void *cookie) { |
| if (!postScanMonitorAsyncResultEvent(nanoappInstanceId, success, enable, |
| errorCode, cookie)) { |
| FATAL_ERROR("Failed to send WiFi scan monitor async result event"); |
| } |
| } |
| |
| bool WifiRequestManager::postScanRequestAsyncResultEvent( |
| uint32_t nanoappInstanceId, bool success, uint8_t errorCode, |
| const void *cookie) { |
| bool eventPosted = false; |
| chreAsyncResult *event = memoryAlloc<chreAsyncResult>(); |
| if (event == nullptr) { |
| LOGE("Failed to allocate wifi scan request async result event"); |
| } else { |
| event->requestType = CHRE_WIFI_REQUEST_TYPE_REQUEST_SCAN; |
| event->success = success; |
| event->errorCode = errorCode; |
| event->reserved = 0; |
| event->cookie = cookie; |
| |
| // Post the event. |
| eventPosted = EventLoopManagerSingleton::get()->getEventLoop() |
| .postEvent(CHRE_EVENT_WIFI_ASYNC_RESULT, event, freeEventDataCallback, |
| kSystemInstanceId, nanoappInstanceId); |
| } |
| |
| return eventPosted; |
| } |
| |
| void WifiRequestManager::postScanRequestAsyncResultEventFatal( |
| uint32_t nanoappInstanceId, bool success, uint8_t errorCode, |
| const void *cookie) { |
| if (!postScanRequestAsyncResultEvent(nanoappInstanceId, success, errorCode, |
| cookie)) { |
| FATAL_ERROR("Failed to send WiFi scan request async result event"); |
| } |
| } |
| |
| void WifiRequestManager::postScanEventFatal(chreWifiScanEvent *event) { |
| EventLoopManagerSingleton::get()->getEventLoop() |
| .postEvent(CHRE_EVENT_WIFI_SCAN_RESULT, event, freeWifiScanEventCallback); |
| } |
| |
| void WifiRequestManager::handleScanMonitorStateChangeSync(bool enabled, |
| uint8_t errorCode) { |
| // Success is defined as having no errors ... in life ༼ つ ◕_◕ ༽つ |
| bool success = (errorCode == CHRE_ERROR_NONE); |
| |
| // TODO(b/62904616): re-enable this assertion |
| //CHRE_ASSERT_LOG(!mScanMonitorStateTransitions.empty(), |
| // "handleScanMonitorStateChangeSync called with no transitions"); |
| if (mPendingScanMonitorRequests.empty()) { |
| LOGE("WiFi PAL error: handleScanMonitorStateChangeSync called with no " |
| "transitions (enabled %d errorCode %" PRIu8 ")", enabled, errorCode); |
| } |
| |
| // Always check the front of the queue. |
| if (!mPendingScanMonitorRequests.empty()) { |
| const auto& stateTransition = mPendingScanMonitorRequests.front(); |
| success &= (stateTransition.enable == enabled); |
| postScanMonitorAsyncResultEventFatal(stateTransition.nanoappInstanceId, |
| success, stateTransition.enable, |
| errorCode, stateTransition.cookie); |
| mPendingScanMonitorRequests.pop(); |
| } |
| |
| while (!mPendingScanMonitorRequests.empty()) { |
| const auto& stateTransition = mPendingScanMonitorRequests.front(); |
| bool hasScanMonitorRequest = nanoappHasScanMonitorRequest( |
| stateTransition.nanoappInstanceId); |
| if (scanMonitorIsInRequestedState( |
| stateTransition.enable, hasScanMonitorRequest)) { |
| // We are already in the target state so just post an event indicating |
| // success |
| postScanMonitorAsyncResultEventFatal(stateTransition.nanoappInstanceId, |
| success, stateTransition.enable, |
| errorCode, stateTransition.cookie); |
| } else if (scanMonitorStateTransitionIsRequired( |
| stateTransition.enable, hasScanMonitorRequest)) { |
| if (mPlatformWifi.configureScanMonitor(stateTransition.enable)) { |
| break; |
| } else { |
| postScanMonitorAsyncResultEventFatal(stateTransition.nanoappInstanceId, |
| false /* success */, |
| stateTransition.enable, CHRE_ERROR, |
| stateTransition.cookie); |
| } |
| } else { |
| CHRE_ASSERT_LOG(false, "Invalid scan monitor state"); |
| break; |
| } |
| |
| mPendingScanMonitorRequests.pop(); |
| } |
| } |
| |
| void WifiRequestManager::handleScanResponseSync(bool pending, |
| uint8_t errorCode) { |
| // TODO(b/65206783): re-enable this assertion |
| //CHRE_ASSERT_LOG(mScanRequestingNanoappInstanceId.has_value(), |
| // "handleScanResponseSync called with no outstanding request"); |
| if (!mScanRequestingNanoappInstanceId.has_value()) { |
| LOGE("handleScanResponseSync called with no outstanding request"); |
| } |
| |
| // TODO: raise this to CHRE_ASSERT_LOG |
| if (!pending && errorCode == CHRE_ERROR_NONE) { |
| LOGE("Invalid wifi scan response"); |
| errorCode = CHRE_ERROR; |
| } |
| |
| if (mScanRequestingNanoappInstanceId.has_value()) { |
| bool success = (pending && errorCode == CHRE_ERROR_NONE); |
| if (!success) { |
| LOGW("Wifi scan request failed: pending %d, errorCode %" PRIu8, |
| pending, errorCode); |
| } |
| postScanRequestAsyncResultEventFatal(*mScanRequestingNanoappInstanceId, |
| success, errorCode, |
| mScanRequestingNanoappCookie); |
| |
| // Set a flag to indicate that results may be pending. |
| mScanRequestResultsArePending = pending; |
| |
| if (pending) { |
| Nanoapp *nanoapp = EventLoopManagerSingleton::get()->getEventLoop() |
| .findNanoappByInstanceId(*mScanRequestingNanoappInstanceId); |
| if (nanoapp == nullptr) { |
| LOGW("Received WiFi scan response for unknown nanoapp"); |
| } else { |
| nanoapp->registerForBroadcastEvent(CHRE_EVENT_WIFI_SCAN_RESULT); |
| } |
| } else { |
| // If the scan results are not pending, clear the nanoapp instance ID. |
| // Otherwise, wait for the results to be delivered and then clear the |
| // instance ID. |
| mScanRequestingNanoappInstanceId.reset(); |
| } |
| } |
| } |
| |
| bool WifiRequestManager::postRangingAsyncResult(uint8_t errorCode) { |
| bool eventPosted = false; |
| |
| if (mPendingRangingRequests.empty()) { |
| LOGE("Unexpected ranging event callback"); |
| } else { |
| auto *event = memoryAlloc<struct chreAsyncResult>(); |
| if (event == nullptr) { |
| LOGE("Couldn't allocate ranging async result"); |
| } else { |
| const PendingRangingRequest& req = mPendingRangingRequests.front(); |
| |
| event->requestType = CHRE_WIFI_REQUEST_TYPE_RANGING; |
| event->success = (errorCode == CHRE_ERROR_NONE); |
| event->errorCode = errorCode; |
| event->reserved = 0; |
| event->cookie = req.cookie; |
| |
| eventPosted = EventLoopManagerSingleton::get()->getEventLoop().postEvent( |
| CHRE_EVENT_WIFI_ASYNC_RESULT, event, freeEventDataCallback, |
| kSystemInstanceId, req.nanoappInstanceId); |
| if (!eventPosted) { |
| memoryFree(event); |
| } |
| } |
| } |
| |
| return eventPosted; |
| } |
| |
| bool WifiRequestManager::dispatchQueuedRangingRequest() { |
| const PendingRangingRequest& req = mPendingRangingRequests.front(); |
| struct chreWifiRangingParams params = {}; |
| params.targetListLen = static_cast<uint8_t>(req.targetList.size()); |
| params.targetList = req.targetList.data(); |
| |
| bool success = mPlatformWifi.requestRanging(¶ms); |
| if (!success) { |
| LOGE("Failed to issue queued ranging result"); |
| postRangingAsyncResult(CHRE_ERROR); |
| mPendingRangingRequests.pop(); |
| } else { |
| mRangingResponseTimeout = SystemTime::getMonotonicTime() |
| + Nanoseconds(CHRE_WIFI_RANGING_RESULT_TIMEOUT_NS); |
| } |
| |
| return success; |
| } |
| |
| void WifiRequestManager::handleRangingEventSync( |
| uint8_t errorCode, struct chreWifiRangingEvent *event) { |
| if (postRangingAsyncResult(errorCode)) { |
| if (errorCode != CHRE_ERROR_NONE) { |
| LOGW("RTT ranging failed with error %d", errorCode); |
| } else { |
| EventLoopManagerSingleton::get()->getEventLoop().postEvent( |
| CHRE_EVENT_WIFI_RANGING_RESULT, event, freeWifiRangingEventCallback, |
| kSystemInstanceId, mPendingRangingRequests.front().nanoappInstanceId); |
| } |
| mPendingRangingRequests.pop(); |
| } |
| |
| // If we have any pending requests, try issuing them to the platform until the |
| // first one succeeds |
| while (!mPendingRangingRequests.empty() && !dispatchQueuedRangingRequest()); |
| } |
| |
| void WifiRequestManager::handleFreeWifiScanEvent(chreWifiScanEvent *scanEvent) { |
| if (mScanRequestResultsArePending) { |
| // Reset the event distribution logic once an entire scan event has been |
| // received and processed by the nanoapp requesting the scan event. |
| mScanEventResultCountAccumulator += scanEvent->resultCount; |
| if (mScanEventResultCountAccumulator >= scanEvent->resultTotal) { |
| mScanEventResultCountAccumulator = 0; |
| mScanRequestResultsArePending = false; |
| } |
| |
| if (!mScanRequestResultsArePending |
| && mScanRequestingNanoappInstanceId.has_value()) { |
| Nanoapp *nanoapp = EventLoopManagerSingleton::get()->getEventLoop() |
| .findNanoappByInstanceId(*mScanRequestingNanoappInstanceId); |
| if (nanoapp == nullptr) { |
| LOGW("Attempted to unsubscribe unknown nanoapp from WiFi scan events"); |
| } else if (!nanoappHasScanMonitorRequest( |
| *mScanRequestingNanoappInstanceId)) { |
| nanoapp->unregisterForBroadcastEvent(CHRE_EVENT_WIFI_SCAN_RESULT); |
| } |
| |
| mScanRequestingNanoappInstanceId.reset(); |
| } |
| } |
| |
| mPlatformWifi.releaseScanEvent(scanEvent); |
| } |
| |
| void WifiRequestManager::freeWifiScanEventCallback(uint16_t eventType, |
| void *eventData) { |
| chreWifiScanEvent *scanEvent = static_cast<chreWifiScanEvent *>(eventData); |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .handleFreeWifiScanEvent(scanEvent); |
| } |
| |
| void WifiRequestManager::freeWifiRangingEventCallback(uint16_t eventType, |
| void *eventData) { |
| auto *event = static_cast<struct chreWifiRangingEvent *>(eventData); |
| EventLoopManagerSingleton::get()->getWifiRequestManager() |
| .mPlatformWifi.releaseRangingEvent(event); |
| } |
| |
| } // namespace chre |
