MiPad4/android_device_xiaomi_sdm660-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SystemStatus - Add reported UTC timestamp in report

Browse source 
Add reported UTC timestamp field in systemstatus' report
data structure. It indicates the system UTC time when the
information was last received from provider such as modem.

Change-Id: I31beb64958c980242ea65fb9a602e18985ad17e1
CRs-Fixed: 2012926
This commit is contained in:
Katz Yamada 2017-04-10 16:16:46 -07:00 committed by Gerrit - the friendly Code Review server
parent f3a58cea24
commit f7a8f2cded
2 changed files with 46 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

103
core/SystemStatus.cpp
View file

@ -47,7 +47,6 @@ class SystemStatusNmeaBase
{ {
protected: protected:
std::vector<std::string> mField; std::vector<std::string> mField;
timespec setUtcTime(std::string sutctime);
SystemStatusNmeaBase(const char *str_in, uint32_t len_in) SystemStatusNmeaBase(const char *str_in, uint32_t len_in)
{ {
@ -86,31 +85,12 @@ public:
static const uint32_t NMEA_MAXSIZE = DEBUG_NMEA_MAXSIZE; static const uint32_t NMEA_MAXSIZE = DEBUG_NMEA_MAXSIZE;
}; };
timespec SystemStatusNmeaBase::setUtcTime(std::string sutctime)
{
timespec ts = { 0ULL, 0ULL };
uint64_t utctime_ns = atof(sutctime.c_str()) * 1000000000ULL;
ts.tv_nsec = utctime_ns % 1000000000ULL;
uint64_t utctime_s = utctime_ns / 1000000000ULL;
uint64_t hour = utctime_s / 10000ULL;
uint64_t min = (utctime_s / 100LL) % 100ULL;
uint64_t sec = utctime_s % 100ULL;
ts.tv_sec = hour * 3600ULL + min * 60ULL + sec;
timeval tv;
gettimeofday(&tv, NULL);
ts.tv_sec += (uint64_t(tv.tv_sec / (24ULL * 60ULL * 60ULL))) * (24ULL * 60ULL * 60ULL);
return ts;
}
/****************************************************************************** /******************************************************************************
SystemStatusPQWM1 SystemStatusPQWM1
******************************************************************************/ ******************************************************************************/
class SystemStatusPQWM1 class SystemStatusPQWM1
{ {
public: public:
timespec mUtcTime;
uint16_t mGpsWeek; // x1 uint16_t mGpsWeek; // x1
uint32_t mGpsTowMs; // x2 uint32_t mGpsTowMs; // x2
uint8_t mTimeValid; // x3 uint8_t mTimeValid; // x3
@ -199,11 +179,6 @@ public:
return; return;
} }
memset(&mM1, 0, sizeof(mM1)); memset(&mM1, 0, sizeof(mM1));
timeval tv;
gettimeofday(&tv, NULL);
mM1.mUtcTime.tv_sec = tv.tv_sec;
mM1.mUtcTime.tv_nsec = tv.tv_usec * 1000UL;
mM1.mGpsWeek = atoi(mField[eGpsWeek].c_str()); mM1.mGpsWeek = atoi(mField[eGpsWeek].c_str());
mM1.mGpsTowMs = atoi(mField[eGpsTowMs].c_str()); mM1.mGpsTowMs = atoi(mField[eGpsTowMs].c_str());
mM1.mTimeValid = atoi(mField[eTimeValid].c_str()); mM1.mTimeValid = atoi(mField[eTimeValid].c_str());
@ -237,7 +212,6 @@ public:
class SystemStatusPQWP1 class SystemStatusPQWP1
{ {
public: public:
timespec mUtcTime;
uint8_t mEpiValidity; // x4 uint8_t mEpiValidity; // x4
float mEpiLat; // x5 float mEpiLat; // x5
float mEpiLon; // x6 float mEpiLon; // x6
@ -266,7 +240,6 @@ private:
SystemStatusPQWP1 mP1; SystemStatusPQWP1 mP1;
public: public:
inline timespec getUtcTime() { return mP1.mUtcTime; }
inline uint8_t getEpiValidity() { return mP1.mEpiValidity; } inline uint8_t getEpiValidity() { return mP1.mEpiValidity; }
inline float getEpiLat() { return mP1.mEpiLat; } inline float getEpiLat() { return mP1.mEpiLat; }
inline float getEpiLon() { return mP1.mEpiLon; } inline float getEpiLon() { return mP1.mEpiLon; }
@ -282,7 +255,6 @@ public:
return; return;
} }
memset(&mP1, 0, sizeof(mP1)); memset(&mP1, 0, sizeof(mP1));
mP1.mUtcTime = setUtcTime(mField[eUtcTime]);
mP1.mEpiValidity = strtol(mField[eEpiValidity].c_str(), NULL, 16); mP1.mEpiValidity = strtol(mField[eEpiValidity].c_str(), NULL, 16);
mP1.mEpiLat = atof(mField[eEpiLat].c_str()); mP1.mEpiLat = atof(mField[eEpiLat].c_str());
mP1.mEpiLon = atof(mField[eEpiLon].c_str()); mP1.mEpiLon = atof(mField[eEpiLon].c_str());
@ -301,7 +273,6 @@ public:
class SystemStatusPQWP2 class SystemStatusPQWP2
{ {
public: public:
timespec mUtcTime;
float mBestLat; // x4 float mBestLat; // x4
float mBestLon; // x5 float mBestLon; // x5
float mBestAlt; // x6 float mBestAlt; // x6
@ -339,7 +310,6 @@ public:
return; return;
} }
memset(&mP2, 0, sizeof(mP2)); memset(&mP2, 0, sizeof(mP2));
mP2.mUtcTime = setUtcTime(mField[eUtcTime]);
mP2.mBestLat = atof(mField[eBestLat].c_str()); mP2.mBestLat = atof(mField[eBestLat].c_str());
mP2.mBestLon = atof(mField[eBestLon].c_str()); mP2.mBestLon = atof(mField[eBestLon].c_str());
mP2.mBestAlt = atof(mField[eBestAlt].c_str()); mP2.mBestAlt = atof(mField[eBestAlt].c_str());
@ -356,7 +326,6 @@ public:
class SystemStatusPQWP3 class SystemStatusPQWP3
{ {
public: public:
timespec mUtcTime;
uint8_t mXtraValidMask; uint8_t mXtraValidMask;
uint32_t mGpsXtraAge; uint32_t mGpsXtraAge;
uint32_t mGloXtraAge; uint32_t mGloXtraAge;
@ -412,7 +381,6 @@ public:
return; return;
} }
memset(&mP3, 0, sizeof(mP3)); memset(&mP3, 0, sizeof(mP3));
mP3.mUtcTime = setUtcTime(mField[eUtcTime]);
mP3.mXtraValidMask = strtol(mField[eXtraValidMask].c_str(), NULL, 16); mP3.mXtraValidMask = strtol(mField[eXtraValidMask].c_str(), NULL, 16);
mP3.mGpsXtraAge = atoi(mField[eGpsXtraAge].c_str()); mP3.mGpsXtraAge = atoi(mField[eGpsXtraAge].c_str());
mP3.mGloXtraAge = atoi(mField[eGloXtraAge].c_str()); mP3.mGloXtraAge = atoi(mField[eGloXtraAge].c_str());
@ -435,7 +403,6 @@ public:
class SystemStatusPQWP4 class SystemStatusPQWP4
{ {
public: public:
timespec mUtcTime;
uint32_t mGpsEpheValid; uint32_t mGpsEpheValid;
uint32_t mGloEpheValid; uint32_t mGloEpheValid;
uint64_t mBdsEpheValid; uint64_t mBdsEpheValid;
@ -473,7 +440,6 @@ public:
return; return;
} }
memset(&mP4, 0, sizeof(mP4)); memset(&mP4, 0, sizeof(mP4));
mP4.mUtcTime = setUtcTime(mField[eUtcTime]);
mP4.mGpsEpheValid = strtol(mField[eGpsEpheValid].c_str(), NULL, 16); mP4.mGpsEpheValid = strtol(mField[eGpsEpheValid].c_str(), NULL, 16);
mP4.mGloEpheValid = strtol(mField[eGloEpheValid].c_str(), NULL, 16); mP4.mGloEpheValid = strtol(mField[eGloEpheValid].c_str(), NULL, 16);
mP4.mBdsEpheValid = strtol(mField[eBdsEpheValid].c_str(), NULL, 16); mP4.mBdsEpheValid = strtol(mField[eBdsEpheValid].c_str(), NULL, 16);
@ -490,7 +456,6 @@ public:
class SystemStatusPQWP5 class SystemStatusPQWP5
{ {
public: public:
timespec mUtcTime;
uint32_t mGpsUnknownMask; uint32_t mGpsUnknownMask;
uint32_t mGloUnknownMask; uint32_t mGloUnknownMask;
uint64_t mBdsUnknownMask; uint64_t mBdsUnknownMask;
@ -558,7 +523,6 @@ public:
return; return;
} }
memset(&mP5, 0, sizeof(mP5)); memset(&mP5, 0, sizeof(mP5));
mP5.mUtcTime = setUtcTime(mField[eUtcTime]);
mP5.mGpsUnknownMask = strtol(mField[eGpsUnknownMask].c_str(), NULL, 16); mP5.mGpsUnknownMask = strtol(mField[eGpsUnknownMask].c_str(), NULL, 16);
mP5.mGloUnknownMask = strtol(mField[eGloUnknownMask].c_str(), NULL, 16); mP5.mGloUnknownMask = strtol(mField[eGloUnknownMask].c_str(), NULL, 16);
mP5.mBdsUnknownMask = strtol(mField[eBdsUnknownMask].c_str(), NULL, 16); mP5.mBdsUnknownMask = strtol(mField[eBdsUnknownMask].c_str(), NULL, 16);
@ -585,7 +549,6 @@ public:
class SystemStatusPQWP6 class SystemStatusPQWP6
{ {
public: public:
timespec mUtcTime;
uint32_t mFixInfoMask; uint32_t mFixInfoMask;
}; };
@ -611,7 +574,6 @@ public:
return; return;
} }
memset(&mP6, 0, sizeof(mP6)); memset(&mP6, 0, sizeof(mP6));
mP6.mUtcTime = setUtcTime(mField[eUtcTime]);
mP6.mFixInfoMask = strtol(mField[eFixInfoMask].c_str(), NULL, 16); mP6.mFixInfoMask = strtol(mField[eFixInfoMask].c_str(), NULL, 16);
} }
@ -624,7 +586,6 @@ public:
class SystemStatusPQWS1 class SystemStatusPQWS1
{ {
public: public:
timespec mUtcTime;
uint32_t mFixInfoMask; uint32_t mFixInfoMask;
uint32_t mHepeLimit; uint32_t mHepeLimit;
}; };
@ -653,7 +614,6 @@ public:
return; return;
} }
memset(&mS1, 0, sizeof(mS1)); memset(&mS1, 0, sizeof(mS1));
mS1.mUtcTime = setUtcTime(mField[eUtcTime]);
mS1.mFixInfoMask = atoi(mField[eFixInfoMask].c_str()); mS1.mFixInfoMask = atoi(mField[eFixInfoMask].c_str());
mS1.mHepeLimit = atoi(mField[eHepeLimit].c_str()); mS1.mHepeLimit = atoi(mField[eHepeLimit].c_str());
} }
@ -665,7 +625,6 @@ public:
SystemStatusTimeAndClock SystemStatusTimeAndClock
******************************************************************************/ ******************************************************************************/
SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea) : SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mGpsWeek(nmea.mGpsWeek), mGpsWeek(nmea.mGpsWeek),
mGpsTowMs(nmea.mGpsTowMs), mGpsTowMs(nmea.mGpsTowMs),
mTimeValid(nmea.mTimeValid), mTimeValid(nmea.mTimeValid),
@ -708,7 +667,6 @@ void SystemStatusTimeAndClock::dump()
SystemStatusXoState SystemStatusXoState
******************************************************************************/ ******************************************************************************/
SystemStatusXoState::SystemStatusXoState(const SystemStatusPQWM1& nmea) : SystemStatusXoState::SystemStatusXoState(const SystemStatusPQWM1& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mXoState(nmea.mXoState) mXoState(nmea.mXoState)
{ {
} }
@ -733,7 +691,6 @@ void SystemStatusXoState::dump()
SystemStatusRfAndParams SystemStatusRfAndParams
******************************************************************************/ ******************************************************************************/
SystemStatusRfAndParams::SystemStatusRfAndParams(const SystemStatusPQWM1& nmea) : SystemStatusRfAndParams::SystemStatusRfAndParams(const SystemStatusPQWM1& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mPgaGain(nmea.mPgaGain), mPgaGain(nmea.mPgaGain),
mGpsBpAmpI(nmea.mGpsBpAmpI), mGpsBpAmpI(nmea.mGpsBpAmpI),
mGpsBpAmpQ(nmea.mGpsBpAmpQ), mGpsBpAmpQ(nmea.mGpsBpAmpQ),
@ -796,7 +753,6 @@ void SystemStatusRfAndParams::dump()
SystemStatusErrRecovery SystemStatusErrRecovery
******************************************************************************/ ******************************************************************************/
SystemStatusErrRecovery::SystemStatusErrRecovery(const SystemStatusPQWM1& nmea) : SystemStatusErrRecovery::SystemStatusErrRecovery(const SystemStatusPQWM1& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mRecErrorRecovery(nmea.mRecErrorRecovery) mRecErrorRecovery(nmea.mRecErrorRecovery)
{ {
} }
@ -821,7 +777,6 @@ void SystemStatusErrRecovery::dump()
SystemStatusInjectedPosition SystemStatusInjectedPosition
******************************************************************************/ ******************************************************************************/
SystemStatusInjectedPosition::SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea) : SystemStatusInjectedPosition::SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mEpiValidity(nmea.mEpiValidity), mEpiValidity(nmea.mEpiValidity),
mEpiLat(nmea.mEpiLat), mEpiLat(nmea.mEpiLat),
mEpiLon(nmea.mEpiLon), mEpiLon(nmea.mEpiLon),
@ -864,7 +819,6 @@ void SystemStatusInjectedPosition::dump()
SystemStatusBestPosition SystemStatusBestPosition
******************************************************************************/ ******************************************************************************/
SystemStatusBestPosition::SystemStatusBestPosition(const SystemStatusPQWP2& nmea) : SystemStatusBestPosition::SystemStatusBestPosition(const SystemStatusPQWP2& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mBestLat(nmea.mBestLat), mBestLat(nmea.mBestLat),
mBestLon(nmea.mBestLon), mBestLon(nmea.mBestLon),
mBestAlt(nmea.mBestAlt), mBestAlt(nmea.mBestAlt),
@ -901,7 +855,6 @@ void SystemStatusBestPosition::dump()
SystemStatusXtra SystemStatusXtra
******************************************************************************/ ******************************************************************************/
SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) : SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mXtraValidMask(nmea.mXtraValidMask), mXtraValidMask(nmea.mXtraValidMask),
mGpsXtraAge(nmea.mGpsXtraAge), mGpsXtraAge(nmea.mGpsXtraAge),
mGloXtraAge(nmea.mGloXtraAge), mGloXtraAge(nmea.mGloXtraAge),
@ -956,7 +909,6 @@ void SystemStatusXtra::dump()
SystemStatusEphemeris SystemStatusEphemeris
******************************************************************************/ ******************************************************************************/
SystemStatusEphemeris::SystemStatusEphemeris(const SystemStatusPQWP4& nmea) : SystemStatusEphemeris::SystemStatusEphemeris(const SystemStatusPQWP4& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mGpsEpheValid(nmea.mGpsEpheValid), mGpsEpheValid(nmea.mGpsEpheValid),
mGloEpheValid(nmea.mGloEpheValid), mGloEpheValid(nmea.mGloEpheValid),
mBdsEpheValid(nmea.mBdsEpheValid), mBdsEpheValid(nmea.mBdsEpheValid),
@ -993,7 +945,6 @@ void SystemStatusEphemeris::dump()
SystemStatusSvHealth SystemStatusSvHealth
******************************************************************************/ ******************************************************************************/
SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) : SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mGpsUnknownMask(nmea.mGpsUnknownMask), mGpsUnknownMask(nmea.mGpsUnknownMask),
mGloUnknownMask(nmea.mGloUnknownMask), mGloUnknownMask(nmea.mGloUnknownMask),
mBdsUnknownMask(nmea.mBdsUnknownMask), mBdsUnknownMask(nmea.mBdsUnknownMask),
@ -1060,7 +1011,6 @@ void SystemStatusSvHealth::dump()
SystemStatusPdr SystemStatusPdr
******************************************************************************/ ******************************************************************************/
SystemStatusPdr::SystemStatusPdr(const SystemStatusPQWP6& nmea) : SystemStatusPdr::SystemStatusPdr(const SystemStatusPQWP6& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mFixInfoMask(nmea.mFixInfoMask) mFixInfoMask(nmea.mFixInfoMask)
{ {
} }
@ -1085,7 +1035,6 @@ void SystemStatusPdr::dump()
SystemStatusPositionFailure SystemStatusPositionFailure
******************************************************************************/ ******************************************************************************/
SystemStatusPositionFailure::SystemStatusPositionFailure(const SystemStatusPQWS1& nmea) : SystemStatusPositionFailure::SystemStatusPositionFailure(const SystemStatusPQWS1& nmea) :
SystemStatusItemBase(nmea.mUtcTime),
mFixInfoMask(nmea.mFixInfoMask), mFixInfoMask(nmea.mFixInfoMask),
mHepeLimit(nmea.mHepeLimit) mHepeLimit(nmea.mHepeLimit)
{ {
@ -1161,7 +1110,9 @@ SystemStatus::SystemStatus()
bool SystemStatus::setTimeAndCLock(const SystemStatusPQWM1& nmea) bool SystemStatus::setTimeAndCLock(const SystemStatusPQWM1& nmea)
{ {
SystemStatusTimeAndClock s(nmea); SystemStatusTimeAndClock s(nmea);
if (mCache.mTimeAndClock.empty() || !mCache.mTimeAndClock.back().equals(s)) { if (!mCache.mTimeAndClock.empty() && mCache.mTimeAndClock.back().equals(s)) {
mCache.mTimeAndClock.back().mUtcReported = s.mUtcReported;
} else {
mCache.mTimeAndClock.push_back(s); mCache.mTimeAndClock.push_back(s);
if (mCache.mTimeAndClock.size() > maxTimeAndClock) { if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin()); mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
@ -1173,7 +1124,9 @@ bool SystemStatus::setTimeAndCLock(const SystemStatusPQWM1& nmea)
bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea) bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea)
{ {
SystemStatusXoState s(nmea); SystemStatusXoState s(nmea);
if (mCache.mXoState.empty() || !mCache.mXoState.back().equals(s)) { if (!mCache.mXoState.empty() && mCache.mXoState.back().equals(s)) {
mCache.mXoState.back().mUtcReported = s.mUtcReported;
} else {
mCache.mXoState.push_back(s); mCache.mXoState.push_back(s);
if (mCache.mXoState.size() > maxXoState) { if (mCache.mXoState.size() > maxXoState) {
mCache.mXoState.erase(mCache.mXoState.begin()); mCache.mXoState.erase(mCache.mXoState.begin());
@ -1185,7 +1138,9 @@ bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea)
bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea) bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea)
{ {
SystemStatusRfAndParams s(nmea); SystemStatusRfAndParams s(nmea);
if (mCache.mRfAndParams.empty() || !mCache.mRfAndParams.back().equals(s)) { if (!mCache.mRfAndParams.empty() && mCache.mRfAndParams.back().equals(s)) {
mCache.mRfAndParams.back().mUtcReported = s.mUtcReported;
} else {
mCache.mRfAndParams.push_back(s); mCache.mRfAndParams.push_back(s);
if (mCache.mRfAndParams.size() > maxRfAndParams) { if (mCache.mRfAndParams.size() > maxRfAndParams) {
mCache.mRfAndParams.erase(mCache.mRfAndParams.begin()); mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
@ -1197,7 +1152,9 @@ bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea)
bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea) bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea)
{ {
SystemStatusErrRecovery s(nmea); SystemStatusErrRecovery s(nmea);
if (mCache.mErrRecovery.empty() || !mCache.mErrRecovery.back().equals(s)) { if (!mCache.mErrRecovery.empty() && mCache.mErrRecovery.back().equals(s)) {
mCache.mErrRecovery.back().mUtcReported = s.mUtcReported;
} else {
mCache.mErrRecovery.push_back(s); mCache.mErrRecovery.push_back(s);
if (mCache.mErrRecovery.size() > maxErrRecovery) { if (mCache.mErrRecovery.size() > maxErrRecovery) {
mCache.mErrRecovery.erase(mCache.mErrRecovery.begin()); mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
@ -1212,7 +1169,9 @@ bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea)
bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea) bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea)
{ {
SystemStatusInjectedPosition s(nmea); SystemStatusInjectedPosition s(nmea);
if (mCache.mInjectedPosition.empty() || !mCache.mInjectedPosition.back().equals(s)) { if (!mCache.mInjectedPosition.empty() && mCache.mInjectedPosition.back().equals(s)) {
mCache.mInjectedPosition.back().mUtcReported = s.mUtcReported;
} else {
mCache.mInjectedPosition.push_back(s); mCache.mInjectedPosition.push_back(s);
if (mCache.mInjectedPosition.size() > maxInjectedPosition) { if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin()); mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
@ -1224,7 +1183,9 @@ bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea)
bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea) bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea)
{ {
SystemStatusBestPosition s(nmea); SystemStatusBestPosition s(nmea);
if (mCache.mBestPosition.empty() || !mCache.mBestPosition.back().equals(s)) { if (!mCache.mBestPosition.empty() && mCache.mBestPosition.back().equals(s)) {
mCache.mBestPosition.back().mUtcReported = s.mUtcReported;
} else {
mCache.mBestPosition.push_back(s); mCache.mBestPosition.push_back(s);
if (mCache.mBestPosition.size() > maxBestPosition) { if (mCache.mBestPosition.size() > maxBestPosition) {
mCache.mBestPosition.erase(mCache.mBestPosition.begin()); mCache.mBestPosition.erase(mCache.mBestPosition.begin());
@ -1236,7 +1197,9 @@ bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea)
bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea) bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea)
{ {
SystemStatusXtra s(nmea); SystemStatusXtra s(nmea);
if (mCache.mXtra.empty() || !mCache.mXtra.back().equals(s)) { if (!mCache.mXtra.empty() && mCache.mXtra.back().equals(s)) {
mCache.mXtra.back().mUtcReported = s.mUtcReported;
} else {
mCache.mXtra.push_back(s); mCache.mXtra.push_back(s);
if (mCache.mXtra.size() > maxXtra) { if (mCache.mXtra.size() > maxXtra) {
mCache.mXtra.erase(mCache.mXtra.begin()); mCache.mXtra.erase(mCache.mXtra.begin());
@ -1248,7 +1211,9 @@ bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea)
bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea) bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea)
{ {
SystemStatusEphemeris s(nmea); SystemStatusEphemeris s(nmea);
if (mCache.mEphemeris.empty() || !mCache.mEphemeris.back().equals(s)) { if (!mCache.mEphemeris.empty() && mCache.mEphemeris.back().equals(s)) {
mCache.mEphemeris.back().mUtcReported = s.mUtcReported;
} else {
mCache.mEphemeris.push_back(s); mCache.mEphemeris.push_back(s);
if (mCache.mEphemeris.size() > maxEphemeris) { if (mCache.mEphemeris.size() > maxEphemeris) {
mCache.mEphemeris.erase(mCache.mEphemeris.begin()); mCache.mEphemeris.erase(mCache.mEphemeris.begin());
@ -1260,7 +1225,9 @@ bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea)
bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea) bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea)
{ {
SystemStatusSvHealth s(nmea); SystemStatusSvHealth s(nmea);
if (mCache.mSvHealth.empty() || !mCache.mSvHealth.back().equals(s)) { if (!mCache.mSvHealth.empty() && mCache.mSvHealth.back().equals(s)) {
mCache.mSvHealth.back().mUtcReported = s.mUtcReported;
} else {
mCache.mSvHealth.push_back(s); mCache.mSvHealth.push_back(s);
if (mCache.mSvHealth.size() > maxSvHealth) { if (mCache.mSvHealth.size() > maxSvHealth) {
mCache.mSvHealth.erase(mCache.mSvHealth.begin()); mCache.mSvHealth.erase(mCache.mSvHealth.begin());
@ -1272,7 +1239,9 @@ bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea)
bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea) bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea)
{ {
SystemStatusPdr s(nmea); SystemStatusPdr s(nmea);
if (mCache.mPdr.empty() || !mCache.mPdr.back().equals(s)) { if (!mCache.mPdr.empty() && mCache.mPdr.back().equals(s)) {
mCache.mPdr.back().mUtcReported = s.mUtcReported;
} else {
mCache.mPdr.push_back(s); mCache.mPdr.push_back(s);
if (mCache.mPdr.size() > maxPdr) { if (mCache.mPdr.size() > maxPdr) {
mCache.mPdr.erase(mCache.mPdr.begin()); mCache.mPdr.erase(mCache.mPdr.begin());
@ -1287,7 +1256,9 @@ bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea)
bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea) bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea)
{ {
SystemStatusPositionFailure s(nmea); SystemStatusPositionFailure s(nmea);
if (mCache.mPositionFailure.empty() || !mCache.mPositionFailure.back().equals(s)) { if (!mCache.mPositionFailure.empty() && mCache.mPositionFailure.back().equals(s)) {
mCache.mPositionFailure.back().mUtcReported = s.mUtcReported;
} else {
mCache.mPositionFailure.push_back(s); mCache.mPositionFailure.push_back(s);
if (mCache.mPositionFailure.size() > maxPositionFailure) { if (mCache.mPositionFailure.size() > maxPositionFailure) {
mCache.mPositionFailure.erase(mCache.mPositionFailure.begin()); mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
@ -1322,8 +1293,7 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
} }
char buf[SystemStatusNmeaBase::NMEA_MAXSIZE + 1] = { 0 }; char buf[SystemStatusNmeaBase::NMEA_MAXSIZE + 1] = { 0 };
strncpy(buf, data, len); strlcpy(buf, data, sizeof(buf));
LOC_LOGI("setNmeaString-0321a: nmea=%s", buf);
pthread_mutex_lock(&mMutexSystemStatus); pthread_mutex_lock(&mMutexSystemStatus);
@ -1393,10 +1363,7 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
bool SystemStatus::eventPosition(const UlpLocation& location, bool SystemStatus::eventPosition(const UlpLocation& location,
const GpsLocationExtended& locationEx) const GpsLocationExtended& locationEx)
{ {
timespec ts; SystemStatusLocation s(location, locationEx);
ts.tv_sec = location.gpsLocation.timestamp / 1000ULL;
ts.tv_nsec = (location.gpsLocation.timestamp % 1000ULL) * 1000000ULL;
SystemStatusLocation s(location, locationEx, ts);
if ((mCache.mLocation.empty()) || !mCache.mLocation.back().equals(s)) { if ((mCache.mLocation.empty()) || !mCache.mLocation.back().equals(s)) {
mCache.mLocation.push_back(s); mCache.mLocation.push_back(s);
if (mCache.mLocation.size() > maxLocation) { if (mCache.mLocation.size() > maxLocation) {

16
core/SystemStatus.h
View file

@ -49,8 +49,16 @@ namespace loc_core
class SystemStatusItemBase class SystemStatusItemBase
{ {
public: public:
timespec mUtcTime; timespec mUtcTime; // UTC timestamp when this info was last updated
SystemStatusItemBase(timespec utctime) : mUtcTime(utctime) { }; timespec mUtcReported; // UTC timestamp when this info was reported
SystemStatusItemBase() {
timeval tv;
gettimeofday(&tv, NULL);
mUtcTime.tv_sec = tv.tv_sec;
mUtcTime.tv_nsec = tv.tv_usec *1000ULL;
mUtcReported = mUtcTime;
};
virtual ~SystemStatusItemBase() { }; virtual ~SystemStatusItemBase() { };
virtual void dump(void) { }; virtual void dump(void) { };
}; };
@ -61,9 +69,7 @@ public:
UlpLocation mLocation; UlpLocation mLocation;
GpsLocationExtended mLocationEx; GpsLocationExtended mLocationEx;
SystemStatusLocation(const UlpLocation& location, SystemStatusLocation(const UlpLocation& location,
const GpsLocationExtended& locationEx, const GpsLocationExtended& locationEx) :
const timespec& ts) :
SystemStatusItemBase(ts),
mLocation(location), mLocation(location),
mLocationEx(locationEx){ }; mLocationEx(locationEx){ };
bool equals(SystemStatusLocation& peer); bool equals(SystemStatusLocation& peer);