PL286/system/chre/core/gnss_request_manager.cc

/*
 * Copyright (C) 2017 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/gnss_request_manager.h"

#include "chre/core/event_loop_manager.h"
#include "chre/platform/assert.h"
#include "chre/platform/fatal_error.h"
#include "chre/util/system/debug_dump.h"

namespace chre {

GnssRequestManager::GnssRequestManager()
    : mCurrentLocationSessionInterval(UINT64_MAX) {
  if (!mLocationSessionRequests.reserve(1)) {
    FATAL_ERROR("Failed to allocate GNSS requests list at startup");
  }
}

void GnssRequestManager::init() {
  mPlatformGnss.init();
}

uint32_t GnssRequestManager::getCapabilities() {
  return mPlatformGnss.getCapabilities();
}

bool GnssRequestManager::startLocationSession(Nanoapp *nanoapp,
                                              Milliseconds minInterval,
                                              Milliseconds minTimeToNextFix,
                                              const void *cookie) {
  CHRE_ASSERT(nanoapp);
  return configureLocationSession(nanoapp, true /* enable */, minInterval,
                                  minTimeToNextFix, cookie);
}

bool GnssRequestManager::stopLocationSession(Nanoapp *nanoapp,
                                             const void *cookie) {
  CHRE_ASSERT(nanoapp);
  return configureLocationSession(nanoapp, false /* enable */,
                                  Milliseconds(UINT64_MAX),
                                  Milliseconds(UINT64_MAX), cookie);
}

void GnssRequestManager::handleLocationSessionStatusChange(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 location session state change");
  } else {
    cbState->enabled = enabled;
    cbState->errorCode = errorCode;

    auto callback = [](uint16_t /* eventType */, void *eventData) {
      auto *state = static_cast<CallbackState *>(eventData);
      EventLoopManagerSingleton::get()->getGnssRequestManager()
          .handleLocationSessionStatusChangeSync(state->enabled,
                                                 state->errorCode);
      memoryFree(state);
    };

    bool callbackDeferred = EventLoopManagerSingleton::get()->deferCallback(
        SystemCallbackType::GnssLocationSessionStatusChange, cbState, callback);
    if (!callbackDeferred) {
      memoryFree(cbState);
    }
  }
}

void GnssRequestManager::handleLocationEvent(chreGnssLocationEvent *event) {
  bool eventPosted = EventLoopManagerSingleton::get()->getEventLoop()
      .postEvent(CHRE_EVENT_GNSS_LOCATION, event, freeLocationEventCallback,
                 kSystemInstanceId, kBroadcastInstanceId);
  if (!eventPosted) {
    FATAL_ERROR("Failed to send GNSS location event");
  }
}

bool GnssRequestManager::logStateToBuffer(char *buffer, size_t *bufferPos,
                                          size_t bufferSize) const {
  bool success = debugDumpPrint(buffer, bufferPos, bufferSize, "\nGNSS:"
                                " Current interval(ms)=%" PRIu64 "\n",
                                mCurrentLocationSessionInterval.
                                getMilliseconds());

  success &= debugDumpPrint(buffer, bufferPos, bufferSize,
                            " GNSS requests:\n");
  for (const auto& request : mLocationSessionRequests) {
    success &= debugDumpPrint(buffer, bufferPos, bufferSize, "  minInterval(ms)"
                              "=%" PRIu64 " nanoappId=%" PRIu32 "\n",
                              request.minInterval.getMilliseconds(),
                              request.nanoappInstanceId);
  }

  success &= debugDumpPrint(buffer, bufferPos, bufferSize,
                            " GNSS transition queue:\n");
  for (const auto& transition : mLocationSessionStateTransitions) {
    success &= debugDumpPrint(buffer, bufferPos, bufferSize,
                              "  minInterval(ms)=%" PRIu64 " enable=%d"
                              " nanoappId=%" PRIu32 "\n",
                              transition.minInterval.getMilliseconds(),
                              transition.enable,
                              transition.nanoappInstanceId);
  }

  return success;
}

