chre/core/sensor_request_manager.cc

/*
 * 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 "chre/core/sensor_request_manager.h"

#include "chre_api/chre/version.h"
#include "chre/core/event_loop_manager.h"
#include "chre/platform/fatal_error.h"
#include "chre/platform/shared/platform_sensor_util.h"
#include "chre/util/nested_data_ptr.h"
#include "chre/util/system/debug_dump.h"

#define LOG_INVALID_SENSOR(x) \
    LOGE("Invalid sensor type %" PRIu8 ": line %d", \
         static_cast<uint8_t>(x), __LINE__)

namespace chre {
namespace {

bool isSensorRequestValid(const Sensor& sensor,
                          const SensorRequest& sensorRequest) {
  bool isRequestContinuous = sensorModeIsContinuous(
      sensorRequest.getMode());
  bool isRequestOneShot = sensorModeIsOneShot(sensorRequest.getMode());
  uint64_t requestedInterval = sensorRequest.getInterval().toRawNanoseconds();
  SensorType sensorType = sensor.getSensorType();

  bool success = true;
  if (requestedInterval < sensor.getMinInterval()) {
    success = false;
    LOGE("Requested interval %" PRIu64 " < sensor's minInterval %" PRIu64,
         requestedInterval, sensor.getMinInterval());
  } else if (isRequestContinuous) {
    if (sensorTypeIsOneShot(sensorType)) {
      success = false;
      LOGE("Invalid continuous request for a one-shot sensor.");
    }
  } else if (isRequestOneShot) {
    if (!sensorTypeIsOneShot(sensorType)) {
      success = false;
      LOGE("Invalid one-shot request for a continuous sensor.");
    }
  }
  return success;
}

}  // namespace

SensorRequestManager::SensorRequestManager() {
  mSensorRequests.resize(mSensorRequests.capacity());
}

SensorRequestManager::~SensorRequestManager() {
  for (size_t i = 0; i < mSensorRequests.size(); i++) {
    // Disable sensors that have been enabled previously.
    if (mSensorRequests[i].isSensorSupported()) {
      mSensorRequests[i].removeAll();
    }
  }

  PlatformSensor::deinit();
}

void SensorRequestManager::init() {
  // The Platform sensor must be initialized prior to interacting with any
  // sensors.
  PlatformSensor::init();

  DynamicVector<Sensor> sensors;
  sensors.reserve(8);  // Avoid some initial reallocation churn
  if (!PlatformSensor::getSensors(&sensors)) {
    LOGE("Failed to query the platform for sensors");
  } else if (sensors.empty()) {
    LOGW("Platform returned zero sensors");
  } else {
    for (size_t i = 0; i < sensors.size(); i++) {
      SensorType sensorType = sensors[i].getSensorType();
      size_t sensorIndex = getSensorTypeArrayIndex(sensorType);

      if (!isValidSensorType(sensorType)) {
        LOG_INVALID_SENSOR(sensorType);
      } else if (sensors[i].getMinInterval() == 0) {
        LOGE("Invalid sensor minInterval: %s", getSensorTypeName(sensorType));
      } else {
        mSensorRequests[sensorIndex].setSensor(std::move(sensors[i]));
        LOGD("Found sensor: %s", getSensorTypeName(sensorType));
      }
    }
  }
}

bool SensorRequestManager::getSensorHandle(SensorType sensorType,
                                           uint32_t *sensorHandle) const {
  CHRE_ASSERT(sensorHandle);

  bool sensorHandleIsValid = false;
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
  } else {
    size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
    sensorHandleIsValid = mSensorRequests[sensorIndex].isSensorSupported();
    if (sensorHandleIsValid) {
      *sensorHandle = getSensorHandleFromSensorType(sensorType);
    }
  }

  return sensorHandleIsValid;
}

bool SensorRequestManager::setSensorRequest(Nanoapp *nanoapp,
    uint32_t sensorHandle, const SensorRequest& sensorRequest) {
  CHRE_ASSERT(nanoapp);

  // Validate the input to ensure that a valid handle has been provided.
  SensorType sensorType = getSensorTypeFromSensorHandle(sensorHandle);
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
    return false;
  }

  // Ensure that the runtime is aware of this sensor type.
  size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
  SensorRequests& requests = mSensorRequests[sensorIndex];
  if (!requests.isSensorSupported()) {
    LOGW("Attempting to configure non-existent sensor");
    return false;
  }

  const Sensor& sensor = requests.getSensor();
  if (!isSensorRequestValid(sensor, sensorRequest)) {
    return false;
  }

  size_t requestIndex;
  uint16_t eventType = getSampleEventTypeForSensorType(sensorType);
  bool nanoappHasRequest = (requests.find(nanoapp->getInstanceId(),
                                          &requestIndex) != nullptr);

  bool success;
  bool requestChanged;
  if (sensorRequest.getMode() == SensorMode::Off) {
    if (nanoappHasRequest) {
      // The request changes the mode to off and there was an existing request.
      // The existing request is removed from the multiplexer. The nanoapp is
      // unregistered from events of this type if this request was successful.
      success = requests.remove(requestIndex, &requestChanged);
      if (success) {
        cancelFlushRequests(sensorType, nanoapp->getInstanceId());

        nanoapp->unregisterForBroadcastEvent(eventType);

        uint16_t biasEventType;
        if (getSensorBiasEventType(sensorType, &biasEventType)) {
          // Per API requirements, turn off bias reporting when unsubscribing
          // from the sensor.
          nanoapp->unregisterForBroadcastEvent(biasEventType);
        }
      }
    } else {
      // The sensor is being configured to Off, but is already Off (there is no
      // existing request). We assign to success to be true and no other
      // operation is required.
      requestChanged = false;
      success = true;
    }
  } else if (!nanoappHasRequest) {
    // The request changes the mode to the enabled state and there was no
    // existing request. The request is newly created and added to the
    // multiplexer. The nanoapp is registered for events if this request was
    // successful.
    success = requests.add(sensorRequest, &requestChanged);
    if (success) {
      nanoapp->registerForBroadcastEvent(eventType);

      // Per API requirements, turn on bias reporting for calibrated sensors
      // by default when subscribed.
      uint16_t biasEventType;
      if (getSensorBiasEventType(sensorType, &biasEventType)
          && sensorTypeIsCalibrated(sensorType)) {
        nanoapp->registerForBroadcastEvent(biasEventType);
      }

      // Deliver last valid event to new clients of on-change sensors
      if (sensorTypeIsOnChange(sensor.getSensorType()) &&
          sensor.getLastEvent() != nullptr) {
        EventLoopManagerSingleton::get()->getEventLoop().postEventOrDie(
            getSampleEventTypeForSensorType(sensorType), sensor.getLastEvent(),
            nullptr, nanoapp->getInstanceId());
      }
    }
  } else {
    // The request changes the mode to the enabled state and there was an
    // existing request. The existing request is updated.
    success = requests.update(requestIndex, sensorRequest, &requestChanged);
  }

  if (requestChanged) {
    // TODO: Send an event to nanoapps to indicate the rate change.
  }

  return success;
}

bool SensorRequestManager::getSensorInfo(uint32_t sensorHandle,
                                         const Nanoapp& nanoapp,
                                         struct chreSensorInfo *info) const {
  CHRE_ASSERT(info);

  bool success = false;

  // Validate the input to ensure that a valid handle has been provided.
  SensorType sensorType = getSensorTypeFromSensorHandle(sensorHandle);
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
  } else {
    size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
    if (!mSensorRequests[sensorIndex].isSensorSupported()) {
      LOGW("Attempting to get sensor info for unsupported sensor handle %"
           PRIu32, sensorHandle);
    } else {
      // Platform-independent properties.
      info->sensorType = getUnsignedIntFromSensorType(sensorType);
      info->isOnChange = sensorTypeIsOnChange(sensorType);
      info->isOneShot  = sensorTypeIsOneShot(sensorType);
      info->reportsBiasEvents = sensorTypeReportsBias(sensorType);
      info->unusedFlags = 0;

      // Platform-specific properties.
      const Sensor& sensor = mSensorRequests[sensorIndex].getSensor();
      info->sensorName = sensor.getSensorName();

      // minInterval was added in CHRE API v1.1 - do not attempt to populate for
      // nanoapps targeting v1.0 as their struct will not be large enough
      if (nanoapp.getTargetApiVersion() >= CHRE_API_VERSION_1_1) {
        info->minInterval = sensor.getMinInterval();
      }

      success = true;
    }
  }

  return success;
}

bool SensorRequestManager::removeAllRequests(SensorType sensorType) {
  bool success = false;
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
  } else {
    size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
    SensorRequests& requests = mSensorRequests[sensorIndex];
    uint16_t eventType = getSampleEventTypeForSensorType(sensorType);

    for (const SensorRequest& request : requests.getRequests()) {
      Nanoapp *nanoapp = EventLoopManagerSingleton::get()->getEventLoop()
          .findNanoappByInstanceId(request.getInstanceId());
      if (nanoapp != nullptr) {
        nanoapp->unregisterForBroadcastEvent(eventType);
      }
    }

    cancelFlushRequests(sensorType);
    success = requests.removeAll();
  }
  return success;
}

Sensor *SensorRequestManager::getSensor(SensorType sensorType) {
  Sensor *sensorPtr = nullptr;
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
  } else {
    size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
    if (mSensorRequests[sensorIndex].isSensorSupported()) {
      sensorPtr = &mSensorRequests[sensorIndex].getSensor();
    }
  }
  return sensorPtr;
}

bool SensorRequestManager::getSensorSamplingStatus(
    uint32_t sensorHandle, struct chreSensorSamplingStatus *status) const {
  CHRE_ASSERT(status);

  bool success = false;
  SensorType sensorType = getSensorTypeFromSensorHandle(sensorHandle);
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
  } else {
    size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
    if (mSensorRequests[sensorIndex].isSensorSupported()) {
      success = mSensorRequests[sensorIndex].getSamplingStatus(status);
    }
  }
  return success;
}

const DynamicVector<SensorRequest>& SensorRequestManager::getRequests(
    SensorType sensorType) const {
  size_t sensorIndex = 0;
  if (!isValidSensorType(sensorType)) {
    LOG_INVALID_SENSOR(sensorType);
  } else {
    sensorIndex = getSensorTypeArrayIndex(sensorType);
  }
  return mSensorRequests[sensorIndex].getRequests();
}

bool SensorRequestManager::configureBiasEvents(
      Nanoapp *nanoapp, uint32_t sensorHandle, bool enable) {
  bool success = false;
  uint16_t eventType;
  SensorType sensorType = getSensorTypeFromSensorHandle(sensorHandle);
  if (getSensorBiasEventType(sensorType, &eventType)) {
    if (enable) {
      nanoapp->registerForBroadcastEvent(eventType);
    } else {
      nanoapp->unregisterForBroadcastEvent(eventType);
    }

    success = true;
  }

  return success;
}

bool SensorRequestManager::getThreeAxisBias(
    uint32_t sensorHandle, struct chreSensorThreeAxisData *bias) const {
  CHRE_ASSERT(bias != nullptr);

  bool success = false;
  if (bias != nullptr) {
    SensorType sensorType = getSensorTypeFromSensorHandle(sensorHandle);
    if (!isValidSensorType(sensorType)) {
      LOG_INVALID_SENSOR(sensorType);
    } else {
      size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
      if (mSensorRequests[sensorIndex].isSensorSupported()) {
        success = mSensorRequests[sensorIndex].getThreeAxisBias(bias);
      }
    }
  }

  return success;
}

bool SensorRequestManager::flushAsync(
    Nanoapp *nanoapp, uint32_t sensorHandle, const void *cookie) {
  bool success = false;

  uint32_t nanoappInstanceId = nanoapp->getInstanceId();
  SensorType sensorType = getSensorTypeFromSensorHandle(sensorHandle);
  // NOTE: One-shot sensors do not support flush per API
  if (!isValidSensorType(sensorType) || sensorTypeIsOneShot(sensorType)) {
    LOGE("Cannot flush for sensor type %" PRIu32,
         static_cast<uint32_t>(sensorType));
  } else if (mFlushRequestQueue.full()) {
    LOG_OOM();
  } else {
    mFlushRequestQueue.emplace_back(sensorType, nanoappInstanceId, cookie);
    size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
    success = (mSensorRequests[sensorIndex].makeFlushRequest(
        mFlushRequestQueue.back()) == CHRE_ERROR_NONE);
    if (!success) {
      mFlushRequestQueue.pop_back();
    }
  }

  return success;
}

void SensorRequestManager::handleFlushCompleteEvent(
    uint8_t errorCode, SensorType sensorType) {
  size_t sensorIndex = getSensorTypeArrayIndex(sensorType);
  if (isValidSensorType(sensorType)
      && mSensorRequests[sensorIndex].isFlushRequestPending()) {

    // Cancel flush request timer before posting to the event queue to ensure
    // a timeout event isn't processed by CHRE now that the complete event
    // has been received.
    mSensorRequests[sensorIndex].cancelPendingFlushRequestTimer();

    struct CallbackState {
      uint8_t errorCode;
      SensorType sensorType;
    };

    NestedDataPtr<CallbackState> state = {};
    state.data.errorCode = errorCode;
    state.data.sensorType = sensorType;

    auto callback = [](uint16_t /* eventType */, void *eventData) {
      NestedDataPtr<CallbackState> nestedState;
      nestedState.dataPtr = eventData;
      EventLoopManagerSingleton::get()->getSensorRequestManager()
          .handleFlushCompleteEventSync(nestedState.data.errorCode,
                                        nestedState.data.sensorType);
    };

    EventLoopManagerSingleton::get()->deferCallback(
        SystemCallbackType::SensorFlushComplete, state.dataPtr, callback);
  }
}

