psmattas/device_motorola_sanders
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sanders: gps: update to LA.UM.7.6.r1-02000-89xx.0 tag

Browse Source
This commit is contained in:
therootlord
2018-09-12 13:45:48 -03:00
parent 8a6b5c05e7
commit 0a41b9dc1a
150 changed files with 4794 additions and 4130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

731
gps/core/SystemStatus.cpp
View File

@@ -34,12 +34,13 @@
#include <string.h>
#include <sys/time.h>
#include <pthread.h>
#include <platform_lib_log_util.h>
#include <MsgTask.h>
#include <loc_pla.h>
#include <log_util.h>
#include <loc_nmea.h>
#include <DataItemsFactoryProxy.h>
#include <SystemStatus.h>
#include <SystemStatusOsObserver.h>
#include <DataItemConcreteTypesBase.h>
namespace loc_core
{
@@ -119,6 +120,12 @@ public:
double mAgcGal; // x16
int32_t mLeapSeconds;// x17
int32_t mLeapSecUnc; // x18
uint32_t mGloBpAmpI; // x19
uint32_t mGloBpAmpQ; // x1A
uint32_t mBdsBpAmpI; // x1B
uint32_t mBdsBpAmpQ; // x1C
uint32_t mGalBpAmpI; // x1D
uint32_t mGalBpAmpQ; // x1E
};
// parser
@@ -150,8 +157,15 @@ private:
eAgcGlo = 20,
eAgcBds = 21,
eAgcGal = 22,
eMax0 = eAgcGal,
eLeapSeconds = 23,
eLeapSecUnc = 24,
eGloBpAmpI = 25,
eGloBpAmpQ = 26,
eBdsBpAmpI = 27,
eBdsBpAmpQ = 28,
eGalBpAmpI = 29,
eGalBpAmpQ = 30,
eMax
};
SystemStatusPQWM1 mM1;
@@ -181,12 +195,18 @@ public:
inline uint32_t getRecErrorRecovery() { return mM1.mRecErrorRecovery; }
inline int32_t getLeapSeconds(){ return mM1.mLeapSeconds; }
inline int32_t getLeapSecUnc() { return mM1.mLeapSecUnc; }
inline uint32_t getGloBpAmpI() { return mM1.mGloBpAmpI; }
inline uint32_t getGloBpAmpQ() { return mM1.mGloBpAmpQ; }
inline uint32_t getBdsBpAmpI() { return mM1.mBdsBpAmpI; }
inline uint32_t getBdsBpAmpQ() { return mM1.mBdsBpAmpQ; }
inline uint32_t getGalBpAmpI() { return mM1.mGalBpAmpI; }
inline uint32_t getGalBpAmpQ() { return mM1.mGalBpAmpQ; }
SystemStatusPQWM1parser(const char *str_in, uint32_t len_in)
: SystemStatusNmeaBase(str_in, len_in)
{
memset(&mM1, 0, sizeof(mM1));
if (mField.size() < eMax) {
if (mField.size() <= eMax0) {
LOC_LOGE("PQWM1parser - invalid size=%zu", mField.size());
mM1.mTimeValid = 0;
return;
@@ -213,8 +233,18 @@ public:
mM1.mAgcGlo = atof(mField[eAgcGlo].c_str());
mM1.mAgcBds = atof(mField[eAgcBds].c_str());
mM1.mAgcGal = atof(mField[eAgcGal].c_str());
mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str());
mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str());
if (mField.size() > eLeapSecUnc) {
mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str());
mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str());
}
if (mField.size() > eGalBpAmpQ) {
mM1.mGloBpAmpI = atoi(mField[eGloBpAmpI].c_str());
mM1.mGloBpAmpQ = atoi(mField[eGloBpAmpQ].c_str());
mM1.mBdsBpAmpI = atoi(mField[eBdsBpAmpI].c_str());
mM1.mBdsBpAmpQ = atoi(mField[eBdsBpAmpQ].c_str());
mM1.mGalBpAmpI = atoi(mField[eGalBpAmpI].c_str());
mM1.mGalBpAmpQ = atoi(mField[eGalBpAmpQ].c_str());
}
}
inline SystemStatusPQWM1& get() { return mM1;} //getparser
@@ -689,7 +719,7 @@ SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea
{
}
bool SystemStatusTimeAndClock::equals(SystemStatusTimeAndClock& peer)
bool SystemStatusTimeAndClock::equals(const SystemStatusTimeAndClock& peer)
{
if ((mGpsWeek != peer.mGpsWeek) ||
(mGpsTowMs != peer.mGpsTowMs) ||
@@ -729,7 +759,7 @@ SystemStatusXoState::SystemStatusXoState(const SystemStatusPQWM1& nmea) :
{
}
bool SystemStatusXoState::equals(SystemStatusXoState& peer)
bool SystemStatusXoState::equals(const SystemStatusXoState& peer)
{
if (mXoState != peer.mXoState) {
return false;
@@ -761,11 +791,17 @@ SystemStatusRfAndParams::SystemStatusRfAndParams(const SystemStatusPQWM1& nmea)
mAgcGps(nmea.mAgcGps),
mAgcGlo(nmea.mAgcGlo),
mAgcBds(nmea.mAgcBds),
mAgcGal(nmea.mAgcGal)
mAgcGal(nmea.mAgcGal),
mGloBpAmpI(nmea.mGloBpAmpI),
mGloBpAmpQ(nmea.mGloBpAmpQ),
mBdsBpAmpI(nmea.mBdsBpAmpI),
mBdsBpAmpQ(nmea.mBdsBpAmpQ),
mGalBpAmpI(nmea.mGalBpAmpI),
mGalBpAmpQ(nmea.mGalBpAmpQ)
{
}
bool SystemStatusRfAndParams::equals(SystemStatusRfAndParams& peer)
bool SystemStatusRfAndParams::equals(const SystemStatusRfAndParams& peer)
{
if ((mPgaGain != peer.mPgaGain) ||
(mGpsBpAmpI != peer.mGpsBpAmpI) ||
@@ -779,7 +815,13 @@ bool SystemStatusRfAndParams::equals(SystemStatusRfAndParams& peer)
(mAgcGps != peer.mAgcGps) ||
(mAgcGlo != peer.mAgcGlo) ||
(mAgcBds != peer.mAgcBds) ||
(mAgcGal != peer.mAgcGal)) {
(mAgcGal != peer.mAgcGal) ||
(mGloBpAmpI != peer.mGloBpAmpI) ||
(mGloBpAmpQ != peer.mGloBpAmpQ) ||
(mBdsBpAmpI != peer.mBdsBpAmpI) ||
(mBdsBpAmpQ != peer.mBdsBpAmpQ) ||
(mGalBpAmpI != peer.mGalBpAmpI) ||
(mGalBpAmpQ != peer.mGalBpAmpQ)) {
return false;
}
return true;
@@ -815,7 +857,7 @@ SystemStatusErrRecovery::SystemStatusErrRecovery(const SystemStatusPQWM1& nmea)
{
}
bool SystemStatusErrRecovery::equals(SystemStatusErrRecovery& peer)
bool SystemStatusErrRecovery::equals(const SystemStatusErrRecovery& peer)
{
if (mRecErrorRecovery != peer.mRecErrorRecovery) {
return false;
@@ -845,7 +887,7 @@ SystemStatusInjectedPosition::SystemStatusInjectedPosition(const SystemStatusPQW
{
}
bool SystemStatusInjectedPosition::equals(SystemStatusInjectedPosition& peer)
bool SystemStatusInjectedPosition::equals(const SystemStatusInjectedPosition& peer)
{
if ((mEpiValidity != peer.mEpiValidity) ||
(mEpiLat != peer.mEpiLat) ||
@@ -886,7 +928,7 @@ SystemStatusBestPosition::SystemStatusBestPosition(const SystemStatusPQWP2& nmea
{
}
bool SystemStatusBestPosition::equals(SystemStatusBestPosition& peer)
bool SystemStatusBestPosition::equals(const SystemStatusBestPosition& peer)
{
if ((mBestLat != peer.mBestLat) ||
(mBestLon != peer.mBestLon) ||
@@ -928,7 +970,7 @@ SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) :
{
}
bool SystemStatusXtra::equals(SystemStatusXtra& peer)
bool SystemStatusXtra::equals(const SystemStatusXtra& peer)
{
if ((mXtraValidMask != peer.mXtraValidMask) ||
(mGpsXtraAge != peer.mGpsXtraAge) ||
@@ -976,7 +1018,7 @@ SystemStatusEphemeris::SystemStatusEphemeris(const SystemStatusPQWP4& nmea) :
{
}
bool SystemStatusEphemeris::equals(SystemStatusEphemeris& peer)
bool SystemStatusEphemeris::equals(const SystemStatusEphemeris& peer)
{
if ((mGpsEpheValid != peer.mGpsEpheValid) ||
(mGloEpheValid != peer.mGloEpheValid) ||
@@ -1022,7 +1064,7 @@ SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) :
{
}
bool SystemStatusSvHealth::equals(SystemStatusSvHealth& peer)
bool SystemStatusSvHealth::equals(const SystemStatusSvHealth& peer)
{
if ((mGpsUnknownMask != peer.mGpsUnknownMask) ||
(mGloUnknownMask != peer.mGloUnknownMask) ||
@@ -1077,7 +1119,7 @@ SystemStatusPdr::SystemStatusPdr(const SystemStatusPQWP6& nmea) :
{
}
bool SystemStatusPdr::equals(SystemStatusPdr& peer)
bool SystemStatusPdr::equals(const SystemStatusPdr& peer)
{
if (mFixInfoMask != peer.mFixInfoMask) {
return false;
@@ -1103,7 +1145,7 @@ SystemStatusNavData::SystemStatusNavData(const SystemStatusPQWP7& nmea)
}
}
bool SystemStatusNavData::equals(SystemStatusNavData& peer)
bool SystemStatusNavData::equals(const SystemStatusNavData& peer)
{
for (uint32_t i=0; i<SV_ALL_NUM; i++) {
if ((mNav[i].mType != peer.mNav[i].mType) ||
@@ -1135,7 +1177,7 @@ SystemStatusPositionFailure::SystemStatusPositionFailure(const SystemStatusPQWS1
{
}
bool SystemStatusPositionFailure::equals(SystemStatusPositionFailure& peer)
bool SystemStatusPositionFailure::equals(const SystemStatusPositionFailure& peer)
{
if ((mFixInfoMask != peer.mFixInfoMask) ||
(mHepeLimit != peer.mHepeLimit)) {
@@ -1156,7 +1198,7 @@ void SystemStatusPositionFailure::dump()
/******************************************************************************
SystemStatusLocation
******************************************************************************/
bool SystemStatusLocation::equals(SystemStatusLocation& peer)
bool SystemStatusLocation::equals(const SystemStatusLocation& peer)
{
if ((mLocation.gpsLocation.latitude != peer.mLocation.gpsLocation.latitude) ||
(mLocation.gpsLocation.longitude != peer.mLocation.gpsLocation.longitude) ||
@@ -1213,8 +1255,7 @@ IOsObserver* SystemStatus::getOsObserver()
}
SystemStatus::SystemStatus(const MsgTask* msgTask) :
mSysStatusObsvr(msgTask),
mConnected(false)
mSysStatusObsvr(this, msgTask)
{
int result = 0;
ENTRY_LOG ();
@@ -1235,230 +1276,81 @@ SystemStatus::SystemStatus(const MsgTask* msgTask) :
mCache.mPositionFailure.clear();
mCache.mAirplaneMode.clear();
mCache.mENH.clear();
mCache.mGPSState.clear();
mCache.mNLPStatus.clear();
mCache.mWifiHardwareState.clear();
mCache.mNetworkInfo.clear();
mCache.mRilServiceInfo.clear();
mCache.mRilCellInfo.clear();
mCache.mServiceStatus.clear();
mCache.mModel.clear();
mCache.mManufacturer.clear();
mCache.mAssistedGps.clear();
mCache.mScreenState.clear();
mCache.mPowerConnectState.clear();
mCache.mTimeZoneChange.clear();
mCache.mTimeChange.clear();
mCache.mWifiSupplicantStatus.clear();
mCache.mShutdownState.clear();
mCache.mTac.clear();
mCache.mMccMnc.clear();
mCache.mBtDeviceScanDetail.clear();
mCache.mBtLeDeviceScanDetail.clear();
EXIT_LOG_WITH_ERROR ("%d",result);
}
/******************************************************************************
SystemStatus - M1 functions
******************************************************************************/
bool SystemStatus::setTimeAndCLock(const SystemStatusPQWM1& nmea)
{
SystemStatusTimeAndClock s(nmea);
if (!mCache.mTimeAndClock.empty() && mCache.mTimeAndClock.back().equals(s)) {
mCache.mTimeAndClock.back().mUtcReported = s.mUtcReported;
} else {
mCache.mTimeAndClock.push_back(s);
if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
}
}
return true;
}
bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea)
{
SystemStatusXoState s(nmea);
if (!mCache.mXoState.empty() && mCache.mXoState.back().equals(s)) {
mCache.mXoState.back().mUtcReported = s.mUtcReported;
} else {
mCache.mXoState.push_back(s);
if (mCache.mXoState.size() > maxXoState) {
mCache.mXoState.erase(mCache.mXoState.begin());
}
}
return true;
}
bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea)
{
SystemStatusRfAndParams s(nmea);
if (!mCache.mRfAndParams.empty() && mCache.mRfAndParams.back().equals(s)) {
mCache.mRfAndParams.back().mUtcReported = s.mUtcReported;
} else {
mCache.mRfAndParams.push_back(s);
if (mCache.mRfAndParams.size() > maxRfAndParams) {
mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
}
}
return true;
}
bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea)
{
SystemStatusErrRecovery s(nmea);
if (!mCache.mErrRecovery.empty() && mCache.mErrRecovery.back().equals(s)) {
mCache.mErrRecovery.back().mUtcReported = s.mUtcReported;
} else {
mCache.mErrRecovery.push_back(s);
if (mCache.mErrRecovery.size() > maxErrRecovery) {
mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
}
}
return true;
}
/******************************************************************************
SystemStatus - Px functions
******************************************************************************/
bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea)
{
SystemStatusInjectedPosition s(nmea);
if (!mCache.mInjectedPosition.empty() && mCache.mInjectedPosition.back().equals(s)) {
mCache.mInjectedPosition.back().mUtcReported = s.mUtcReported;
} else {
mCache.mInjectedPosition.push_back(s);
if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
}
}
return true;
}
bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea)
{
SystemStatusBestPosition s(nmea);
if (!mCache.mBestPosition.empty() && mCache.mBestPosition.back().equals(s)) {
mCache.mBestPosition.back().mUtcReported = s.mUtcReported;
} else {
mCache.mBestPosition.push_back(s);
if (mCache.mBestPosition.size() > maxBestPosition) {
mCache.mBestPosition.erase(mCache.mBestPosition.begin());
}
}
return true;
}
bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea)
{
SystemStatusXtra s(nmea);
if (!mCache.mXtra.empty() && mCache.mXtra.back().equals(s)) {
mCache.mXtra.back().mUtcReported = s.mUtcReported;
} else {
mCache.mXtra.push_back(s);
if (mCache.mXtra.size() > maxXtra) {
mCache.mXtra.erase(mCache.mXtra.begin());
}
}
return true;
}
bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea)
{
SystemStatusEphemeris s(nmea);
if (!mCache.mEphemeris.empty() && mCache.mEphemeris.back().equals(s)) {
mCache.mEphemeris.back().mUtcReported = s.mUtcReported;
} else {
mCache.mEphemeris.push_back(s);
if (mCache.mEphemeris.size() > maxEphemeris) {
mCache.mEphemeris.erase(mCache.mEphemeris.begin());
}
}
return true;
}
bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea)
{
SystemStatusSvHealth s(nmea);
if (!mCache.mSvHealth.empty() && mCache.mSvHealth.back().equals(s)) {
mCache.mSvHealth.back().mUtcReported = s.mUtcReported;
} else {
mCache.mSvHealth.push_back(s);
if (mCache.mSvHealth.size() > maxSvHealth) {
mCache.mSvHealth.erase(mCache.mSvHealth.begin());
}
}
return true;
}
bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea)
{
SystemStatusPdr s(nmea);
if (!mCache.mPdr.empty() && mCache.mPdr.back().equals(s)) {
mCache.mPdr.back().mUtcReported = s.mUtcReported;
} else {
mCache.mPdr.push_back(s);
if (mCache.mPdr.size() > maxPdr) {
mCache.mPdr.erase(mCache.mPdr.begin());
}
}
return true;
}
bool SystemStatus::setNavData(const SystemStatusPQWP7& nmea)
{
SystemStatusNavData s(nmea);
if (!mCache.mNavData.empty() && mCache.mNavData.back().equals(s)) {
mCache.mNavData.back().mUtcReported = s.mUtcReported;
} else {
mCache.mNavData.push_back(s);
if (mCache.mNavData.size() > maxNavData) {
mCache.mNavData.erase(mCache.mNavData.begin());
}
}
return true;
}
/******************************************************************************
SystemStatus - Sx functions
******************************************************************************/
bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea)
{
SystemStatusPositionFailure s(nmea);
if (!mCache.mPositionFailure.empty() && mCache.mPositionFailure.back().equals(s)) {
mCache.mPositionFailure.back().mUtcReported = s.mUtcReported;
} else {
mCache.mPositionFailure.push_back(s);
if (mCache.mPositionFailure.size() > maxPositionFailure) {
mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
}
}
return true;
}
/******************************************************************************
SystemStatus - storing dataitems
******************************************************************************/
bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem)
template <typename TYPE_REPORT, typename TYPE_ITEM>
bool SystemStatus::setIteminReport(TYPE_REPORT& report, TYPE_ITEM&& s)
{
SystemStatusNetworkInfo* data = reinterpret_cast<SystemStatusNetworkInfo*>(dataitem);
SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName,
data->mAvailable,data->mConnected,data->mRoaming);
s.dump();
mConnected = data->mConnected;
if (!report.empty() && report.back().equals(static_cast<TYPE_ITEM&>(s.collate(report.back())))) {
// there is no change - just update reported timestamp
report.back().mUtcReported = s.mUtcReported;
return false;
}
if (!mCache.mNetworkInfo.empty() && mCache.mNetworkInfo.back().equals(s)) {
mCache.mNetworkInfo.back().mUtcReported = s.mUtcReported;
} else {
mCache.mNetworkInfo.push_back(s);
if (mCache.mNetworkInfo.size() > maxNetworkInfo) {
mCache.mNetworkInfo.erase(mCache.mNetworkInfo.begin());
}
// first event or updated
report.push_back(s);
if (report.size() > s.maxItem) {
report.erase(report.begin());
}
return true;
}
template <typename TYPE_REPORT, typename TYPE_ITEM>
void SystemStatus::setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s)
{
report.push_back(s);
if (report.size() > s.maxItem) {
report.erase(report.begin());
}
}
template <typename TYPE_REPORT, typename TYPE_ITEM>
void SystemStatus::getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const
{
reportout.clear();
if (c.size() >= 1) {
reportout.push_back(c.back());
reportout.back().dump();
}
}
/******************************************************************************
@brief API to set report data into internal buffer
@param[In] data pointer to the NMEA string
@param[In] len length of the NMEA string
@return true when successfully done
@return true when the NMEA is consumed by the method.
******************************************************************************/
static uint32_t cnt = 0;
static uint32_t cnt_m1 = 0;
static uint32_t cnt_p1 = 0;
static uint32_t cnt_p2 = 0;
static uint32_t cnt_p3 = 0;
static uint32_t cnt_p4 = 0;
static uint32_t cnt_p5 = 0;
static uint32_t cnt_p6 = 0;
static uint32_t cnt_p7 = 0;
static uint32_t cnt_s1 = 0;
bool SystemStatus::setNmeaString(const char *data, uint32_t len)
{
bool ret = false;
if (!loc_nmea_is_debug(data, len)) {
return false;
}
@@ -1469,64 +1361,51 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
pthread_mutex_lock(&mMutexSystemStatus);
// parse the received nmea strings here
if (0 == strncmp(data, "$PQWM1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
if (0 == strncmp(data, "$PQWM1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
SystemStatusPQWM1 s = SystemStatusPQWM1parser(buf, len).get();
ret = setTimeAndCLock(s);
ret |= setXoState(s);
ret |= setRfAndParams(s);
ret |= setErrRecovery(s);
cnt_m1++;
setIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock(s));
setIteminReport(mCache.mXoState, SystemStatusXoState(s));
setIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams(s));
setIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery(s));
}
else if (0 == strncmp(data, "$PQWP1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setInjectedPosition(SystemStatusPQWP1parser(buf, len).get());
cnt_p1++;
setIteminReport(mCache.mInjectedPosition,
SystemStatusInjectedPosition(SystemStatusPQWP1parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP2", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setBestPosition(SystemStatusPQWP2parser(buf, len).get());
cnt_p2++;
setIteminReport(mCache.mBestPosition,
SystemStatusBestPosition(SystemStatusPQWP2parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP3", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setXtra(SystemStatusPQWP3parser(buf, len).get());
cnt_p3++;
setIteminReport(mCache.mXtra,
SystemStatusXtra(SystemStatusPQWP3parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP4", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setEphemeris(SystemStatusPQWP4parser(buf, len).get());
cnt_p4++;
setIteminReport(mCache.mEphemeris,
SystemStatusEphemeris(SystemStatusPQWP4parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP5", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setSvHealth(SystemStatusPQWP5parser(buf, len).get());
cnt_p5++;
setIteminReport(mCache.mSvHealth,
SystemStatusSvHealth(SystemStatusPQWP5parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP6", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setPdr(SystemStatusPQWP6parser(buf, len).get());
cnt_p6++;
setIteminReport(mCache.mPdr,
SystemStatusPdr(SystemStatusPQWP6parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP7", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setNavData(SystemStatusPQWP7parser(buf, len).get());
cnt_p7++;
setIteminReport(mCache.mNavData,
SystemStatusNavData(SystemStatusPQWP7parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWS1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
ret = setPositionFailure(SystemStatusPQWS1parser(buf, len).get());
cnt_s1++;
setIteminReport(mCache.mPositionFailure,
SystemStatusPositionFailure(SystemStatusPQWS1parser(buf, len).get()));
}
else {
// do nothing
}
cnt++;
LOC_LOGV("setNmeaString: cnt=%d M:%d 1:%d 2:%d 3:%d 4:%d 5:%d 6:%d 7:%d S:%d",
cnt,
cnt_m1,
cnt_p1,
cnt_p2,
cnt_p3,
cnt_p4,
cnt_p5,
cnt_p6,
cnt_p7,
cnt_s1);
pthread_mutex_unlock(&mMutexSystemStatus);
return ret;
return true;
}
/******************************************************************************
@@ -1539,22 +1418,18 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
bool SystemStatus::eventPosition(const UlpLocation& location,
const GpsLocationExtended& locationEx)
{
SystemStatusLocation s(location, locationEx);
if (!mCache.mLocation.empty() && mCache.mLocation.back().equals(s)) {
mCache.mLocation.back().mUtcReported = s.mUtcReported;
}
else {
mCache.mLocation.push_back(s);
if (mCache.mLocation.size() > maxLocation) {
mCache.mLocation.erase(mCache.mLocation.begin());
}
}
bool ret = false;
pthread_mutex_lock(&mMutexSystemStatus);
ret = setIteminReport(mCache.mLocation, SystemStatusLocation(location, locationEx));
LOC_LOGV("eventPosition - lat=%f lon=%f alt=%f speed=%f",
s.mLocation.gpsLocation.latitude,
s.mLocation.gpsLocation.longitude,
s.mLocation.gpsLocation.altitude,
s.mLocation.gpsLocation.speed);
return true;
location.gpsLocation.latitude,
location.gpsLocation.longitude,
location.gpsLocation.altitude,
location.gpsLocation.speed);
pthread_mutex_unlock(&mMutexSystemStatus);
return ret;
}
/******************************************************************************
@@ -1562,19 +1437,107 @@ bool SystemStatus::eventPosition(const UlpLocation& location,
@param[In] DataItem
@return true when successfully done
@return true when info is updatated
******************************************************************************/
bool SystemStatus::eventDataItemNotify(IDataItemCore* dataitem)
{
bool ret = false;
pthread_mutex_lock(&mMutexSystemStatus);
switch(dataitem->getId())
{
case AIRPLANEMODE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mAirplaneMode,
SystemStatusAirplaneMode(*(static_cast<AirplaneModeDataItemBase*>(dataitem))));
break;
case ENH_DATA_ITEM_ID:
ret = setIteminReport(mCache.mENH,
SystemStatusENH(*(static_cast<ENHDataItemBase*>(dataitem))));
break;
case GPSSTATE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mGPSState,
SystemStatusGpsState(*(static_cast<GPSStateDataItemBase*>(dataitem))));
break;
case NLPSTATUS_DATA_ITEM_ID:
ret = setIteminReport(mCache.mNLPStatus,
SystemStatusNLPStatus(*(static_cast<NLPStatusDataItemBase*>(dataitem))));
break;
case WIFIHARDWARESTATE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mWifiHardwareState,
SystemStatusWifiHardwareState(*(static_cast<WifiHardwareStateDataItemBase*>(dataitem))));
break;
case NETWORKINFO_DATA_ITEM_ID:
setNetworkInfo(dataitem);
ret = setIteminReport(mCache.mNetworkInfo,
SystemStatusNetworkInfo(*(static_cast<NetworkInfoDataItemBase*>(dataitem))));
break;
case RILSERVICEINFO_DATA_ITEM_ID:
ret = setIteminReport(mCache.mRilServiceInfo,
SystemStatusServiceInfo(*(static_cast<RilServiceInfoDataItemBase*>(dataitem))));
break;
case RILCELLINFO_DATA_ITEM_ID:
ret = setIteminReport(mCache.mRilCellInfo,
SystemStatusRilCellInfo(*(static_cast<RilCellInfoDataItemBase*>(dataitem))));
break;
case SERVICESTATUS_DATA_ITEM_ID:
ret = setIteminReport(mCache.mServiceStatus,
SystemStatusServiceStatus(*(static_cast<ServiceStatusDataItemBase*>(dataitem))));
break;
case MODEL_DATA_ITEM_ID:
ret = setIteminReport(mCache.mModel,
SystemStatusModel(*(static_cast<ModelDataItemBase*>(dataitem))));
break;
case MANUFACTURER_DATA_ITEM_ID:
ret = setIteminReport(mCache.mManufacturer,
SystemStatusManufacturer(*(static_cast<ManufacturerDataItemBase*>(dataitem))));
break;
case ASSISTED_GPS_DATA_ITEM_ID:
ret = setIteminReport(mCache.mAssistedGps,
SystemStatusAssistedGps(*(static_cast<AssistedGpsDataItemBase*>(dataitem))));
break;
case SCREEN_STATE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mScreenState,
SystemStatusScreenState(*(static_cast<ScreenStateDataItemBase*>(dataitem))));
break;
case POWER_CONNECTED_STATE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mPowerConnectState,
SystemStatusPowerConnectState(*(static_cast<PowerConnectStateDataItemBase*>(dataitem))));
break;
case TIMEZONE_CHANGE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mTimeZoneChange,
SystemStatusTimeZoneChange(*(static_cast<TimeZoneChangeDataItemBase*>(dataitem))));
break;
case TIME_CHANGE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mTimeChange,
SystemStatusTimeChange(*(static_cast<TimeChangeDataItemBase*>(dataitem))));
break;
case WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID:
ret = setIteminReport(mCache.mWifiSupplicantStatus,
SystemStatusWifiSupplicantStatus(*(static_cast<WifiSupplicantStatusDataItemBase*>(dataitem))));
break;
case SHUTDOWN_STATE_DATA_ITEM_ID:
ret = setIteminReport(mCache.mShutdownState,
SystemStatusShutdownState(*(static_cast<ShutdownStateDataItemBase*>(dataitem))));
break;
case TAC_DATA_ITEM_ID:
ret = setIteminReport(mCache.mTac,
SystemStatusTac(*(static_cast<TacDataItemBase*>(dataitem))));
break;
case MCCMNC_DATA_ITEM_ID:
ret = setIteminReport(mCache.mMccMnc,
SystemStatusMccMnc(*(static_cast<MccmncDataItemBase*>(dataitem))));
break;
case BTLE_SCAN_DATA_ITEM_ID:
ret = setIteminReport(mCache.mBtDeviceScanDetail,
SystemStatusBtDeviceScanDetail(*(static_cast<BtDeviceScanDetailsDataItemBase*>(dataitem))));
break;
case BT_SCAN_DATA_ITEM_ID:
ret = setIteminReport(mCache.mBtLeDeviceScanDetail,
SystemStatusBtleDeviceScanDetail(*(static_cast<BtLeDeviceScanDetailsDataItemBase*>(dataitem))));
break;
default:
break;
}
pthread_mutex_unlock(&mMutexSystemStatus);
return true;
return ret;
}
/******************************************************************************
@@ -1591,74 +1554,45 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
if (isLatestOnly) {
// push back only the latest report and return it
report.mLocation.clear();
if (mCache.mLocation.size() >= 1) {
report.mLocation.push_back(mCache.mLocation.back());
report.mLocation.back().dump();
}
getIteminReport(report.mLocation, mCache.mLocation);
report.mTimeAndClock.clear();
if (mCache.mTimeAndClock.size() >= 1) {
report.mTimeAndClock.push_back(mCache.mTimeAndClock.back());
report.mTimeAndClock.back().dump();
}
report.mXoState.clear();
if (mCache.mXoState.size() >= 1) {
report.mXoState.push_back(mCache.mXoState.back());
report.mXoState.back().dump();
}
report.mRfAndParams.clear();
if (mCache.mRfAndParams.size() >= 1) {
report.mRfAndParams.push_back(mCache.mRfAndParams.back());
report.mRfAndParams.back().dump();
}
report.mErrRecovery.clear();
if (mCache.mErrRecovery.size() >= 1) {
report.mErrRecovery.push_back(mCache.mErrRecovery.back());
report.mErrRecovery.back().dump();
}
getIteminReport(report.mTimeAndClock, mCache.mTimeAndClock);
getIteminReport(report.mXoState, mCache.mXoState);
getIteminReport(report.mRfAndParams, mCache.mRfAndParams);
getIteminReport(report.mErrRecovery, mCache.mErrRecovery);
report.mInjectedPosition.clear();
if (mCache.mInjectedPosition.size() >= 1) {
report.mInjectedPosition.push_back(mCache.mInjectedPosition.back());
report.mInjectedPosition.back().dump();
}
report.mBestPosition.clear();
if (mCache.mBestPosition.size() >= 1) {
report.mBestPosition.push_back(mCache.mBestPosition.back());
report.mBestPosition.back().dump();
}
report.mXtra.clear();
if (mCache.mXtra.size() >= 1) {
report.mXtra.push_back(mCache.mXtra.back());
report.mXtra.back().dump();
}
report.mEphemeris.clear();
if (mCache.mEphemeris.size() >= 1) {
report.mEphemeris.push_back(mCache.mEphemeris.back());
report.mEphemeris.back().dump();
}
report.mSvHealth.clear();
if (mCache.mSvHealth.size() >= 1) {
report.mSvHealth.push_back(mCache.mSvHealth.back());
report.mSvHealth.back().dump();
}
report.mPdr.clear();
if (mCache.mPdr.size() >= 1) {
report.mPdr.push_back(mCache.mPdr.back());
report.mPdr.back().dump();
}
report.mNavData.clear();
if (mCache.mNavData.size() >= 1) {
report.mNavData.push_back(mCache.mNavData.back());
report.mNavData.back().dump();
}
getIteminReport(report.mInjectedPosition, mCache.mInjectedPosition);
getIteminReport(report.mBestPosition, mCache.mBestPosition);
getIteminReport(report.mXtra, mCache.mXtra);
getIteminReport(report.mEphemeris, mCache.mEphemeris);
getIteminReport(report.mSvHealth, mCache.mSvHealth);
getIteminReport(report.mPdr, mCache.mPdr);
getIteminReport(report.mNavData, mCache.mNavData);
report.mPositionFailure.clear();
if (mCache.mPositionFailure.size() >= 1) {
report.mPositionFailure.push_back(mCache.mPositionFailure.back());
report.mPositionFailure.back().dump();
}
getIteminReport(report.mPositionFailure, mCache.mPositionFailure);
getIteminReport(report.mAirplaneMode, mCache.mAirplaneMode);
getIteminReport(report.mENH, mCache.mENH);
getIteminReport(report.mGPSState, mCache.mGPSState);
getIteminReport(report.mNLPStatus, mCache.mNLPStatus);
getIteminReport(report.mWifiHardwareState, mCache.mWifiHardwareState);
getIteminReport(report.mNetworkInfo, mCache.mNetworkInfo);
getIteminReport(report.mRilServiceInfo, mCache.mRilServiceInfo);
getIteminReport(report.mRilCellInfo, mCache.mRilCellInfo);
getIteminReport(report.mServiceStatus, mCache.mServiceStatus);
getIteminReport(report.mModel, mCache.mModel);
getIteminReport(report.mManufacturer, mCache.mManufacturer);
getIteminReport(report.mAssistedGps, mCache.mAssistedGps);
getIteminReport(report.mScreenState, mCache.mScreenState);
getIteminReport(report.mPowerConnectState, mCache.mPowerConnectState);
getIteminReport(report.mTimeZoneChange, mCache.mTimeZoneChange);
getIteminReport(report.mTimeChange, mCache.mTimeChange);
getIteminReport(report.mWifiSupplicantStatus, mCache.mWifiSupplicantStatus);
getIteminReport(report.mShutdownState, mCache.mShutdownState);
getIteminReport(report.mTac, mCache.mTac);
getIteminReport(report.mMccMnc, mCache.mMccMnc);
getIteminReport(report.mBtDeviceScanDetail, mCache.mBtDeviceScanDetail);
getIteminReport(report.mBtLeDeviceScanDetail, mCache.mBtLeDeviceScanDetail);
}
else {
// copy entire reports and return them
@@ -1678,6 +1612,30 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
report.mNavData.clear();
report.mPositionFailure.clear();
report.mAirplaneMode.clear();
report.mENH.clear();
report.mGPSState.clear();
report.mNLPStatus.clear();
report.mWifiHardwareState.clear();
report.mNetworkInfo.clear();
report.mRilServiceInfo.clear();
report.mRilCellInfo.clear();
report.mServiceStatus.clear();
report.mModel.clear();
report.mManufacturer.clear();
report.mAssistedGps.clear();
report.mScreenState.clear();
report.mPowerConnectState.clear();
report.mTimeZoneChange.clear();
report.mTimeChange.clear();
report.mWifiSupplicantStatus.clear();
report.mShutdownState.clear();
report.mTac.clear();
report.mMccMnc.clear();
report.mBtDeviceScanDetail.clear();
report.mBtLeDeviceScanDetail.clear();
report = mCache;
}
@@ -1692,65 +1650,26 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
@return true when successfully done
******************************************************************************/
bool SystemStatus::setDefaultReport(void)
bool SystemStatus::setDefaultGnssEngineStates(void)
{
pthread_mutex_lock(&mMutexSystemStatus);
mCache.mLocation.push_back(SystemStatusLocation());
if (mCache.mLocation.size() > maxLocation) {
mCache.mLocation.erase(mCache.mLocation.begin());
}
setDefaultIteminReport(mCache.mLocation, SystemStatusLocation());
mCache.mTimeAndClock.push_back(SystemStatusTimeAndClock());
if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
}
mCache.mXoState.push_back(SystemStatusXoState());
if (mCache.mXoState.size() > maxXoState) {
mCache.mXoState.erase(mCache.mXoState.begin());
}
mCache.mRfAndParams.push_back(SystemStatusRfAndParams());
if (mCache.mRfAndParams.size() > maxRfAndParams) {
mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
}
mCache.mErrRecovery.push_back(SystemStatusErrRecovery());
if (mCache.mErrRecovery.size() > maxErrRecovery) {
mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
}
setDefaultIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock());
setDefaultIteminReport(mCache.mXoState, SystemStatusXoState());
setDefaultIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams());
setDefaultIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery());
mCache.mInjectedPosition.push_back(SystemStatusInjectedPosition());
if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
}
mCache.mBestPosition.push_back(SystemStatusBestPosition());
if (mCache.mBestPosition.size() > maxBestPosition) {
mCache.mBestPosition.erase(mCache.mBestPosition.begin());
}
mCache.mXtra.push_back(SystemStatusXtra());
if (mCache.mXtra.size() > maxXtra) {
mCache.mXtra.erase(mCache.mXtra.begin());
}
mCache.mEphemeris.push_back(SystemStatusEphemeris());
if (mCache.mEphemeris.size() > maxEphemeris) {
mCache.mEphemeris.erase(mCache.mEphemeris.begin());
}
mCache.mSvHealth.push_back(SystemStatusSvHealth());
if (mCache.mSvHealth.size() > maxSvHealth) {
mCache.mSvHealth.erase(mCache.mSvHealth.begin());
}
mCache.mPdr.push_back(SystemStatusPdr());
if (mCache.mPdr.size() > maxPdr) {
mCache.mPdr.erase(mCache.mPdr.begin());
}
mCache.mNavData.push_back(SystemStatusNavData());
if (mCache.mNavData.size() > maxNavData) {
mCache.mNavData.erase(mCache.mNavData.begin());
}
setDefaultIteminReport(mCache.mInjectedPosition, SystemStatusInjectedPosition());
setDefaultIteminReport(mCache.mBestPosition, SystemStatusBestPosition());
setDefaultIteminReport(mCache.mXtra, SystemStatusXtra());
setDefaultIteminReport(mCache.mEphemeris, SystemStatusEphemeris());
setDefaultIteminReport(mCache.mSvHealth, SystemStatusSvHealth());
setDefaultIteminReport(mCache.mPdr, SystemStatusPdr());
setDefaultIteminReport(mCache.mNavData, SystemStatusNavData());
mCache.mPositionFailure.push_back(SystemStatusPositionFailure());
if (mCache.mPositionFailure.size() > maxPositionFailure) {
mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
}
setDefaultIteminReport(mCache.mPositionFailure, SystemStatusPositionFailure());
pthread_mutex_unlock(&mMutexSystemStatus);
return true;
@@ -1763,24 +1682,12 @@ bool SystemStatus::setDefaultReport(void)
@return true when successfully done
******************************************************************************/
bool SystemStatus::eventConnectionStatus(bool connected, uint8_t type)
bool SystemStatus::eventConnectionStatus(bool connected, int8_t type)
{
if (connected != mConnected) {
mConnected = connected;
// send networkinof dataitem to systemstatus observer clients
SystemStatusNetworkInfo s(type, "", "", connected);
mSysStatusObsvr.notify({&s});
// send networkinof dataitem to systemstatus observer clients
SystemStatusNetworkInfo s(type, "", "", false, connected, false);
IDataItemCore *networkinfo =
DataItemsFactoryProxy::createNewDataItem(NETWORKINFO_DATA_ITEM_ID);
if (nullptr == networkinfo) {
LOC_LOGE("Unable to create dataitemd");
return false;
}
networkinfo->copy(&s);
list<IDataItemCore*> dl(0);
dl.push_back(networkinfo);
mSysStatusObsvr.notify(dl);
}
return true;
}