bool GnssRequestManager::configureLocationSession(
    Nanoapp *nanoapp, bool enable, Milliseconds minInterval,
    Milliseconds minTimeToFirstFix, const void *cookie) {
  bool success = false;
  uint32_t instanceId = nanoapp->getInstanceId();
  size_t requestIndex = 0;
  bool nanoappHasRequest = nanoappHasLocationSessionRequest(instanceId,
                                                            &requestIndex);
  if (!mLocationSessionStateTransitions.empty()) {
    success = addLocationSessionRequestToQueue(instanceId, enable, minInterval,
                                               cookie);
  } else if (locationSessionIsInRequestedState(enable, minInterval,
                                               nanoappHasRequest)) {
    success = postLocationSessionAsyncResultEvent(
        instanceId, true /* success */, enable, minInterval, CHRE_ERROR_NONE,
        cookie);
  } else if (locationSessionStateTransitionIsRequired(enable, minInterval,
                                                      nanoappHasRequest,
                                                      requestIndex)) {
    success = addLocationSessionRequestToQueue(instanceId, enable,
                                               minInterval, cookie);
    if (success) {
      // TODO: Provide support for min time to next fix. It is currently sent
      // to the platform as zero.
      success = mPlatformGnss.controlLocationSession(enable, minInterval,
                                                     Milliseconds(0));
      if (!success) {
        // TODO: Add a pop_back method.
        mLocationSessionStateTransitions.remove(
            mLocationSessionRequests.size() - 1);
        LOGE("Failed to enable a GNSS location session for nanoapp instance "
             "%" PRIu32, instanceId);
      }
    }
  } else {
    CHRE_ASSERT_LOG(false, "Invalid location session configuration");
  }

  return success;
}

bool GnssRequestManager::nanoappHasLocationSessionRequest(
    uint32_t instanceId, size_t *requestIndex) {
  bool hasLocationSessionRequest = false;
  for (size_t i = 0; i < mLocationSessionRequests.size(); i++) {
    if (mLocationSessionRequests[i].nanoappInstanceId == instanceId) {
      hasLocationSessionRequest = true;
      if (requestIndex != nullptr) {
        *requestIndex = i;
      }

      break;
    }
  }

  return hasLocationSessionRequest;
}

bool GnssRequestManager::addLocationSessionRequestToQueue(
    uint32_t instanceId, bool enable, Milliseconds minInterval,
    const void *cookie) {
  LocationSessionStateTransition stateTransition;
  stateTransition.nanoappInstanceId = instanceId;
  stateTransition.enable = enable;
  stateTransition.minInterval = minInterval;
  stateTransition.cookie = cookie;

  bool success = mLocationSessionStateTransitions.push(stateTransition);
  if (!success) {
    LOGW("Too many location session state transitions");
  }

  return success;
}

bool GnssRequestManager::locationSessionIsEnabled() {
  return !mLocationSessionRequests.empty();
}

bool GnssRequestManager::locationSessionIsInRequestedState(
    bool requestedState, Milliseconds minInterval, bool nanoappHasRequest) {
  bool inTargetState = (requestedState == locationSessionIsEnabled());
  bool meetsMinInterval = (minInterval >= mCurrentLocationSessionInterval);
  bool hasMoreThanOneRequest = (mLocationSessionRequests.size() > 1);
  return ((inTargetState && (!requestedState || meetsMinInterval))
      || (!requestedState && (!nanoappHasRequest || hasMoreThanOneRequest)));
}