void SensorRequestManager::handleSensorEvent(SensorType sensorType,
                                             void *event) {
  uint16_t eventType = getSampleEventTypeForSensorType(sensorType);
  // Only allow dropping continuous sensor events since losing one-shot or
  // on-change events could result in nanoapps stuck in a bad state.
  if (sensorTypeIsContinuous(sensorType)) {
    EventLoopManagerSingleton::get()->getEventLoop().postLowPriorityEventOrFree(
        eventType, event, sensorDataEventFree);
  } else {
    EventLoopManagerSingleton::get()->getEventLoop().postEventOrDie(
        eventType, event, sensorDataEventFree);
  }
}

void SensorRequestManager::logStateToBuffer(char *buffer, size_t *bufferPos,
                                            size_t bufferSize) const {
  debugDumpPrint(buffer, bufferPos, bufferSize, "\nSensors:\n");
  for (uint8_t i = 0; i < static_cast<uint8_t>(SensorType::SENSOR_TYPE_COUNT);
       i++) {
    SensorType sensor = static_cast<SensorType>(i);
    if (isValidSensorType(sensor)) {
      for (const auto& request : getRequests(sensor)) {
        debugDumpPrint(buffer, bufferPos, bufferSize, " %s: mode=%d"
                       " interval(ns)=%" PRIu64 " latency(ns)=%"
                       PRIu64 " nanoappId=%" PRIu32 "\n",
                       getSensorTypeName(sensor), request.getMode(),
                       request.getInterval().toRawNanoseconds(),
                       request.getLatency().toRawNanoseconds(),
                       request.getInstanceId());
      }
    }
  }
}

