/*
|
* Copyright (C) 2018 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_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 {
|
|
GnssManager::GnssManager()
|
: mLocationSession(CHRE_EVENT_GNSS_LOCATION),
|
mMeasurementSession(CHRE_EVENT_GNSS_DATA) {
|
}
|
|
void GnssManager::init() {
|
mPlatformGnss.init();
|
}
|
|
uint32_t GnssManager::getCapabilities() {
|
return mPlatformGnss.getCapabilities();
|
}
|
|
void GnssManager::logStateToBuffer(
|
char *buffer, size_t *bufferPos, size_t bufferSize) const {
|
debugDumpPrint(buffer, bufferPos, bufferSize,"\nGNSS:");
|
mLocationSession.logStateToBuffer(buffer, bufferPos, bufferSize);
|
mMeasurementSession.logStateToBuffer(buffer, bufferPos, bufferSize);
|
}
|
|
GnssSession::GnssSession(uint16_t reportEventType)
|
: mReportEventType(reportEventType) {
|
switch (mReportEventType) {
|
case CHRE_EVENT_GNSS_LOCATION:
|
mStartRequestType = CHRE_GNSS_REQUEST_TYPE_LOCATION_SESSION_START;
|
mStopRequestType = CHRE_GNSS_REQUEST_TYPE_LOCATION_SESSION_STOP;
|
mName = "Location";
|
break;
|
|
case CHRE_EVENT_GNSS_DATA:
|
mStartRequestType = CHRE_GNSS_REQUEST_TYPE_MEASUREMENT_SESSION_START;
|
mStopRequestType = CHRE_GNSS_REQUEST_TYPE_MEASUREMENT_SESSION_STOP;
|
mName = "Measurement";
|
break;
|
|
default:
|
CHRE_ASSERT_LOG(false, "Unsupported eventType %" PRIu16, reportEventType);
|
}
|
|
if (!mRequests.reserve(1)) {
|
FATAL_ERROR_OOM();
|
}
|
}
|
|
bool GnssSession::addRequest(Nanoapp *nanoapp, Milliseconds minInterval,
|
Milliseconds minTimeToNext, const void *cookie) {
|
CHRE_ASSERT(nanoapp);
|
return configure(nanoapp, true /* enable */, minInterval, minTimeToNext,
|
cookie);
|
}
|
|
bool GnssSession::removeRequest(Nanoapp *nanoapp, const void *cookie) {
|
CHRE_ASSERT(nanoapp);
|
return configure(nanoapp, false /* enable */, Milliseconds(UINT64_MAX),
|
Milliseconds(UINT64_MAX), cookie);
|
}
|
|
void GnssSession::handleStatusChange(bool enabled, uint8_t errorCode) {
|
struct CallbackState {
|
bool enabled;
|
uint8_t errorCode;
|
GnssSession *session;
|
};
|
|
auto *cbState = memoryAlloc<CallbackState>();
|
if (cbState == nullptr) {
|
LOG_OOM();
|
} else {
|
cbState->enabled = enabled;
|
cbState->errorCode = errorCode;
|
cbState->session = this;
|
|
auto callback = [](uint16_t /* eventType */, void *eventData) {
|
auto *state = static_cast<CallbackState *>(eventData);
|
state->session->handleStatusChangeSync(state->enabled, state->errorCode);
|
memoryFree(state);
|
};
|
|
EventLoopManagerSingleton::get()->deferCallback(
|
SystemCallbackType::GnssSessionStatusChange, cbState, callback);
|
}
|
}
|
|
void GnssSession::handleReportEvent(void *event) {
|
EventLoopManagerSingleton::get()->getEventLoop()
|
.postEvent(mReportEventType, event, freeReportEventCallback);
|
}
|
|
void GnssSession::logStateToBuffer(
|
char *buffer, size_t *bufferPos, size_t bufferSize) const {
|
debugDumpPrint(buffer, bufferPos, bufferSize,
|
"\n %s: Current interval(ms)=%" PRIu64 "\n",
|
mName, mCurrentInterval.getMilliseconds());
|
debugDumpPrint(buffer, bufferPos, bufferSize, " Requests:\n");
|
for (const auto& request : mRequests) {
|
debugDumpPrint(buffer, bufferPos, bufferSize,
|
" minInterval(ms)=%" PRIu64 " nanoappId=%"
|
PRIu32 "\n",
|
request.minInterval.getMilliseconds(),
|
request.nanoappInstanceId);
|
}
|
|
debugDumpPrint(buffer, bufferPos, bufferSize, " Transition queue:\n");
|
for (const auto& transition : mStateTransitions) {
|
debugDumpPrint(buffer, bufferPos, bufferSize,
|
" minInterval(ms)=%" PRIu64 " enable=%d"
|
" nanoappId=%" PRIu32 "\n",
|
transition.minInterval.getMilliseconds(),
|
transition.enable, transition.nanoappInstanceId);
|
}
|
}
|
|
bool GnssSession::configure(
|
Nanoapp *nanoapp, bool enable, Milliseconds minInterval,
|
Milliseconds minTimeToNext, const void *cookie) {
|
bool success = false;
|
uint32_t instanceId = nanoapp->getInstanceId();
|
size_t requestIndex = 0;
|
bool hasRequest = nanoappHasRequest(instanceId, &requestIndex);
|
if (!mStateTransitions.empty()) {
|
success = addRequestToQueue(instanceId, enable, minInterval, cookie);
|
} else if (stateTransitionIsRequired(enable, minInterval, hasRequest,
|
requestIndex)) {
|
success = addRequestToQueue(instanceId, enable, minInterval, cookie);
|
if (success) {
|
success = controlPlatform(enable, minInterval, minTimeToNext);
|
if (!success) {
|
mStateTransitions.pop_back();
|
LOGE("Failed to enable a GNSS session for nanoapp instance %" PRIu32,
|
instanceId);
|
}
|
}
|
} else {
|
success = postAsyncResultEvent(
|
instanceId, true /* success */, enable, minInterval, CHRE_ERROR_NONE,
|
cookie);
|
}
|
|
return success;
|
}
|
|
bool GnssSession::nanoappHasRequest(
|
uint32_t instanceId, size_t *requestIndex) const {
|
bool hasRequest = false;
|
for (size_t i = 0; i < mRequests.size(); i++) {
|
if (mRequests[i].nanoappInstanceId == instanceId) {
|
hasRequest = true;
|
if (requestIndex != nullptr) {
|
*requestIndex = i;
|
}
|
|
break;
|
}
|
}
|
|
return hasRequest;
|
}
|
|
bool GnssSession::addRequestToQueue(
|
uint32_t instanceId, bool enable, Milliseconds minInterval,
|
const void *cookie) {
|
StateTransition stateTransition;
|
stateTransition.nanoappInstanceId = instanceId;
|
stateTransition.enable = enable;
|
stateTransition.minInterval = minInterval;
|
stateTransition.cookie = cookie;
|
|
bool success = mStateTransitions.push(stateTransition);
|
if (!success) {
|
LOGW("Too many session state transitions");
|
}
|
|
return success;
|
}
|
|
bool GnssSession::isEnabled() const {
|
return !mRequests.empty();
|
}
|
|
bool GnssSession::stateTransitionIsRequired(
|
bool requestedState, Milliseconds minInterval, bool nanoappHasRequest,
|
size_t requestIndex) const {
|
bool requestToEnable = (requestedState && !isEnabled());
|
bool requestToIncreaseRate = (requestedState && isEnabled()
|
&& minInterval < mCurrentInterval);
|
bool requestToDisable = (!requestedState && nanoappHasRequest
|
&& mRequests.size() == 1);
|
|
// An effective rate decrease for the 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 = mRequests[requestIndex];
|
for (size_t i = 0; i < mRequests.size(); i++) {
|
const Request& request = mRequests[i];
|
if (i != requestIndex
|
&& request.minInterval == currentRequest.minInterval) {
|
requestCount++;
|
}
|
}
|
|
requestToDecreaseRate = (minInterval > mCurrentInterval
|
&& currentRequest.minInterval == mCurrentInterval && requestCount == 0);
|
}
|
|
return (requestToEnable || requestToDisable || requestToIncreaseRate
|
|| requestToDecreaseRate);
|
}
|
|
bool GnssSession::updateRequests(
|
bool enable, Milliseconds minInterval, uint32_t instanceId) {
|
bool success = true;
|
Nanoapp *nanoapp = EventLoopManagerSingleton::get()->getEventLoop()
|
.findNanoappByInstanceId(instanceId);
|
if (nanoapp == nullptr) {
|
LOGW("Failed to update GNSS session request list for non-existent nanoapp");
|
} else {
|
size_t requestIndex;
|
bool hasExistingRequest = nanoappHasRequest(instanceId, &requestIndex);
|
if (enable) {
|
if (hasExistingRequest) {
|
// If the nanoapp has an open request ensure that the minInterval is
|
// kept up to date.
|
mRequests[requestIndex].minInterval = minInterval;
|
} else {
|
// The GNSS session was successfully enabled for this nanoapp and
|
// there is no existing request. Add it to the list of GNSS session
|
// nanoapps.
|
Request request;
|
request.nanoappInstanceId = instanceId;
|
request.minInterval = minInterval;
|
success = mRequests.push_back(request);
|
if (!success) {
|
LOG_OOM();
|
} else {
|
nanoapp->registerForBroadcastEvent(mReportEventType);
|
}
|
}
|
} else if (hasExistingRequest) {
|
// The session was successfully disabled for a previously enabled
|
// nanoapp. Remove it from the list of requests.
|
mRequests.erase(requestIndex);
|
nanoapp->unregisterForBroadcastEvent(mReportEventType);
|
} // else disabling an inactive request, treat as success per CHRE API
|
}
|
|
return success;
|
}
|
|
bool GnssSession::postAsyncResultEvent(
|
uint32_t instanceId, bool success, bool enable, Milliseconds minInterval,
|
uint8_t errorCode, const void *cookie) {
|
bool eventPosted = false;
|
if (!success || updateRequests(enable, minInterval, instanceId)) {
|
chreAsyncResult *event = memoryAlloc<chreAsyncResult>();
|
if (event == nullptr) {
|
LOG_OOM();
|
} else {
|
event->requestType = enable ? mStartRequestType : mStopRequestType;
|
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 GnssSession::postAsyncResultEventFatal(
|
uint32_t instanceId, bool success, bool enable, Milliseconds minInterval,
|
uint8_t errorCode, const void *cookie) {
|
if (!postAsyncResultEvent(instanceId, success, enable, minInterval, errorCode,
|
cookie)) {
|
FATAL_ERROR("Failed to send GNSS session request async result event");
|
}
|
}
|
|
void GnssSession::handleStatusChangeSync(bool enabled, uint8_t errorCode) {
|
bool success = (errorCode == CHRE_ERROR_NONE);
|
|
CHRE_ASSERT_LOG(!mStateTransitions.empty(),
|
"handleStatusChangeSync called with no transitions");
|
if (!mStateTransitions.empty()) {
|
const auto& stateTransition = mStateTransitions.front();
|
|
if (success) {
|
mCurrentInterval = stateTransition.minInterval;
|
}
|
|
success &= (stateTransition.enable == enabled);
|
postAsyncResultEventFatal(stateTransition.nanoappInstanceId, success,
|
stateTransition.enable,
|
stateTransition.minInterval,
|
errorCode, stateTransition.cookie);
|
mStateTransitions.pop();
|
}
|
|
while (!mStateTransitions.empty()) {
|
const auto& stateTransition = mStateTransitions.front();
|
|
size_t requestIndex;
|
bool hasRequest = nanoappHasRequest(
|
stateTransition.nanoappInstanceId, &requestIndex);
|
|
if (stateTransitionIsRequired(stateTransition.enable,
|
stateTransition.minInterval,
|
hasRequest, requestIndex)) {
|
if (controlPlatform(stateTransition.enable, stateTransition.minInterval,
|
Milliseconds(0))) {
|
break;
|
} else {
|
LOGE("Failed to enable a GNSS session for nanoapp instance %" PRIu32,
|
stateTransition.nanoappInstanceId);
|
postAsyncResultEventFatal(
|
stateTransition.nanoappInstanceId, false /* success */,
|
stateTransition.enable, stateTransition.minInterval,
|
CHRE_ERROR, stateTransition.cookie);
|
mStateTransitions.pop();
|
}
|
} else {
|
postAsyncResultEventFatal(
|
stateTransition.nanoappInstanceId, true /* success */,
|
stateTransition.enable, stateTransition.minInterval,
|
CHRE_ERROR_NONE, stateTransition.cookie);
|
mStateTransitions.pop();
|
}
|
}
|
}
|
|
void GnssSession::freeReportEventCallback(uint16_t eventType, void *eventData) {
|
switch (eventType) {
|
case CHRE_EVENT_GNSS_LOCATION:
|
EventLoopManagerSingleton::get()->getGnssManager().mPlatformGnss
|
.releaseLocationEvent(
|
static_cast<chreGnssLocationEvent *>(eventData));
|
break;
|
|
case CHRE_EVENT_GNSS_DATA:
|
EventLoopManagerSingleton::get()->getGnssManager().mPlatformGnss
|
.releaseMeasurementDataEvent(
|
static_cast<chreGnssDataEvent *>(eventData));
|
break;
|
|
default:
|
CHRE_ASSERT_LOG(false, "Unhandled event type %" PRIu16, eventType);
|
}
|
}
|
|
bool GnssSession::controlPlatform(
|
bool enable, Milliseconds minInterval, Milliseconds /* minTimeToNext */) {
|
bool success = false;
|
|
switch (mReportEventType) {
|
case CHRE_EVENT_GNSS_LOCATION:
|
// TODO: Provide support for min time to next report. It is currently sent
|
// to the platform as zero.
|
success = EventLoopManagerSingleton::get()->getGnssManager().mPlatformGnss
|
.controlLocationSession(enable, minInterval, Milliseconds(0));
|
break;
|
|
case CHRE_EVENT_GNSS_DATA:
|
success = EventLoopManagerSingleton::get()->getGnssManager().mPlatformGnss
|
.controlMeasurementSession(enable, minInterval);
|
break;
|
|
default:
|
CHRE_ASSERT_LOG(false, "Unhandled event type %" PRIu16, mReportEventType);
|
}
|
return success;
|
}
|
|
} // namespace chre
|