bool GnssRequestManager::locationSessionStateTransitionIsRequired(
    bool requestedState, Milliseconds minInterval, bool nanoappHasRequest,
    size_t requestIndex) {
  bool requestToEnable = (requestedState && !locationSessionIsEnabled());
  bool requestToIncreaseRate = (requestedState && locationSessionIsEnabled()
      && minInterval < mCurrentLocationSessionInterval);
  bool requestToDisable = (!requestedState && nanoappHasRequest
                           && mLocationSessionRequests.size() == 1);

  // An effective rate decrease for the location session can only occur if the
  // nanoapp has an existing request.
  bool requestToDecreaseRate = false;
  if (nanoappHasRequest) {
    // The nanoapp has an existing request. Check that the request does not
    // result in a rate decrease by checking if no other nanoapps have the
    // same request, the nanoapp's existing request is not equal to the current
    // requested interval and the new request is slower than the current
    // requested rate.
    size_t requestCount = 0;
    const auto& currentRequest = mLocationSessionRequests[requestIndex];
    for (size_t i = 0; i < mLocationSessionRequests.size(); i++) {
      LocationSessionRequest& request = mLocationSessionRequests[i];
      if (i != requestIndex
          && request.minInterval == currentRequest.minInterval) {
        requestCount++;
      }
    }

    requestToDecreaseRate = (minInterval > mCurrentLocationSessionInterval
        && currentRequest.minInterval == mCurrentLocationSessionInterval
        && requestCount == 0);
  }

  return (requestToEnable || requestToDisable
      || requestToIncreaseRate || requestToDecreaseRate);
}

bool GnssRequestManager::updateLocationSessionRequests(
    bool enable, Milliseconds minInterval, uint32_t instanceId) {
  bool success = true;
  Nanoapp *nanoapp = EventLoopManagerSingleton::get()->getEventLoop()
      .findNanoappByInstanceId(instanceId);
  if (nanoapp == nullptr) {
    CHRE_ASSERT_LOG(false, "Failed to update location session request list for "
                    "non-existent nanoapp");
  } else {
    size_t requestIndex;
    bool hasExistingRequest = nanoappHasLocationSessionRequest(instanceId,
                                                               &requestIndex);
    if (enable) {
      if (hasExistingRequest) {
        // If the nanoapp has an open request ensure that the minInterval is
        // kept up to date.
        mLocationSessionRequests[requestIndex].minInterval = minInterval;
      } else {
        success = nanoapp->registerForBroadcastEvent(CHRE_EVENT_GNSS_LOCATION);
        if (!success) {
          LOGE("Failed to register nanoapp for GNSS location events");
        } else {
          // The location session was successfully enabled for this nanoapp and
          // there is no existing request. Add it to the list of location
          // session nanoapps.
          LocationSessionRequest locationSessionRequest;
          locationSessionRequest.nanoappInstanceId = instanceId;
          locationSessionRequest.minInterval = minInterval;
          success = mLocationSessionRequests.push_back(locationSessionRequest);
          if (!success) {
            nanoapp->unregisterForBroadcastEvent(CHRE_EVENT_GNSS_LOCATION);
            LOGE("Failed to add nanoapp to the list of location session "
                 "nanoapps");
          }
        }
      }
    } else {
      if (!hasExistingRequest) {
        success = false;
        LOGE("Received a location session state change for a non-existent "
             "nanoapp");
      } else {
        // The location session was successfully disabled for a previously
        // enabled nanoapp. Remove it from the list of requests.
        mLocationSessionRequests.erase(requestIndex);
        nanoapp->unregisterForBroadcastEvent(CHRE_EVENT_GNSS_LOCATION);
      }
    }
  }

  return success;
}