void SensorRequestManager::postFlushCompleteEvent(
    uint32_t sensorHandle, uint8_t errorCode, const FlushRequest& request) {
  auto *event = memoryAlloc<chreSensorFlushCompleteEvent>();
  if (event == nullptr) {
    LOG_OOM();
  } else {
    event->sensorHandle = sensorHandle;
    event->errorCode = errorCode;
    event->cookie = request.cookie;
    memset(event->reserved, 0, sizeof(event->reserved));

    EventLoopManagerSingleton::get()->getEventLoop().postEventOrDie(
        CHRE_EVENT_SENSOR_FLUSH_COMPLETE, event, freeEventDataCallback,
        request.nanoappInstanceId);
  }
}

void SensorRequestManager::completeFlushRequestAtIndex(
    size_t index, uint8_t errorCode) {
  if (index < mFlushRequestQueue.size()) {
    const FlushRequest& request = mFlushRequestQueue[index];
    SensorType sensorType = request.sensorType;
    if (request.isActive) {
      SensorRequests& requests = getSensorRequests(sensorType);
      requests.clearPendingFlushRequest();
    }

    uint32_t sensorHandle;
    if (getSensorHandle(sensorType, &sensorHandle)) {
      postFlushCompleteEvent(sensorHandle, errorCode, request);
    }
    mFlushRequestQueue.erase(index);
  }
}

