1070 lines
38 KiB
C++
1070 lines
38 KiB
C++
/* Copyright (c) 2011-2014, 2016-2021 The Linux Foundation. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* * Neither the name of The Linux Foundation, nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
#define LOG_NDEBUG 0 //Define to enable LOGV
|
|
#define LOG_TAG "LocSvc_LocApiBase"
|
|
|
|
#include <dlfcn.h>
|
|
#include <inttypes.h>
|
|
#include <gps_extended_c.h>
|
|
#include <LocApiBase.h>
|
|
#include <LocAdapterBase.h>
|
|
#include <log_util.h>
|
|
#include <LocContext.h>
|
|
#include <loc_misc_utils.h>
|
|
|
|
namespace loc_core {
|
|
|
|
#define TO_ALL_LOCADAPTERS(call) TO_ALL_ADAPTERS(mLocAdapters, (call))
|
|
#define TO_1ST_HANDLING_LOCADAPTERS(call) TO_1ST_HANDLING_ADAPTER(mLocAdapters, (call))
|
|
|
|
int hexcode(char *hexstring, int string_size,
|
|
const char *data, int data_size)
|
|
{
|
|
int i;
|
|
for (i = 0; i < data_size; i++)
|
|
{
|
|
char ch = data[i];
|
|
if (i*2 + 3 <= string_size)
|
|
{
|
|
snprintf(&hexstring[i*2], 3, "%02X", ch);
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
int decodeAddress(char *addr_string, int string_size,
|
|
const char *data, int data_size)
|
|
{
|
|
const char addr_prefix = 0x91;
|
|
int i, idxOutput = 0;
|
|
|
|
if (!data || !addr_string) { return 0; }
|
|
|
|
if (data[0] != addr_prefix)
|
|
{
|
|
LOC_LOGW("decodeAddress: address prefix is not 0x%x but 0x%x", addr_prefix, data[0]);
|
|
addr_string[0] = '\0';
|
|
return 0; // prefix not correct
|
|
}
|
|
|
|
for (i = 1; i < data_size; i++)
|
|
{
|
|
unsigned char ch = data[i], low = ch & 0x0F, hi = ch >> 4;
|
|
if (low <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = low + '0'; }
|
|
if (hi <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = hi + '0'; }
|
|
}
|
|
|
|
addr_string[idxOutput] = '\0'; // Terminates the string
|
|
|
|
return idxOutput;
|
|
}
|
|
|
|
struct LocSsrMsg : public LocMsg {
|
|
LocApiBase* mLocApi;
|
|
inline LocSsrMsg(LocApiBase* locApi) :
|
|
LocMsg(), mLocApi(locApi)
|
|
{
|
|
locallog();
|
|
}
|
|
inline virtual void proc() const {
|
|
mLocApi->close();
|
|
if (LOC_API_ADAPTER_ERR_SUCCESS == mLocApi->open(mLocApi->getEvtMask())) {
|
|
// Notify adapters that engine up after SSR
|
|
mLocApi->handleEngineUpEvent();
|
|
}
|
|
}
|
|
inline void locallog() const {
|
|
LOC_LOGV("LocSsrMsg");
|
|
}
|
|
inline virtual void log() const {
|
|
locallog();
|
|
}
|
|
};
|
|
|
|
struct LocOpenMsg : public LocMsg {
|
|
LocApiBase* mLocApi;
|
|
LocAdapterBase* mAdapter;
|
|
inline LocOpenMsg(LocApiBase* locApi, LocAdapterBase* adapter = nullptr) :
|
|
LocMsg(), mLocApi(locApi), mAdapter(adapter)
|
|
{
|
|
locallog();
|
|
}
|
|
inline virtual void proc() const {
|
|
if (LOC_API_ADAPTER_ERR_SUCCESS == mLocApi->open(mLocApi->getEvtMask()) &&
|
|
nullptr != mAdapter) {
|
|
mAdapter->handleEngineUpEvent();
|
|
}
|
|
}
|
|
inline void locallog() const {
|
|
LOC_LOGv("LocOpen Mask: %" PRIx64 "\n", mLocApi->getEvtMask());
|
|
}
|
|
inline virtual void log() const {
|
|
locallog();
|
|
}
|
|
};
|
|
|
|
struct LocCloseMsg : public LocMsg {
|
|
LocApiBase* mLocApi;
|
|
inline LocCloseMsg(LocApiBase* locApi) :
|
|
LocMsg(), mLocApi(locApi)
|
|
{
|
|
locallog();
|
|
}
|
|
inline virtual void proc() const {
|
|
mLocApi->close();
|
|
}
|
|
inline void locallog() const {
|
|
}
|
|
inline virtual void log() const {
|
|
locallog();
|
|
}
|
|
};
|
|
|
|
MsgTask* LocApiBase::mMsgTask = nullptr;
|
|
volatile int32_t LocApiBase::mMsgTaskRefCount = 0;
|
|
|
|
LocApiBase::LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
|
|
ContextBase* context) :
|
|
mContext(context),
|
|
mMask(0), mExcludedMask(excludedMask)
|
|
{
|
|
memset(mLocAdapters, 0, sizeof(mLocAdapters));
|
|
|
|
android_atomic_inc(&mMsgTaskRefCount);
|
|
if (nullptr == mMsgTask) {
|
|
mMsgTask = new MsgTask("LocApiMsgTask");
|
|
}
|
|
}
|
|
|
|
LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask()
|
|
{
|
|
LOC_API_ADAPTER_EVENT_MASK_T mask = 0;
|
|
|
|
TO_ALL_LOCADAPTERS(mask |= mLocAdapters[i]->getEvtMask());
|
|
|
|
return mask & ~mExcludedMask;
|
|
}
|
|
|
|
bool LocApiBase::isMaster()
|
|
{
|
|
bool isMaster = false;
|
|
|
|
for (int i = 0;
|
|
!isMaster && i < MAX_ADAPTERS && NULL != mLocAdapters[i];
|
|
i++) {
|
|
isMaster |= mLocAdapters[i]->isAdapterMaster();
|
|
}
|
|
return isMaster;
|
|
}
|
|
|
|
bool LocApiBase::isInSession()
|
|
{
|
|
bool inSession = false;
|
|
|
|
for (int i = 0;
|
|
!inSession && i < MAX_ADAPTERS && NULL != mLocAdapters[i];
|
|
i++) {
|
|
inSession = mLocAdapters[i]->isInSession();
|
|
}
|
|
|
|
return inSession;
|
|
}
|
|
|
|
bool LocApiBase::needReport(const UlpLocation& ulpLocation,
|
|
enum loc_sess_status status,
|
|
LocPosTechMask techMask)
|
|
{
|
|
bool reported = false;
|
|
|
|
if (LOC_SESS_SUCCESS == status) {
|
|
// this is a final fix
|
|
LocPosTechMask mask =
|
|
LOC_POS_TECH_MASK_SATELLITE | LOC_POS_TECH_MASK_SENSORS | LOC_POS_TECH_MASK_HYBRID;
|
|
// it is a Satellite fix or a sensor fix
|
|
reported = (mask & techMask);
|
|
}
|
|
else if (LOC_SESS_INTERMEDIATE == status &&
|
|
LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS) {
|
|
// this is a intermediate fix and we accept intermediate
|
|
|
|
// it is NOT the case that
|
|
// there is inaccuracy; and
|
|
// we care about inaccuracy; and
|
|
// the inaccuracy exceeds our tolerance
|
|
reported = !((ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ACCURACY) &&
|
|
(ContextBase::mGps_conf.ACCURACY_THRES != 0) &&
|
|
(ulpLocation.gpsLocation.accuracy > ContextBase::mGps_conf.ACCURACY_THRES));
|
|
}
|
|
|
|
return reported;
|
|
}
|
|
|
|
void LocApiBase::addAdapter(LocAdapterBase* adapter)
|
|
{
|
|
for (int i = 0; i < MAX_ADAPTERS && mLocAdapters[i] != adapter; i++) {
|
|
if (mLocAdapters[i] == NULL) {
|
|
mLocAdapters[i] = adapter;
|
|
sendMsg(new LocOpenMsg(this, adapter));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LocApiBase::removeAdapter(LocAdapterBase* adapter)
|
|
{
|
|
for (int i = 0;
|
|
i < MAX_ADAPTERS && NULL != mLocAdapters[i];
|
|
i++) {
|
|
if (mLocAdapters[i] == adapter) {
|
|
mLocAdapters[i] = NULL;
|
|
|
|
// shift the rest of the adapters up so that the pointers
|
|
// in the array do not have holes. This should be more
|
|
// performant, because the array maintenance is much much
|
|
// less frequent than event handlings, which need to linear
|
|
// search all the adapters
|
|
int j = i;
|
|
while (++i < MAX_ADAPTERS && mLocAdapters[i] != NULL);
|
|
|
|
// i would be MAX_ADAPTERS or point to a NULL
|
|
i--;
|
|
// i now should point to a none NULL adapter within valid
|
|
// range although i could be equal to j, but it won't hurt.
|
|
// No need to check it, as it gains nothing.
|
|
mLocAdapters[j] = mLocAdapters[i];
|
|
// this makes sure that we exit the for loop
|
|
mLocAdapters[i] = NULL;
|
|
|
|
// if we have an empty list of adapters
|
|
if (0 == i) {
|
|
sendMsg(new LocCloseMsg(this));
|
|
} else {
|
|
// else we need to remove the bit
|
|
sendMsg(new LocOpenMsg(this));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void LocApiBase::updateEvtMask()
|
|
{
|
|
sendMsg(new LocOpenMsg(this));
|
|
}
|
|
|
|
void LocApiBase::updateNmeaMask(uint32_t mask)
|
|
{
|
|
struct LocSetNmeaMsg : public LocMsg {
|
|
LocApiBase* mLocApi;
|
|
uint32_t mMask;
|
|
inline LocSetNmeaMsg(LocApiBase* locApi, uint32_t mask) :
|
|
LocMsg(), mLocApi(locApi), mMask(mask)
|
|
{
|
|
locallog();
|
|
}
|
|
inline virtual void proc() const {
|
|
mLocApi->setNMEATypesSync(mMask);
|
|
}
|
|
inline void locallog() const {
|
|
LOC_LOGv("LocSyncNmea NmeaMask: %" PRIx32 "\n", mMask);
|
|
}
|
|
inline virtual void log() const {
|
|
locallog();
|
|
}
|
|
};
|
|
|
|
sendMsg(new LocSetNmeaMsg(this, mask));
|
|
}
|
|
|
|
void LocApiBase::handleEngineUpEvent()
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineUpEvent());
|
|
}
|
|
|
|
void LocApiBase::handleEngineDownEvent()
|
|
{ // This will take care of renegotiating the loc handle
|
|
sendMsg(new LocSsrMsg(this));
|
|
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent());
|
|
}
|
|
|
|
void LocApiBase::reportPosition(UlpLocation& location,
|
|
GpsLocationExtended& locationExtended,
|
|
enum loc_sess_status status,
|
|
LocPosTechMask loc_technology_mask,
|
|
GnssDataNotification* pDataNotify,
|
|
int msInWeek)
|
|
{
|
|
// print the location info before delivering
|
|
LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
|
|
"altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
|
|
"timestamp: %" PRId64 "\n"
|
|
"Session status: %d\n Technology mask: %u\n "
|
|
"SV used in fix (gps/glo/bds/gal/qzss) : \
|
|
(0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 ")",
|
|
location.gpsLocation.flags, location.position_source,
|
|
location.gpsLocation.latitude, location.gpsLocation.longitude,
|
|
location.gpsLocation.altitude, location.gpsLocation.speed,
|
|
location.gpsLocation.bearing, location.gpsLocation.accuracy,
|
|
location.gpsLocation.timestamp, status, loc_technology_mask,
|
|
locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask,
|
|
locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask,
|
|
locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask,
|
|
locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask,
|
|
locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask,
|
|
locationExtended.gnss_sv_used_ids.navic_sv_used_ids_mask);
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(
|
|
mLocAdapters[i]->reportPositionEvent(location, locationExtended,
|
|
status, loc_technology_mask,
|
|
pDataNotify, msInWeek)
|
|
);
|
|
}
|
|
|
|
void LocApiBase::reportWwanZppFix(LocGpsLocation &zppLoc)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportWwanZppFix(zppLoc));
|
|
}
|
|
|
|
void LocApiBase::reportZppBestAvailableFix(LocGpsLocation &zppLoc,
|
|
GpsLocationExtended &location_extended, LocPosTechMask tech_mask)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportZppBestAvailableFix(zppLoc,
|
|
location_extended, tech_mask));
|
|
}
|
|
|
|
void LocApiBase::requestOdcpi(OdcpiRequestInfo& request)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestOdcpiEvent(request));
|
|
}
|
|
|
|
void LocApiBase::reportGnssEngEnergyConsumedEvent(uint64_t energyConsumedSinceFirstBoot)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssEngEnergyConsumedEvent(
|
|
energyConsumedSinceFirstBoot));
|
|
}
|
|
|
|
void LocApiBase::reportDeleteAidingDataEvent(GnssAidingData& aidingData) {
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDeleteAidingDataEvent(aidingData));
|
|
}
|
|
|
|
void LocApiBase::reportKlobucharIonoModel(GnssKlobucharIonoModel & ionoModel) {
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportKlobucharIonoModelEvent(ionoModel));
|
|
}
|
|
|
|
void LocApiBase::reportGnssAdditionalSystemInfo(GnssAdditionalSystemInfo& additionalSystemInfo) {
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportGnssAdditionalSystemInfoEvent(
|
|
additionalSystemInfo));
|
|
}
|
|
|
|
void LocApiBase::sendNfwNotification(GnssNfwNotification& notification)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNfwNotificationEvent(notification));
|
|
|
|
}
|
|
|
|
void LocApiBase::reportSv(GnssSvNotification& svNotify)
|
|
{
|
|
const char* constellationString[] = { "Unknown", "GPS", "SBAS", "GLONASS",
|
|
"QZSS", "BEIDOU", "GALILEO", "NAVIC" };
|
|
|
|
// print the SV info before delivering
|
|
LOC_LOGV("num sv: %u\n"
|
|
" sv: constellation svid cN0 basebandCN0"
|
|
" elevation azimuth flags",
|
|
svNotify.count);
|
|
for (size_t i = 0; i < svNotify.count && i < GNSS_SV_MAX; i++) {
|
|
if (svNotify.gnssSvs[i].type >
|
|
sizeof(constellationString) / sizeof(constellationString[0]) - 1) {
|
|
svNotify.gnssSvs[i].type = GNSS_SV_TYPE_UNKNOWN;
|
|
}
|
|
// Display what we report to clients
|
|
LOC_LOGV(" %03zu: %*s %02d %f %f %f %f %f 0x%02X 0x%2X",
|
|
i,
|
|
13,
|
|
constellationString[svNotify.gnssSvs[i].type],
|
|
svNotify.gnssSvs[i].svId,
|
|
svNotify.gnssSvs[i].cN0Dbhz,
|
|
svNotify.gnssSvs[i].basebandCarrierToNoiseDbHz,
|
|
svNotify.gnssSvs[i].elevation,
|
|
svNotify.gnssSvs[i].azimuth,
|
|
svNotify.gnssSvs[i].carrierFrequencyHz,
|
|
svNotify.gnssSvs[i].gnssSvOptionsMask,
|
|
svNotify.gnssSvs[i].gnssSignalTypeMask);
|
|
}
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(
|
|
mLocAdapters[i]->reportSvEvent(svNotify)
|
|
);
|
|
}
|
|
|
|
void LocApiBase::reportSvPolynomial(GnssSvPolynomial &svPolynomial)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(
|
|
mLocAdapters[i]->reportSvPolynomialEvent(svPolynomial)
|
|
);
|
|
}
|
|
|
|
void LocApiBase::reportSvEphemeris(GnssSvEphemerisReport & svEphemeris)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(
|
|
mLocAdapters[i]->reportSvEphemerisEvent(svEphemeris)
|
|
);
|
|
}
|
|
|
|
void LocApiBase::reportStatus(LocGpsStatusValue status)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status));
|
|
}
|
|
|
|
void LocApiBase::reportData(GnssDataNotification& dataNotify, int msInWeek)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportDataEvent(dataNotify, msInWeek));
|
|
}
|
|
|
|
void LocApiBase::reportNmea(const char* nmea, int length)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmeaEvent(nmea, length));
|
|
}
|
|
|
|
void LocApiBase::reportXtraServer(const char* url1, const char* url2,
|
|
const char* url3, const int maxlength)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportXtraServer(url1, url2, url3, maxlength));
|
|
|
|
}
|
|
|
|
void LocApiBase::reportLocationSystemInfo(const LocationSystemInfo& locationSystemInfo)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportLocationSystemInfoEvent(locationSystemInfo));
|
|
}
|
|
|
|
void LocApiBase::reportQwesCapabilities
|
|
(
|
|
const std::unordered_map<LocationQwesFeatureType, bool> &featureMap
|
|
)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportQwesCapabilities(featureMap));
|
|
}
|
|
void LocApiBase::requestXtraData()
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestXtraData());
|
|
}
|
|
|
|
void LocApiBase::requestTime()
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestTime());
|
|
}
|
|
|
|
void LocApiBase::requestLocation()
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestLocation());
|
|
}
|
|
|
|
void LocApiBase::requestATL(int connHandle, LocAGpsType agps_type,
|
|
LocApnTypeMask apn_type_mask)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(
|
|
mLocAdapters[i]->requestATL(connHandle, agps_type, apn_type_mask));
|
|
}
|
|
|
|
void LocApiBase::releaseATL(int connHandle)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->releaseATL(connHandle));
|
|
}
|
|
|
|
void LocApiBase::requestNiNotify(GnssNiNotification ¬ify, const void* data,
|
|
const LocInEmergency emergencyState)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_1ST_HANDLING_LOCADAPTERS(
|
|
mLocAdapters[i]->requestNiNotifyEvent(notify,
|
|
data,
|
|
emergencyState));
|
|
}
|
|
|
|
void* LocApiBase :: getSibling()
|
|
DEFAULT_IMPL(NULL)
|
|
|
|
LocApiProxyBase* LocApiBase :: getLocApiProxy()
|
|
DEFAULT_IMPL(NULL)
|
|
|
|
void LocApiBase::reportGnssMeasurements(GnssMeasurements& gnssMeasurements, int msInWeek)
|
|
{
|
|
// loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementsEvent(gnssMeasurements, msInWeek));
|
|
}
|
|
|
|
void LocApiBase::reportGnssSvIdConfig(const GnssSvIdConfig& config)
|
|
{
|
|
// Print the config
|
|
LOC_LOGv("gloBlacklistSvMask: %" PRIu64 ", bdsBlacklistSvMask: %" PRIu64 ",\n"
|
|
"qzssBlacklistSvMask: %" PRIu64 ", galBlacklistSvMask: %" PRIu64 ",\n"
|
|
"navicBlacklistSvMask: %" PRIu64,
|
|
config.gloBlacklistSvMask, config.bdsBlacklistSvMask,
|
|
config.qzssBlacklistSvMask, config.galBlacklistSvMask, config.navicBlacklistSvMask);
|
|
|
|
// Loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssSvIdConfigEvent(config));
|
|
}
|
|
|
|
void LocApiBase::reportGnssSvTypeConfig(const GnssSvTypeConfig& config)
|
|
{
|
|
// Print the config
|
|
LOC_LOGv("blacklistedMask: %" PRIu64 ", enabledMask: %" PRIu64,
|
|
config.blacklistedSvTypesMask, config.enabledSvTypesMask);
|
|
|
|
// Loop through adapters, and deliver to all adapters.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssSvTypeConfigEvent(config));
|
|
}
|
|
|
|
void LocApiBase::geofenceBreach(size_t count, uint32_t* hwIds, Location& location,
|
|
GeofenceBreachType breachType, uint64_t timestamp)
|
|
{
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->geofenceBreachEvent(count, hwIds, location, breachType,
|
|
timestamp));
|
|
}
|
|
|
|
void LocApiBase::geofenceStatus(GeofenceStatusAvailable available)
|
|
{
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->geofenceStatusEvent(available));
|
|
}
|
|
|
|
void LocApiBase::reportDBTPosition(UlpLocation &location, GpsLocationExtended &locationExtended,
|
|
enum loc_sess_status status, LocPosTechMask loc_technology_mask)
|
|
{
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportPositionEvent(location, locationExtended, status,
|
|
loc_technology_mask));
|
|
}
|
|
|
|
void LocApiBase::reportLocations(Location* locations, size_t count, BatchingMode batchingMode)
|
|
{
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportLocationsEvent(locations, count, batchingMode));
|
|
}
|
|
|
|
void LocApiBase::reportCompletedTrips(uint32_t accumulated_distance)
|
|
{
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportCompletedTripsEvent(accumulated_distance));
|
|
}
|
|
|
|
void LocApiBase::handleBatchStatusEvent(BatchingStatus batchStatus)
|
|
{
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportBatchStatusChangeEvent(batchStatus));
|
|
}
|
|
|
|
void LocApiBase::reportGnssConfig(uint32_t sessionId, const GnssConfig& gnssConfig)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssConfigEvent(sessionId, gnssConfig));
|
|
}
|
|
|
|
void LocApiBase::reportLatencyInfo(GnssLatencyInfo& gnssLatencyInfo)
|
|
{
|
|
// loop through adapters, and deliver to the first handling adapter.
|
|
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportLatencyInfoEvent(gnssLatencyInfo));
|
|
}
|
|
|
|
enum loc_api_adapter_err LocApiBase::
|
|
open(LOC_API_ADAPTER_EVENT_MASK_T /*mask*/)
|
|
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
|
|
|
|
enum loc_api_adapter_err LocApiBase::
|
|
close()
|
|
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
|
|
|
|
void LocApiBase::startFix(const LocPosMode& /*posMode*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::stopFix(LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
deleteAidingData(const GnssAidingData& /*data*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
injectPosition(double /*latitude*/, double /*longitude*/, float /*accuracy*/,
|
|
bool /*onDemandCpi*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
injectPosition(const Location& /*location*/, bool /*onDemandCpi*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
injectPosition(const GnssLocationInfoNotification & /*locationInfo*/, bool /*onDemandCpi*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
setTime(LocGpsUtcTime /*time*/, int64_t /*timeReference*/, int /*uncertainty*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
atlOpenStatus(int /*handle*/, int /*is_succ*/, char* /*apn*/, uint32_t /*apnLen*/,
|
|
AGpsBearerType /*bear*/, LocAGpsType /*agpsType*/,
|
|
LocApnTypeMask /*mask*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
atlCloseStatus(int /*handle*/, int /*is_succ*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::
|
|
setServerSync(const char* /*url*/, int /*len*/, LocServerType /*type*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
LocationError LocApiBase::
|
|
setServerSync(unsigned int /*ip*/, int /*port*/, LocServerType /*type*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::
|
|
informNiResponse(GnssNiResponse /*userResponse*/, const void* /*passThroughData*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::
|
|
setSUPLVersionSync(GnssConfigSuplVersion /*version*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
enum loc_api_adapter_err LocApiBase::
|
|
setNMEATypesSync (uint32_t /*typesMask*/)
|
|
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
|
|
|
|
LocationError LocApiBase::
|
|
setLPPConfigSync(GnssConfigLppProfileMask /*profileMask*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
|
|
enum loc_api_adapter_err LocApiBase::
|
|
setSensorPropertiesSync(bool /*gyroBiasVarianceRandomWalk_valid*/,
|
|
float /*gyroBiasVarianceRandomWalk*/,
|
|
bool /*accelBiasVarianceRandomWalk_valid*/,
|
|
float /*accelBiasVarianceRandomWalk*/,
|
|
bool /*angleBiasVarianceRandomWalk_valid*/,
|
|
float /*angleBiasVarianceRandomWalk*/,
|
|
bool /*rateBiasVarianceRandomWalk_valid*/,
|
|
float /*rateBiasVarianceRandomWalk*/,
|
|
bool /*velocityBiasVarianceRandomWalk_valid*/,
|
|
float /*velocityBiasVarianceRandomWalk*/)
|
|
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
|
|
|
|
enum loc_api_adapter_err LocApiBase::
|
|
setSensorPerfControlConfigSync(int /*controlMode*/,
|
|
int /*accelSamplesPerBatch*/,
|
|
int /*accelBatchesPerSec*/,
|
|
int /*gyroSamplesPerBatch*/,
|
|
int /*gyroBatchesPerSec*/,
|
|
int /*accelSamplesPerBatchHigh*/,
|
|
int /*accelBatchesPerSecHigh*/,
|
|
int /*gyroSamplesPerBatchHigh*/,
|
|
int /*gyroBatchesPerSecHigh*/,
|
|
int /*algorithmConfig*/)
|
|
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
|
|
|
|
LocationError LocApiBase::
|
|
setAGLONASSProtocolSync(GnssConfigAGlonassPositionProtocolMask /*aGlonassProtocol*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
LocationError LocApiBase::
|
|
setLPPeProtocolCpSync(GnssConfigLppeControlPlaneMask /*lppeCP*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
LocationError LocApiBase::
|
|
setLPPeProtocolUpSync(GnssConfigLppeUserPlaneMask /*lppeUP*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
GnssConfigSuplVersion LocApiBase::convertSuplVersion(const uint32_t /*suplVersion*/)
|
|
DEFAULT_IMPL(GNSS_CONFIG_SUPL_VERSION_1_0_0)
|
|
|
|
GnssConfigLppeControlPlaneMask LocApiBase::convertLppeCp(const uint32_t /*lppeControlPlaneMask*/)
|
|
DEFAULT_IMPL(0)
|
|
|
|
GnssConfigLppeUserPlaneMask LocApiBase::convertLppeUp(const uint32_t /*lppeUserPlaneMask*/)
|
|
DEFAULT_IMPL(0)
|
|
|
|
LocationError LocApiBase::setEmergencyExtensionWindowSync(
|
|
const uint32_t /*emergencyExtensionSeconds*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::setMeasurementCorrections(
|
|
const GnssMeasurementCorrections& /*gnssMeasurementCorrections*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
getWwanZppFix()
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
getBestAvailableZppFix()
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::
|
|
setGpsLockSync(GnssConfigGpsLock /*lock*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::
|
|
requestForAidingData(GnssAidingDataSvMask /*svDataMask*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::
|
|
setXtraVersionCheckSync(uint32_t /*check*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
LocationError LocApiBase::setBlacklistSvSync(const GnssSvIdConfig& /*config*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::setBlacklistSv(const GnssSvIdConfig& /*config*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::getBlacklistSv()
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::setConstellationControl(const GnssSvTypeConfig& /*config*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::getConstellationControl()
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::resetConstellationControl(LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
setConstrainedTuncMode(bool /*enabled*/,
|
|
float /*tuncConstraint*/,
|
|
uint32_t /*energyBudget*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
setPositionAssistedClockEstimatorMode(bool /*enabled*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::getGnssEnergyConsumed()
|
|
DEFAULT_IMPL()
|
|
|
|
|
|
void LocApiBase::addGeofence(uint32_t /*clientId*/, const GeofenceOption& /*options*/,
|
|
const GeofenceInfo& /*info*/,
|
|
LocApiResponseData<LocApiGeofenceData>* /*adapterResponseData*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::removeGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::pauseGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::resumeGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::modifyGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
|
|
const GeofenceOption& /*options*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::startTimeBasedTracking(const TrackingOptions& /*options*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::stopTimeBasedTracking(LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::startDistanceBasedTracking(uint32_t /*sessionId*/,
|
|
const LocationOptions& /*options*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::stopDistanceBasedTracking(uint32_t /*sessionId*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::startBatching(uint32_t /*sessionId*/, const LocationOptions& /*options*/,
|
|
uint32_t /*accuracy*/, uint32_t /*timeout*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::stopBatching(uint32_t /*sessionId*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::startOutdoorTripBatchingSync(uint32_t /*tripDistance*/,
|
|
uint32_t /*tripTbf*/, uint32_t /*timeout*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::startOutdoorTripBatching(uint32_t /*tripDistance*/, uint32_t /*tripTbf*/,
|
|
uint32_t /*timeout*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::reStartOutdoorTripBatching(uint32_t /*ongoingTripDistance*/,
|
|
uint32_t /*ongoingTripInterval*/, uint32_t /*batchingTimeout,*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::stopOutdoorTripBatchingSync(bool /*deallocBatchBuffer*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::stopOutdoorTripBatching(bool /*deallocBatchBuffer*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::getBatchedLocationsSync(size_t /*count*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::getBatchedLocations(size_t /*count*/, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::getBatchedTripLocationsSync(size_t /*count*/,
|
|
uint32_t /*accumulatedDistance*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::getBatchedTripLocations(size_t /*count*/, uint32_t /*accumulatedDistance*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::queryAccumulatedTripDistanceSync(uint32_t& /*accumulated_trip_distance*/,
|
|
uint32_t& /*numOfBatchedPositions*/)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::queryAccumulatedTripDistance(
|
|
LocApiResponseData<LocApiBatchData>* /*adapterResponseData*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::setBatchSize(size_t /*size*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::setTripBatchSize(size_t /*size*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::addToCallQueue(LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::updateSystemPowerState(PowerStateType /*powerState*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
configRobustLocation(bool /*enabled*/,
|
|
bool /*enableForE911*/,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
getRobustLocationConfig(uint32_t sessionId, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
configMinGpsWeek(uint16_t minGpsWeek,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
getMinGpsWeek(uint32_t sessionId, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
LocationError LocApiBase::
|
|
setParameterSync(const GnssConfig& gnssConfig)
|
|
DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
|
|
|
|
void LocApiBase::
|
|
getParameter(uint32_t sessionId, GnssConfigFlagsMask flags, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
configConstellationMultiBand(const GnssSvTypeConfig& secondaryBandConfig,
|
|
LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
void LocApiBase::
|
|
getConstellationMultiBandConfig(uint32_t sessionId, LocApiResponse* /*adapterResponse*/)
|
|
DEFAULT_IMPL()
|
|
|
|
int64_t ElapsedRealtimeEstimator::getElapsedRealtimeEstimateNanos(int64_t curDataTimeNanos,
|
|
bool isCurDataTimeTrustable, int64_t tbf) {
|
|
//The algorithm works follow below steps:
|
|
//When isCurDataTimeTrustable is meet (means Modem timestamp is already stable),
|
|
//1, Wait for mFixTimeStablizationThreshold fixes; While waiting for modem time
|
|
// stable, we set the traveltime to a default value;
|
|
//2, When the mFixTimeStablizationThreshold fix comes, we think now the mode time
|
|
// is already stable, calculate the initial AP-Modem clock diff(mCurrentClockDiff)
|
|
// using formula:
|
|
// mCurrentClockDiff = currentTimeNanos - locationTimeNanos - currentTravelTimeNanos
|
|
//3, since then, when the nth fix comes,
|
|
// 3.1 First update mCurrentClockDiff using below formula:
|
|
// mCurrentClockDiff = mCurrentClockDiff + (currentTimeNanos - sinceBootTimeNanos)
|
|
// - (mPrevUtcTimeNanos - mPrevBootTimeNanos)
|
|
// 3.2 Calculate currentTravelTimeNanos:
|
|
// currentTravelTimeNanos = currentTimeNanos - locationTimeNanos - mCurrentClockDiff
|
|
//4, It is possible that locationTimeNanos will jump,
|
|
// reset mFixTimeStablizationThreshold to default value, jump to step 2 to continue.
|
|
|
|
int64_t currentTravelTimeNanos = mInitialTravelTime;
|
|
struct timespec currentTime;
|
|
int64_t sinceBootTimeNanos;
|
|
if (getCurrentTime(currentTime, sinceBootTimeNanos)) {
|
|
if (isCurDataTimeTrustable) {
|
|
if (tbf > 0 && tbf != curDataTimeNanos - mPrevDataTimeNanos) {
|
|
mFixTimeStablizationThreshold = 5;
|
|
}
|
|
int64_t currentTimeNanos = (int64_t)currentTime.tv_sec*1000000000 + currentTime.tv_nsec;
|
|
LOC_LOGd("sinceBootTimeNanos:%" PRIi64 " currentTimeNanos:%" PRIi64 ""
|
|
" locationTimeNanos:%" PRIi64 "",
|
|
sinceBootTimeNanos, currentTimeNanos, curDataTimeNanos);
|
|
if (mFixTimeStablizationThreshold == 0) {
|
|
currentTravelTimeNanos = mInitialTravelTime;
|
|
mCurrentClockDiff = currentTimeNanos - curDataTimeNanos - currentTravelTimeNanos;
|
|
} else if (mFixTimeStablizationThreshold < 0) {
|
|
mCurrentClockDiff = mCurrentClockDiff + (currentTimeNanos - sinceBootTimeNanos)
|
|
- (mPrevUtcTimeNanos - mPrevBootTimeNanos);
|
|
currentTravelTimeNanos = currentTimeNanos - curDataTimeNanos - mCurrentClockDiff;
|
|
}
|
|
|
|
mPrevUtcTimeNanos = currentTimeNanos;
|
|
mPrevBootTimeNanos = sinceBootTimeNanos;
|
|
mPrevDataTimeNanos = curDataTimeNanos;
|
|
mFixTimeStablizationThreshold--;
|
|
}
|
|
} else {
|
|
return -1;
|
|
}
|
|
LOC_LOGd("Estimated travel time: %" PRIi64 "", currentTravelTimeNanos);
|
|
return (sinceBootTimeNanos - currentTravelTimeNanos);
|
|
}
|
|
|
|
void ElapsedRealtimeEstimator::reset() {
|
|
mCurrentClockDiff = 0;
|
|
mPrevDataTimeNanos = 0;
|
|
mPrevUtcTimeNanos = 0;
|
|
mPrevBootTimeNanos = 0;
|
|
mFixTimeStablizationThreshold = 5;
|
|
}
|
|
|
|
int64_t ElapsedRealtimeEstimator::getElapsedRealtimeQtimer(int64_t qtimerTicksAtOrigin) {
|
|
struct timespec currentTime;
|
|
int64_t sinceBootTimeNanos;
|
|
int64_t elapsedRealTimeNanos;
|
|
|
|
if (getCurrentTime(currentTime, sinceBootTimeNanos)) {
|
|
uint64_t qtimerDiff = 0;
|
|
uint64_t qTimerTickCount = getQTimerTickCount();
|
|
if (qTimerTickCount >= qtimerTicksAtOrigin) {
|
|
qtimerDiff = qTimerTickCount - qtimerTicksAtOrigin;
|
|
}
|
|
LOC_LOGd("sinceBootTimeNanos:%" PRIi64 " qtimerTicksAtOrigin=%" PRIi64 ""
|
|
" qTimerTickCount=%" PRIi64 " qtimerDiff=%" PRIi64 "",
|
|
sinceBootTimeNanos, qtimerTicksAtOrigin, qTimerTickCount, qtimerDiff);
|
|
uint64_t qTimerDiffNanos = qTimerTicksToNanos(double(qtimerDiff));
|
|
|
|
/* If the time difference between Qtimer on modem side and Qtimer on AP side
|
|
is greater than one second we assume this is a dual-SoC device such as
|
|
Kona and will try to get Qtimer on modem side and on AP side and
|
|
will adjust our difference accordingly */
|
|
if (qTimerDiffNanos > 1000000000) {
|
|
uint64_t qtimerDelta = getQTimerDeltaNanos();
|
|
if (qTimerDiffNanos >= qtimerDelta) {
|
|
qTimerDiffNanos -= qtimerDelta;
|
|
}
|
|
}
|
|
|
|
LOC_LOGd("Qtimer travel time: %" PRIi64 "", qTimerDiffNanos);
|
|
if (sinceBootTimeNanos >= qTimerDiffNanos) {
|
|
elapsedRealTimeNanos = sinceBootTimeNanos - qTimerDiffNanos;
|
|
} else {
|
|
elapsedRealTimeNanos = -1;
|
|
}
|
|
} else {
|
|
elapsedRealTimeNanos = -1;
|
|
}
|
|
return elapsedRealTimeNanos;
|
|
}
|
|
|
|
bool ElapsedRealtimeEstimator::getCurrentTime(
|
|
struct timespec& currentTime, int64_t& sinceBootTimeNanos)
|
|
{
|
|
struct timespec sinceBootTime;
|
|
struct timespec sinceBootTimeTest;
|
|
bool clockGetTimeSuccess = false;
|
|
const uint32_t MAX_TIME_DELTA_VALUE_NANOS = 10000;
|
|
const uint32_t MAX_GET_TIME_COUNT = 20;
|
|
/* Attempt to get CLOCK_REALTIME and CLOCK_BOOTIME in succession without an interruption
|
|
or context switch (for up to MAX_GET_TIME_COUNT times) to avoid errors in the calculation */
|
|
for (uint32_t i = 0; i < MAX_GET_TIME_COUNT; i++) {
|
|
if (clock_gettime(CLOCK_BOOTTIME, &sinceBootTime) != 0) {
|
|
break;
|
|
};
|
|
if (clock_gettime(CLOCK_REALTIME, ¤tTime) != 0) {
|
|
break;
|
|
}
|
|
if (clock_gettime(CLOCK_BOOTTIME, &sinceBootTimeTest) != 0) {
|
|
break;
|
|
};
|
|
sinceBootTimeNanos = (int64_t)sinceBootTime.tv_sec * 1000000000 + sinceBootTime.tv_nsec;
|
|
int64_t sinceBootTimeTestNanos =
|
|
(int64_t)sinceBootTimeTest.tv_sec * 1000000000 + sinceBootTimeTest.tv_nsec;
|
|
int64_t sinceBootTimeDeltaNanos = sinceBootTimeTestNanos - sinceBootTimeNanos;
|
|
|
|
/* sinceBootTime and sinceBootTimeTest should have a close value if there was no
|
|
interruption or context switch between clock_gettime for CLOCK_BOOTIME and
|
|
clock_gettime for CLOCK_REALTIME */
|
|
if (sinceBootTimeDeltaNanos < MAX_TIME_DELTA_VALUE_NANOS) {
|
|
clockGetTimeSuccess = true;
|
|
break;
|
|
} else {
|
|
LOC_LOGd("Delta:%" PRIi64 "ns time too large, retry number #%u...",
|
|
sinceBootTimeDeltaNanos, i + 1);
|
|
}
|
|
}
|
|
return clockGetTimeSuccess;
|
|
}
|
|
} // namespace loc_core
|