bool GnssRequestManager::postLocationSessionAsyncResultEvent(
    uint32_t instanceId, bool success, bool enable, Milliseconds minInterval,
    uint8_t errorCode, const void *cookie) {
  bool eventPosted = false;
  if (!success || updateLocationSessionRequests(enable, minInterval,
                                                instanceId)) {
    chreAsyncResult *event = memoryAlloc<chreAsyncResult>();
    if (event == nullptr) {
      LOGE("Failed to allocate location session async result event");
    } else {
      if (enable) {
        event->requestType = CHRE_GNSS_REQUEST_TYPE_LOCATION_SESSION_START;
      } else {
        event->requestType = CHRE_GNSS_REQUEST_TYPE_LOCATION_SESSION_STOP;
      }

      event->success = success;
      event->errorCode = errorCode;
      event->reserved = 0;
      event->cookie = cookie;

      eventPosted = EventLoopManagerSingleton::get()->getEventLoop()
          .postEvent(CHRE_EVENT_GNSS_ASYNC_RESULT, event, freeEventDataCallback,
                     kSystemInstanceId, instanceId);

      if (!eventPosted) {
        memoryFree(event);
      }
    }
  }

  return eventPosted;
}

void GnssRequestManager::postLocationSessionAsyncResultEventFatal(
    uint32_t instanceId, bool success, bool enable, Milliseconds minInterval,
    uint8_t errorCode, const void *cookie) {
  if (!postLocationSessionAsyncResultEvent(instanceId, success, enable,
                                           minInterval, errorCode, cookie)) {
    FATAL_ERROR("Failed to send GNSS location request async result event");
  }
}

void GnssRequestManager::handleLocationSessionStatusChangeSync(
    bool enabled, uint8_t errorCode) {
  bool success = (errorCode == CHRE_ERROR_NONE);

  CHRE_ASSERT_LOG(!mLocationSessionStateTransitions.empty(),
                  "handleLocationSessionStatusChangeSync called with no "
                  "transitions");
  if (!mLocationSessionStateTransitions.empty()) {
    const auto& stateTransition = mLocationSessionStateTransitions.front();

    if (success) {
      mCurrentLocationSessionInterval = stateTransition.minInterval;
    }

    success &= (stateTransition.enable == enabled);
    postLocationSessionAsyncResultEventFatal(stateTransition.nanoappInstanceId,
                                             success, stateTransition.enable,
                                             stateTransition.minInterval,
                                             errorCode, stateTransition.cookie);
    mLocationSessionStateTransitions.pop();
  }

  while (!mLocationSessionStateTransitions.empty()) {
    const auto& stateTransition = mLocationSessionStateTransitions.front();

    size_t requestIndex;
    bool nanoappHasRequest = nanoappHasLocationSessionRequest(
        stateTransition.nanoappInstanceId, &requestIndex);

    if (locationSessionStateTransitionIsRequired(stateTransition.enable,
                                                 stateTransition.minInterval,
                                                 nanoappHasRequest,
                                                 requestIndex)) {
      if (mPlatformGnss.controlLocationSession(stateTransition.enable,
                                               stateTransition.minInterval,
                                               Milliseconds(0))) {
        break;
      } else {
        LOGE("Failed to enable a GNSS location session for nanoapp instance "
             "%" PRIu32, stateTransition.nanoappInstanceId);
        postLocationSessionAsyncResultEventFatal(
            stateTransition.nanoappInstanceId, false /* success */,
            stateTransition.enable, stateTransition.minInterval,
            CHRE_ERROR, stateTransition.cookie);
        mLocationSessionStateTransitions.pop();
      }
    } else {
      postLocationSessionAsyncResultEventFatal(
          stateTransition.nanoappInstanceId, true /* success */,
          stateTransition.enable, stateTransition.minInterval,
          errorCode, stateTransition.cookie);
      mLocationSessionStateTransitions.pop();
    }
  }
}

void GnssRequestManager::handleFreeLocationEvent(chreGnssLocationEvent *event) {
  mPlatformGnss.releaseLocationEvent(event);
}

void GnssRequestManager::freeLocationEventCallback(uint16_t eventType,
                                                   void *eventData) {
  auto *locationEvent = static_cast<chreGnssLocationEvent *>(eventData);
  EventLoopManagerSingleton::get()->getGnssRequestManager()
      .handleFreeLocationEvent(locationEvent);
}

}  // namespace chre