void SensorRequestManager::dispatchNextFlushRequest(SensorType sensorType) {
  SensorRequests& requests = getSensorRequests(sensorType);

  for (size_t i = 0; i < mFlushRequestQueue.size(); i++) {
    FlushRequest& request = mFlushRequestQueue[i];
    if (request.sensorType == sensorType) {
      uint8_t newRequestErrorCode = requests.makeFlushRequest(request);
      if (newRequestErrorCode == CHRE_ERROR_NONE) {
        break;
      } else {
        completeFlushRequestAtIndex(i,  newRequestErrorCode);
        i--;
      }
    }
  }
}

void SensorRequestManager::handleFlushCompleteEventSync(
    uint8_t errorCode, SensorType sensorType) {
  for (size_t i = 0; i < mFlushRequestQueue.size(); i++) {
    if (mFlushRequestQueue[i].sensorType == sensorType) {
      completeFlushRequestAtIndex(i, errorCode);
      dispatchNextFlushRequest(sensorType);
      break;
    }
  }
}

void SensorRequestManager::cancelFlushRequests(
    SensorType sensorType, uint32_t nanoappInstanceId) {
  bool removeAll = (nanoappInstanceId == kSystemInstanceId);
  for (size_t i = 0; i < mFlushRequestQueue.size(); i++) {
    const FlushRequest& request = mFlushRequestQueue[i];
    if (request.sensorType == sensorType &&
        (request.nanoappInstanceId == nanoappInstanceId || removeAll)) {
      completeFlushRequestAtIndex(
          i, CHRE_ERROR_FUNCTION_DISABLED /* errorCode */);
      i--;
    }
  }

  SensorRequests& requests = getSensorRequests(sensorType);
  if (!requests.isFlushRequestPending()) {
    dispatchNextFlushRequest(sensorType);
  }
}

const SensorRequest *SensorRequestManager::SensorRequests::find(
    uint32_t instanceId, size_t *index) const {
  CHRE_ASSERT(index);

  const auto& requests = mMultiplexer.getRequests();
  for (size_t i = 0; i < requests.size(); i++) {
    const SensorRequest& sensorRequest = requests[i];
    if (sensorRequest.getInstanceId() == instanceId) {
      *index = i;
      return &sensorRequest;
    }
  }

  return nullptr;
}

bool SensorRequestManager::SensorRequests::add(const SensorRequest& request,
                                               bool *requestChanged) {
  CHRE_ASSERT(requestChanged != nullptr);
  CHRE_ASSERT(isSensorSupported());

  size_t addIndex;
  bool success = true;
  if (!mMultiplexer.addRequest(request, &addIndex, requestChanged)) {
    *requestChanged = false;
    success = false;
    LOG_OOM();
  } else if (*requestChanged) {
    success = mSensor->setRequest(mMultiplexer.getCurrentMaximalRequest());
    if (!success) {
      // Remove the newly added request since the platform failed to handle it.
      // The sensor is expected to maintain the existing request so there is no
      // need to reset the platform to the last maximal request.
      mMultiplexer.removeRequest(addIndex, requestChanged);

      // This is a roll-back operation so the maximal change in the multiplexer
      // must not have changed. The request changed state is forced to false.
      *requestChanged = false;
    }
  }

  return success;
}

bool SensorRequestManager::SensorRequests::remove(size_t removeIndex,
                                                  bool *requestChanged) {
  CHRE_ASSERT(requestChanged != nullptr);
  CHRE_ASSERT(isSensorSupported());

  bool success = true;
  mMultiplexer.removeRequest(removeIndex, requestChanged);
  if (*requestChanged) {
    success = mSensor->setRequest(mMultiplexer.getCurrentMaximalRequest());
    if (!success) {
      LOGE("SensorRequestManager failed to remove a request");

      // If the platform fails to handle this request in a debug build there is
      // likely an error in the platform. This is not strictly a programming
      // error but it does make sense to use assert semantics when a platform
      // fails to handle a request that it had been sent previously.
      CHRE_ASSERT(false);

      // The request to the platform to set a request when removing has failed
      // so the request has not changed.
      *requestChanged = false;
    }
  }

  return success;
}

bool SensorRequestManager::SensorRequests::update(size_t updateIndex,
                                                  const SensorRequest& request,
                                                  bool *requestChanged) {
  CHRE_ASSERT(requestChanged != nullptr);
  CHRE_ASSERT(isSensorSupported());

  bool success = true;
  SensorRequest previousRequest = mMultiplexer.getRequests()[updateIndex];
  mMultiplexer.updateRequest(updateIndex, request, requestChanged);
  if (*requestChanged) {
    success = mSensor->setRequest(mMultiplexer.getCurrentMaximalRequest());
    if (!success) {
      // Roll back the request since sending it to the sensor failed. The
      // request will roll back to the previous maximal. The sensor is
      // expected to maintain the existing request if a request fails so there
      // is no need to reset the platform to the last maximal request.
      mMultiplexer.updateRequest(updateIndex, previousRequest, requestChanged);

      // This is a roll-back operation so the maximal change in the multiplexer
      // must not have changed. The request changed state is forced to false.
      *requestChanged = false;
    }
  }

  return success;
}

bool SensorRequestManager::SensorRequests::removeAll() {
  CHRE_ASSERT(isSensorSupported());

  bool requestChanged;
  mMultiplexer.removeAllRequests(&requestChanged);

  bool success = true;
  if (requestChanged) {
    SensorRequest maximalRequest = mMultiplexer.getCurrentMaximalRequest();
    success = mSensor->setRequest(maximalRequest);
    if (!success) {
      LOGE("SensorRequestManager failed to remove all request");

      // If the platform fails to handle this request in a debug build there is
      // likely an error in the platform. This is not strictly a programming
      // error but it does make sense to use assert semantics when a platform
      // fails to handle a request that it had been sent previously.
      CHRE_ASSERT(false);
    }
  }
  return success;
}

uint8_t SensorRequestManager::SensorRequests::makeFlushRequest(
    FlushRequest& request) {
  uint8_t errorCode = CHRE_ERROR;
  if (!isSensorSupported()) {
    LOGE("Cannot flush on unsupported sensor");
  } else if (mMultiplexer.getRequests().size() == 0) {
    LOGE("Cannot flush on disabled sensor");
  } else if (!isFlushRequestPending()) {
    Nanoseconds now = SystemTime::getMonotonicTime();
    Nanoseconds deadline = request.deadlineTimestamp;
    if (now >= deadline) {
      LOGE("Flush sensor %" PRIu32 " failed for nanoapp ID %" PRIu32
           ": deadline exceeded", static_cast<uint32_t>(request.sensorType),
           request.nanoappInstanceId);
      errorCode = CHRE_ERROR_TIMEOUT;
    } else if (doMakeFlushRequest()) {
      errorCode = CHRE_ERROR_NONE;
      Nanoseconds delay = deadline - now;
      request.isActive = true;

      NestedDataPtr<SensorType> nestedType = {};
      nestedType.data = request.sensorType;

      auto callback = [](uint16_t /* eventType */, void * eventData) {
        LOGE("Flush request timed out.");
        NestedDataPtr<SensorType> nestedType;
        nestedType.dataPtr = eventData;
        // Send a complete event, thus closing out this flush request. If the
        // request that has just timed out receives a response later, this may
        // inadvertently close out a new request before it has actually
        // completed.
        // TODO: Attach an ID to all flush requests / responses so stale
        // responses can be properly dropped.
        EventLoopManagerSingleton::get()->getSensorRequestManager()
            .handleFlushCompleteEventSync(CHRE_ERROR_TIMEOUT,
                                          nestedType.data);
      };

      mFlushRequestTimerHandle =
          EventLoopManagerSingleton::get()->setDelayedCallback(
              SystemCallbackType::SensorFlushTimeout, nestedType.dataPtr,
              callback, delay);
    }
  } else {
    // Flush request will be made once the pending request is completed.
    // Return true so that the nanoapp can wait for a result through the
    // CHRE_EVENT_SENSOR_FLUSH_COMPLETE event.
    errorCode = CHRE_ERROR_NONE;
  }

  return errorCode;
}

void SensorRequestManager::SensorRequests::clearPendingFlushRequest() {
  cancelPendingFlushRequestTimer();
  mFlushRequestPending = false;
}

void SensorRequestManager::SensorRequests::cancelPendingFlushRequestTimer() {
  if (mFlushRequestTimerHandle != CHRE_TIMER_INVALID) {
    EventLoopManagerSingleton::get()->cancelDelayedCallback(
        mFlushRequestTimerHandle);
    mFlushRequestTimerHandle = CHRE_TIMER_INVALID;
  }
}

bool SensorRequestManager::SensorRequests::doMakeFlushRequest() {
  // Set to true before making the request since it's a synchronous request
  // and we may get the complete event before it returns.
  mFlushRequestPending = true;
  mFlushRequestPending = mSensor->flushAsync();
  return mFlushRequestPending;
}

}  // namespace chre