From f5f0f29c13570eec19ae03f6888bc12759d9dac2 Mon Sep 17 00:00:00 2001 From: Katz Yamada Date: Tue, 26 Sep 2017 15:19:18 -0700 Subject: [PATCH] Add storing dataitem in systemstatus report SystemStatus stores incoming dataitem events received from osagent into its internal systemstatus report cache. Change-Id: I129c633b45abfc04c9d9bbbd558db5f6e93c1672 CRs-Fixed: 2093347 --- android/AGnssRil.cpp | 32 +- core/SystemStatus.cpp | 686 +++++++++----------- core/SystemStatus.h | 455 ++++++++----- core/SystemStatusOsObserver.cpp | 12 +- core/SystemStatusOsObserver.h | 6 +- core/data-items/DataItemConcreteTypesBase.h | 15 + 6 files changed, 638 insertions(+), 568 deletions(-) diff --git a/android/AGnssRil.cpp b/android/AGnssRil.cpp index 54bd8a1c..d790bae9 100644 --- a/android/AGnssRil.cpp +++ b/android/AGnssRil.cpp @@ -29,6 +29,8 @@ #include #include "Gnss.h" #include "AGnssRil.h" +#include + typedef void* (getLocationInterface)(); namespace android { @@ -51,7 +53,35 @@ Return AGnssRil::updateNetworkState(bool connected, NetworkType type, bool // for XTRA if (nullptr != mGnss && ( nullptr != mGnss->getGnssInterface() )) { - mGnss->getGnssInterface()->updateConnectionStatus(connected, (int8_t)type); + int8_t typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN; + switch(type) + { + case IAGnssRil::NetworkType::MOBILE: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_MOBILE; + break; + case IAGnssRil::NetworkType::WIFI: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIFI; + break; + case IAGnssRil::NetworkType::MMS: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_MMS; + break; + case IAGnssRil::NetworkType::SUPL: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_SUPL; + break; + case IAGnssRil::NetworkType::DUN: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_DUN; + break; + case IAGnssRil::NetworkType::HIPRI: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_HIPRI; + break; + case IAGnssRil::NetworkType::WIMAX: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIMAX; + break; + default: + typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN; + break; + } + mGnss->getGnssInterface()->updateConnectionStatus(connected, typeout); } return true; } diff --git a/core/SystemStatus.cpp b/core/SystemStatus.cpp index 275c9deb..8954a719 100644 --- a/core/SystemStatus.cpp +++ b/core/SystemStatus.cpp @@ -714,7 +714,7 @@ SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea { } -bool SystemStatusTimeAndClock::equals(SystemStatusTimeAndClock& peer) +bool SystemStatusTimeAndClock::equals(const SystemStatusTimeAndClock& peer) { if ((mGpsWeek != peer.mGpsWeek) || (mGpsTowMs != peer.mGpsTowMs) || @@ -754,7 +754,7 @@ SystemStatusXoState::SystemStatusXoState(const SystemStatusPQWM1& nmea) : { } -bool SystemStatusXoState::equals(SystemStatusXoState& peer) +bool SystemStatusXoState::equals(const SystemStatusXoState& peer) { if (mXoState != peer.mXoState) { return false; @@ -796,7 +796,7 @@ SystemStatusRfAndParams::SystemStatusRfAndParams(const SystemStatusPQWM1& nmea) { } -bool SystemStatusRfAndParams::equals(SystemStatusRfAndParams& peer) +bool SystemStatusRfAndParams::equals(const SystemStatusRfAndParams& peer) { if ((mPgaGain != peer.mPgaGain) || (mGpsBpAmpI != peer.mGpsBpAmpI) || @@ -852,7 +852,7 @@ SystemStatusErrRecovery::SystemStatusErrRecovery(const SystemStatusPQWM1& nmea) { } -bool SystemStatusErrRecovery::equals(SystemStatusErrRecovery& peer) +bool SystemStatusErrRecovery::equals(const SystemStatusErrRecovery& peer) { if (mRecErrorRecovery != peer.mRecErrorRecovery) { return false; @@ -882,7 +882,7 @@ SystemStatusInjectedPosition::SystemStatusInjectedPosition(const SystemStatusPQW { } -bool SystemStatusInjectedPosition::equals(SystemStatusInjectedPosition& peer) +bool SystemStatusInjectedPosition::equals(const SystemStatusInjectedPosition& peer) { if ((mEpiValidity != peer.mEpiValidity) || (mEpiLat != peer.mEpiLat) || @@ -923,7 +923,7 @@ SystemStatusBestPosition::SystemStatusBestPosition(const SystemStatusPQWP2& nmea { } -bool SystemStatusBestPosition::equals(SystemStatusBestPosition& peer) +bool SystemStatusBestPosition::equals(const SystemStatusBestPosition& peer) { if ((mBestLat != peer.mBestLat) || (mBestLon != peer.mBestLon) || @@ -965,7 +965,7 @@ SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) : { } -bool SystemStatusXtra::equals(SystemStatusXtra& peer) +bool SystemStatusXtra::equals(const SystemStatusXtra& peer) { if ((mXtraValidMask != peer.mXtraValidMask) || (mGpsXtraAge != peer.mGpsXtraAge) || @@ -1013,7 +1013,7 @@ SystemStatusEphemeris::SystemStatusEphemeris(const SystemStatusPQWP4& nmea) : { } -bool SystemStatusEphemeris::equals(SystemStatusEphemeris& peer) +bool SystemStatusEphemeris::equals(const SystemStatusEphemeris& peer) { if ((mGpsEpheValid != peer.mGpsEpheValid) || (mGloEpheValid != peer.mGloEpheValid) || @@ -1059,7 +1059,7 @@ SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) : { } -bool SystemStatusSvHealth::equals(SystemStatusSvHealth& peer) +bool SystemStatusSvHealth::equals(const SystemStatusSvHealth& peer) { if ((mGpsUnknownMask != peer.mGpsUnknownMask) || (mGloUnknownMask != peer.mGloUnknownMask) || @@ -1114,7 +1114,7 @@ SystemStatusPdr::SystemStatusPdr(const SystemStatusPQWP6& nmea) : { } -bool SystemStatusPdr::equals(SystemStatusPdr& peer) +bool SystemStatusPdr::equals(const SystemStatusPdr& peer) { if (mFixInfoMask != peer.mFixInfoMask) { return false; @@ -1140,7 +1140,7 @@ SystemStatusNavData::SystemStatusNavData(const SystemStatusPQWP7& nmea) } } -bool SystemStatusNavData::equals(SystemStatusNavData& peer) +bool SystemStatusNavData::equals(const SystemStatusNavData& peer) { for (uint32_t i=0; i 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) +bool SystemStatus::setNetworkInfo(const SystemStatusNetworkInfo& s) { - NetworkInfoDataItemBase* data = reinterpret_cast(dataitem); - SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName, - data->mAvailable,data->mConnected,data->mRoaming); - s.dump(); - mConnected = data->mConnected; + mConnected = s.mConnected; + SystemStatusNetworkInfo sout = s; + sout.mType = s.getType(); + return setIteminReport(mCache.mNetworkInfo, sout); +} - 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()); - } +template +bool SystemStatus::setIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s) +{ + if (!report.empty() && report.back().equals(s)) { + // there is no change - just update reported timestamp + report.back().mUtcReported = s.mUtcReported; + return false; + } + + // first event or updated + report.push_back(s); + if (report.size() > s.maxItem) { + report.erase(report.begin()); } return true; } +template +void SystemStatus::setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s) +{ + report.push_back(s); + if (report.size() > s.maxItem) { + report.erase(report.begin()); + } +} + +template +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 @@ -1482,17 +1353,6 @@ bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem) @return true when successfully done ******************************************************************************/ -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; @@ -1508,59 +1368,46 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len) // parse the received nmea strings here 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++; + ret |= setIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock(s)); + ret |= setIteminReport(mCache.mXoState, SystemStatusXoState(s)); + ret |= setIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams(s)); + ret |= setIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery(s)); } else if (0 == strncmp(data, "$PQWP1", SystemStatusNmeaBase::NMEA_MINSIZE)) { - ret = setInjectedPosition(SystemStatusPQWP1parser(buf, len).get()); - cnt_p1++; + ret = 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++; + ret = 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++; + ret = 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++; + ret = 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++; + ret = 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++; + ret = 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++; + ret = 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++; + ret = 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; @@ -1576,22 +1423,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; } /****************************************************************************** @@ -1599,19 +1442,108 @@ 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, + *(static_cast(dataitem))); + break; + case ENH_DATA_ITEM_ID: + ret = setIteminReport(mCache.mENH, + *(static_cast(dataitem))); + break; + case GPSSTATE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mGPSState, + *(static_cast(dataitem))); + break; + case NLPSTATUS_DATA_ITEM_ID: + ret = setIteminReport(mCache.mNLPStatus, + *(static_cast(dataitem))); + break; + case WIFIHARDWARESTATE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mWifiHardwareState, + *(static_cast(dataitem))); + break; case NETWORKINFO_DATA_ITEM_ID: - setNetworkInfo(dataitem); + // need special handling for this item to map emums + ret = setNetworkInfo( + *(static_cast(dataitem))); + break; + case RILSERVICEINFO_DATA_ITEM_ID: + ret = setIteminReport(mCache.mRilServiceInfo, + *(static_cast(dataitem))); + break; + case RILCELLINFO_DATA_ITEM_ID: + ret = setIteminReport(mCache.mRilCellInfo, + *(static_cast(dataitem))); + break; + case SERVICESTATUS_DATA_ITEM_ID: + ret = setIteminReport(mCache.mServiceStatus, + *(static_cast(dataitem))); + break; + case MODEL_DATA_ITEM_ID: + ret = setIteminReport(mCache.mModel, + *(static_cast(dataitem))); + break; + case MANUFACTURER_DATA_ITEM_ID: + ret = setIteminReport(mCache.mManufacturer, + *(static_cast(dataitem))); + break; + case ASSISTED_GPS_DATA_ITEM_ID: + ret = setIteminReport(mCache.mAssistedGps, + *(static_cast(dataitem))); + break; + case SCREEN_STATE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mScreenState, + *(static_cast(dataitem))); + break; + case POWER_CONNECTED_STATE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mPowerConnectState, + *(static_cast(dataitem))); + break; + case TIMEZONE_CHANGE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mTimeZoneChange, + *(static_cast(dataitem))); + break; + case TIME_CHANGE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mTimeChange, + *(static_cast(dataitem))); + break; + case WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID: + ret = setIteminReport(mCache.mWifiSupplicantStatus, + *(static_cast(dataitem))); + break; + case SHUTDOWN_STATE_DATA_ITEM_ID: + ret = setIteminReport(mCache.mShutdownState, + *(static_cast(dataitem))); + break; + case TAC_DATA_ITEM_ID: + ret = setIteminReport(mCache.mTac, + *(static_cast(dataitem))); + break; + case MCCMNC_DATA_ITEM_ID: + ret = setIteminReport(mCache.mMccMnc, + *(static_cast(dataitem))); + break; + case BTLE_SCAN_DATA_ITEM_ID: + ret = setIteminReport(mCache.mBtDeviceScanDetail, + *(static_cast(dataitem))); + break; + case BT_SCAN_DATA_ITEM_ID: + ret = setIteminReport(mCache.mBtLeDeviceScanDetail, + *(static_cast(dataitem))); + break; + default: break; } pthread_mutex_unlock(&mMutexSystemStatus); - return true; + return ret; } /****************************************************************************** @@ -1628,74 +1560,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 @@ -1715,6 +1618,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; } @@ -1733,61 +1660,45 @@ bool SystemStatus::setDefaultReport(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()); + + setDefaultIteminReport(mCache.mAirplaneMode, SystemStatusAirplaneMode()); + setDefaultIteminReport(mCache.mENH, SystemStatusENH()); + setDefaultIteminReport(mCache.mGPSState, SystemStatusGpsState()); + setDefaultIteminReport(mCache.mNLPStatus, SystemStatusNLPStatus()); + setDefaultIteminReport(mCache.mWifiHardwareState, SystemStatusWifiHardwareState()); + setDefaultIteminReport(mCache.mNetworkInfo, SystemStatusNetworkInfo()); + setDefaultIteminReport(mCache.mRilServiceInfo, SystemStatusServiceInfo()); + setDefaultIteminReport(mCache.mRilCellInfo, SystemStatusRilCellInfo()); + setDefaultIteminReport(mCache.mServiceStatus, SystemStatusServiceStatus()); + setDefaultIteminReport(mCache.mModel, SystemStatusModel()); + setDefaultIteminReport(mCache.mManufacturer, SystemStatusManufacturer()); + setDefaultIteminReport(mCache.mAssistedGps, SystemStatusAssistedGps()); + setDefaultIteminReport(mCache.mScreenState, SystemStatusScreenState()); + setDefaultIteminReport(mCache.mPowerConnectState, SystemStatusPowerConnectState()); + setDefaultIteminReport(mCache.mTimeZoneChange, SystemStatusTimeZoneChange()); + setDefaultIteminReport(mCache.mTimeChange, SystemStatusTimeChange()); + setDefaultIteminReport(mCache.mWifiSupplicantStatus, SystemStatusWifiSupplicantStatus()); + setDefaultIteminReport(mCache.mShutdownState, SystemStatusShutdownState()); + setDefaultIteminReport(mCache.mTac, SystemStatusTac()); + setDefaultIteminReport(mCache.mMccMnc, SystemStatusMccMnc()); + setDefaultIteminReport(mCache.mBtDeviceScanDetail, SystemStatusBtDeviceScanDetail()); + setDefaultIteminReport(mCache.mBtLeDeviceScanDetail, SystemStatusBtleDeviceScanDetail()); pthread_mutex_unlock(&mMutexSystemStatus); return true; @@ -1807,15 +1718,8 @@ bool SystemStatus::eventConnectionStatus(bool connected, int8_t type) // 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 dl(0); - dl.push_back(networkinfo); + dl.push_back(&s); mSysStatusObsvr.notify(dl); } return true; diff --git a/core/SystemStatus.h b/core/SystemStatus.h index 9ee85d3f..0c9b4b9d 100644 --- a/core/SystemStatus.h +++ b/core/SystemStatus.h @@ -36,6 +36,7 @@ #include #include #include +#include #include #include @@ -66,6 +67,7 @@ class SystemStatusItemBase public: timespec mUtcTime; // UTC timestamp when this info was last updated timespec mUtcReported; // UTC timestamp when this info was reported + static const uint32_t maxItem = 5; SystemStatusItemBase() { timeval tv; @@ -91,7 +93,7 @@ public: mValid(true), mLocation(location), mLocationEx(locationEx) { } - bool equals(SystemStatusLocation& peer); + bool equals(const SystemStatusLocation& peer); void dump(void); }; @@ -119,7 +121,7 @@ public: mLeapSeconds(0), mLeapSecUnc(0) {} inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea); - bool equals(SystemStatusTimeAndClock& peer); + bool equals(const SystemStatusTimeAndClock& peer); void dump(void); }; @@ -130,7 +132,7 @@ public: inline SystemStatusXoState() : mXoState(0) {} inline SystemStatusXoState(const SystemStatusPQWM1& nmea); - bool equals(SystemStatusXoState& peer); + bool equals(const SystemStatusXoState& peer); void dump(void); }; @@ -177,7 +179,7 @@ public: mGalBpAmpI(0), mGalBpAmpQ(0) {} inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea); - bool equals(SystemStatusRfAndParams& peer); + bool equals(const SystemStatusRfAndParams& peer); void dump(void); }; @@ -188,7 +190,7 @@ public: inline SystemStatusErrRecovery() : mRecErrorRecovery(0) {}; inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea); - bool equals(SystemStatusErrRecovery& peer); + bool equals(const SystemStatusErrRecovery& peer); void dump(void); }; @@ -212,7 +214,7 @@ public: mEpiAltUnc(0), mEpiSrc(0) {} inline SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea); - bool equals(SystemStatusInjectedPosition& peer); + bool equals(const SystemStatusInjectedPosition& peer); void dump(void); }; @@ -234,7 +236,7 @@ public: mBestHepe(0), mBestAltUnc(0) {} inline SystemStatusBestPosition(const SystemStatusPQWP2& nmea); - bool equals(SystemStatusBestPosition& peer); + bool equals(const SystemStatusBestPosition& peer); void dump(void); }; @@ -266,7 +268,7 @@ public: mGalXtraValid(0ULL), mQzssXtraValid(0) {} inline SystemStatusXtra(const SystemStatusPQWP3& nmea); - bool equals(SystemStatusXtra& peer); + bool equals(const SystemStatusXtra& peer); void dump(void); }; @@ -286,7 +288,7 @@ public: mGalEpheValid(0ULL), mQzssEpheValid(0) {} inline SystemStatusEphemeris(const SystemStatusPQWP4& nmea); - bool equals(SystemStatusEphemeris& peer); + bool equals(const SystemStatusEphemeris& peer); void dump(void); }; @@ -326,7 +328,7 @@ public: mGalBadMask(0ULL), mQzssBadMask(0) {} inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea); - bool equals(SystemStatusSvHealth& peer); + bool equals(const SystemStatusSvHealth& peer); void dump(void); }; @@ -338,7 +340,7 @@ public: inline SystemStatusPdr() : mFixInfoMask(0) {} inline SystemStatusPdr(const SystemStatusPQWP6& nmea); - bool equals(SystemStatusPdr& peer); + bool equals(const SystemStatusPdr& peer); void dump(void); }; @@ -362,7 +364,7 @@ public: } } inline SystemStatusNavData(const SystemStatusPQWP7& nmea); - bool equals(SystemStatusNavData& peer); + bool equals(const SystemStatusNavData& peer); void dump(void); }; @@ -376,168 +378,294 @@ public: mFixInfoMask(0), mHepeLimit(0) {} inline SystemStatusPositionFailure(const SystemStatusPQWS1& nmea); - bool equals(SystemStatusPositionFailure& peer); + bool equals(const SystemStatusPositionFailure& peer); void dump(void); }; /****************************************************************************** SystemStatus report data structure - from DataItem observer ******************************************************************************/ -class SystemStatusGpsState : public SystemStatusItemBase, public IDataItemCore +class SystemStatusAirplaneMode : public SystemStatusItemBase, + public AirplaneModeDataItemBase { public: - inline SystemStatusGpsState() : - mEnabled(false) {} - inline SystemStatusGpsState(bool enabled) : - mEnabled(enabled) {} + inline SystemStatusAirplaneMode(bool mode=false) : + AirplaneModeDataItemBase(mode) {} + inline bool equals(const SystemStatusAirplaneMode& peer) { + return (mMode == peer.mMode); + } +}; - bool mEnabled; - - inline bool equals(SystemStatusGpsState& peer) { +class SystemStatusENH : public SystemStatusItemBase, + public ENHDataItemBase +{ +public: + inline SystemStatusENH(bool enabled=false) : + ENHDataItemBase(enabled) {} + inline bool equals(const SystemStatusENH& peer) { return (mEnabled == peer.mEnabled); } - inline void dump(void) { +}; + +class SystemStatusGpsState : public SystemStatusItemBase, + public GPSStateDataItemBase +{ +public: + inline SystemStatusGpsState(bool enabled=false) : + GPSStateDataItemBase(enabled) {} + inline bool equals(const SystemStatusGpsState& peer) { + return (mEnabled == peer.mEnabled); + } + inline void dump(void) override { LOC_LOGD("GpsState: state=%u", mEnabled); } - inline DataItemId getId() { - return GPSSTATE_DATA_ITEM_ID; - } - inline void stringify(string& valueStr) { - valueStr.clear(); - valueStr += "GpsState: enabled="; - valueStr += to_string(mEnabled); - } - inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { - SystemStatusGpsState* gpsstate = static_cast(src); - mEnabled = gpsstate->mEnabled; - if (dataItemCopied) { - *dataItemCopied = true; - } - return 1; +}; + +class SystemStatusNLPStatus : public SystemStatusItemBase, + public NLPStatusDataItemBase +{ +public: + inline SystemStatusNLPStatus(bool enabled=false) : + NLPStatusDataItemBase(enabled) {} + inline bool equals(const SystemStatusNLPStatus& peer) { + return (mEnabled == peer.mEnabled); } }; -class SystemStatusNetworkInfo : public SystemStatusItemBase, public IDataItemCore +class SystemStatusWifiHardwareState : public SystemStatusItemBase, + public WifiHardwareStateDataItemBase +{ +public: + inline SystemStatusWifiHardwareState(bool enabled=false) : + WifiHardwareStateDataItemBase(enabled) {} + inline bool equals(const SystemStatusWifiHardwareState& peer) { + return (mEnabled == peer.mEnabled); + } +}; + +class SystemStatusNetworkInfo : public SystemStatusItemBase, + public NetworkInfoDataItemBase { public: - inline SystemStatusNetworkInfo() : - mType(0), - mTypeName(""), - mSubTypeName(""), - mAvailable(false), - mConnected(false), - mRoaming(false) {} inline SystemStatusNetworkInfo( - int32_t type, - std::string typeName, - std::string subTypeName, - bool available, - bool connected, - bool roaming) : - mType(type), - mTypeName(typeName), - mSubTypeName(subTypeName), - mAvailable(available), - mConnected(connected), - mRoaming(roaming) {} - - int32_t mType; - std::string mTypeName; - std::string mSubTypeName; - bool mAvailable; - bool mConnected; - bool mRoaming; - - inline bool equals(SystemStatusNetworkInfo& peer) { - if ((mType != peer.mType) || - (mTypeName != peer.mTypeName) || - (mSubTypeName != peer.mSubTypeName) || - (mAvailable != peer.mAvailable) || - (mConnected != peer.mConnected) || - (mRoaming != peer.mRoaming)) { + int32_t type=0, + std::string typeName="", + string subTypeName="", + bool available=false, + bool connected=false, + bool roaming=false) : + NetworkInfoDataItemBase( + type, + typeName, + subTypeName, + available, + connected, + roaming) {} + inline bool equals(const SystemStatusNetworkInfo& peer) { + if ((mType == peer.mType) && + (mTypeName == peer.mTypeName) && + (mSubTypeName == peer.mSubTypeName) && + (mAvailable == peer.mAvailable) && + (mConnected == peer.mConnected) && + (mRoaming == peer.mRoaming)) { + return true; + } return false; } - return true; - } - inline void dump(void) { + inline void dump(void) override { LOC_LOGD("NetworkInfo: type=%u connected=%u", mType, mConnected); } - inline DataItemId getId() { - return NETWORKINFO_DATA_ITEM_ID; - } - inline void stringify(string& /*valueStr*/) { } - inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { - SystemStatusNetworkInfo* networkinfo = static_cast(src); - mType = networkinfo->mType; - mTypeName = networkinfo->mTypeName; - mSubTypeName = networkinfo->mSubTypeName; - mAvailable = networkinfo->mAvailable; - mConnected = networkinfo->mConnected; - mRoaming = networkinfo->mRoaming; - if (dataItemCopied) { - *dataItemCopied = true; - } - return 1; - } }; -class SystemStatusTac : public SystemStatusItemBase, public IDataItemCore +class SystemStatusServiceInfo : public SystemStatusItemBase, + public RilServiceInfoDataItemBase { public: - inline SystemStatusTac() : - mValue("") {} - inline SystemStatusTac(std::string value) : - mValue(value) {} + inline SystemStatusServiceInfo() : + RilServiceInfoDataItemBase() {} + inline bool equals(const SystemStatusServiceInfo& /*peer*/) { + return true; + } +}; - std::string mValue; +class SystemStatusRilCellInfo : public SystemStatusItemBase, + public RilCellInfoDataItemBase +{ +public: + inline SystemStatusRilCellInfo() : + RilCellInfoDataItemBase() {} + inline bool equals(const SystemStatusRilCellInfo& /*peer*/) { + return true; + } +}; - inline bool equals(SystemStatusTac& peer) { +class SystemStatusServiceStatus : public SystemStatusItemBase, + public ServiceStatusDataItemBase +{ +public: + inline SystemStatusServiceStatus(int32_t mServiceState=0) : + ServiceStatusDataItemBase(mServiceState) {} + inline bool equals(const SystemStatusServiceStatus& peer) { + return (mServiceState == peer.mServiceState); + } +}; + +class SystemStatusModel : public SystemStatusItemBase, + public ModelDataItemBase +{ +public: + inline SystemStatusModel(string name="") : + ModelDataItemBase(name) {} + inline bool equals(const SystemStatusModel& peer) { + return (mModel == peer.mModel); + } +}; + +class SystemStatusManufacturer : public SystemStatusItemBase, + public ManufacturerDataItemBase +{ +public: + inline SystemStatusManufacturer(string name="") : + ManufacturerDataItemBase(name) {} + inline bool equals(const SystemStatusManufacturer& peer) { + return (mManufacturer == peer.mManufacturer); + } +}; + +class SystemStatusAssistedGps : public SystemStatusItemBase, + public AssistedGpsDataItemBase +{ +public: + inline SystemStatusAssistedGps(bool enabled=false) : + AssistedGpsDataItemBase(enabled) {} + inline bool equals(const SystemStatusAssistedGps& peer) { + return (mEnabled == peer.mEnabled); + } +}; + +class SystemStatusScreenState : public SystemStatusItemBase, + public ScreenStateDataItemBase +{ +public: + inline SystemStatusScreenState(bool state=false) : + ScreenStateDataItemBase(state) {} + inline bool equals(const SystemStatusScreenState& peer) { + return (mState == peer.mState); + } +}; + +class SystemStatusPowerConnectState : public SystemStatusItemBase, + public PowerConnectStateDataItemBase +{ +public: + inline SystemStatusPowerConnectState(bool state=false) : + PowerConnectStateDataItemBase(state) {} + inline bool equals(const SystemStatusPowerConnectState& peer) { + return (mState == peer.mState); + } +}; + +class SystemStatusTimeZoneChange : public SystemStatusItemBase, + public TimeZoneChangeDataItemBase +{ +public: + inline SystemStatusTimeZoneChange( + int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) : + TimeZoneChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {} + inline bool equals(const SystemStatusTimeZoneChange& peer) { + return ((mCurrTimeMillis == peer.mCurrTimeMillis) && + (mRawOffsetTZ == peer.mRawOffsetTZ) && + (mDstOffsetTZ == peer.mDstOffsetTZ)); + } +}; + +class SystemStatusTimeChange : public SystemStatusItemBase, + public TimeChangeDataItemBase +{ +public: + inline SystemStatusTimeChange( + int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) : + TimeChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {} + inline bool equals(const SystemStatusTimeChange& peer) { + return ((mCurrTimeMillis == peer.mCurrTimeMillis) && + (mRawOffsetTZ == peer.mRawOffsetTZ) && + (mDstOffsetTZ == peer.mDstOffsetTZ)); + } +}; + +class SystemStatusWifiSupplicantStatus : public SystemStatusItemBase, + public WifiSupplicantStatusDataItemBase +{ +public: + inline SystemStatusWifiSupplicantStatus() : + WifiSupplicantStatusDataItemBase() {} + inline bool equals(const SystemStatusWifiSupplicantStatus& peer) { + return ((mState == peer.mState) && + (mApMacAddressValid == peer.mApMacAddressValid) && + (mWifiApSsidValid == peer.mWifiApSsidValid) && + (mWifiApSsid == peer.mWifiApSsid)); + } +}; + +class SystemStatusShutdownState : public SystemStatusItemBase, + public ShutdownStateDataItemBase +{ +public: + inline SystemStatusShutdownState(bool state=false) : + ShutdownStateDataItemBase(state) {} + inline bool equals(const SystemStatusShutdownState& peer) { + return (mState == peer.mState); + } +}; + +class SystemStatusTac : public SystemStatusItemBase, + public TacDataItemBase +{ +public: + inline SystemStatusTac(std::string value="") : + TacDataItemBase(value) {} + + inline bool equals(const SystemStatusTac& peer) { return (mValue == peer.mValue); } inline void dump(void) { LOC_LOGD("Tac: value=%s", mValue.c_str()); } - inline DataItemId getId() { - return TAC_DATA_ITEM_ID; - } - inline void stringify(string& /*valueStr*/) { } - inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { - SystemStatusTac* tac = static_cast(src); - mValue = tac->mValue; - if (dataItemCopied) { - *dataItemCopied = true; - } - return 1; - } }; -class SystemStatusMccMnc : public SystemStatusItemBase, public IDataItemCore +class SystemStatusMccMnc : public SystemStatusItemBase, + public MccmncDataItemBase { public: - inline SystemStatusMccMnc() : - mValue("") {} - inline SystemStatusMccMnc(std::string value) : - mValue(value) {} - - std::string mValue; - - inline bool equals(SystemStatusMccMnc& peer) { + inline SystemStatusMccMnc(std::string value="") : + MccmncDataItemBase(value) {} + inline bool equals(const SystemStatusMccMnc& peer) { return (mValue == peer.mValue); } inline void dump(void) { LOC_LOGD("TacMccMnc value=%s", mValue.c_str()); } - inline DataItemId getId() { - return MCCMNC_DATA_ITEM_ID; +}; + +class SystemStatusBtDeviceScanDetail : public SystemStatusItemBase, + public BtDeviceScanDetailsDataItemBase +{ +public: + inline SystemStatusBtDeviceScanDetail() : + BtDeviceScanDetailsDataItemBase() {} + inline bool equals(const SystemStatusBtDeviceScanDetail& /*peer*/) { + return true; } - inline void stringify(string& /*valueStr*/) { } - inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { - SystemStatusMccMnc* mccmnc = static_cast(src); - mValue = mccmnc->mValue; - if (dataItemCopied) { - *dataItemCopied = true; - } - return 1; +}; + +class SystemStatusBtleDeviceScanDetail : public SystemStatusItemBase, + public BtLeDeviceScanDetailsDataItemBase +{ +public: + inline SystemStatusBtleDeviceScanDetail() : + BtLeDeviceScanDetailsDataItemBase() {} + inline bool equals(const SystemStatusBtleDeviceScanDetail& /*peer*/) { + return true; } }; @@ -569,10 +697,28 @@ public: std::vector mPositionFailure; // from dataitems observer - std::vector mGpsState; + std::vector mAirplaneMode; + std::vector mENH; + std::vector mGPSState; + std::vector mNLPStatus; + std::vector mWifiHardwareState; std::vector mNetworkInfo; + std::vector mRilServiceInfo; + std::vector mRilCellInfo; + std::vector mServiceStatus; + std::vector mModel; + std::vector mManufacturer; + std::vector mAssistedGps; + std::vector mScreenState; + std::vector mPowerConnectState; + std::vector mTimeZoneChange; + std::vector mTimeChange; + std::vector mWifiSupplicantStatus; + std::vector mShutdownState; std::vector mTac; std::vector mMccMnc; + std::vector mBtDeviceScanDetail; + std::vector mBtLeDeviceScanDetail; }; /****************************************************************************** @@ -590,50 +736,21 @@ private: // Data members static pthread_mutex_t mMutexSystemStatus; - - static const uint32_t maxLocation = 5; - - static const uint32_t maxTimeAndClock = 5; - static const uint32_t maxXoState = 5; - static const uint32_t maxRfAndParams = 5; - static const uint32_t maxErrRecovery = 5; - - static const uint32_t maxInjectedPosition = 5; - static const uint32_t maxBestPosition = 5; - static const uint32_t maxXtra = 5; - static const uint32_t maxEphemeris = 5; - static const uint32_t maxSvHealth = 5; - static const uint32_t maxPdr = 5; - static const uint32_t maxNavData = 5; - - static const uint32_t maxPositionFailure = 5; - - static const uint32_t maxGpsState = 5; - static const uint32_t maxNetworkInfo = 5; - static const uint32_t maxTac = 5; - static const uint32_t maxMccMnc = 5; - SystemStatusReports mCache; bool mConnected; - bool setLocation(const UlpLocation& location); + // set dataitem derived item in report cache + bool setNetworkInfo(const SystemStatusNetworkInfo& s); - bool setTimeAndCLock(const SystemStatusPQWM1& nmea); - bool setXoState(const SystemStatusPQWM1& nmea); - bool setRfAndParams(const SystemStatusPQWM1& nmea); - bool setErrRecovery(const SystemStatusPQWM1& nmea); + template + bool setIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s); - bool setInjectedPosition(const SystemStatusPQWP1& nmea); - bool setBestPosition(const SystemStatusPQWP2& nmea); - bool setXtra(const SystemStatusPQWP3& nmea); - bool setEphemeris(const SystemStatusPQWP4& nmea); - bool setSvHealth(const SystemStatusPQWP5& nmea); - bool setPdr(const SystemStatusPQWP6& nmea); - bool setNavData(const SystemStatusPQWP7& nmea); + // set default dataitem derived item in report cache + template + void setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s); - bool setPositionFailure(const SystemStatusPQWS1& nmea); - - bool setNetworkInfo(IDataItemCore* dataitem); + template + void getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const; public: // Static methods diff --git a/core/SystemStatusOsObserver.cpp b/core/SystemStatusOsObserver.cpp index dc08a76e..2fdd19f1 100644 --- a/core/SystemStatusOsObserver.cpp +++ b/core/SystemStatusOsObserver.cpp @@ -39,7 +39,9 @@ namespace loc_core { -SystemStatusOsObserver::SystemStatusOsObserver(const MsgTask* msgTask) : +SystemStatusOsObserver::SystemStatusOsObserver( + SystemStatus* systemstatus, const MsgTask* msgTask) : + mSystemStatus(systemstatus), mAddress("SystemStatusOsObserver"), #ifdef USE_GLIB mBackHaulConnectReqCount(0), @@ -369,11 +371,11 @@ void SystemStatusOsObserver::notify(const list& dlist) // Copy contents into the newly created data item di->copy(each); - dataItemList.push_back(di); + // Request systemstatus to record this dataitem in its cache - SystemStatus* systemstatus = SystemStatus::getInstance(mContext.mMsgTask); - if(nullptr != systemstatus) { - systemstatus->eventDataItemNotify(di); + if (mSystemStatus->eventDataItemNotify(di)) { + // add this dataitem if updated from last one + dataItemList.push_back(di); } } diff --git a/core/SystemStatusOsObserver.h b/core/SystemStatusOsObserver.h index 6892f226..33e668d2 100644 --- a/core/SystemStatusOsObserver.h +++ b/core/SystemStatusOsObserver.h @@ -70,12 +70,13 @@ typedef map> ObserverReqCache; // subscribe with OSObserver using IDataItemSubscription interface. // Such clients would need to implement IDataItemObserver interface // to receive data when it becomes available. +class SystemStatus; class SystemStatusOsObserver : public IOsObserver { public: // ctor - SystemStatusOsObserver(const MsgTask* msgTask); - + SystemStatusOsObserver( + SystemStatus* systemstatus, const MsgTask* msgTask); // dtor ~SystemStatusOsObserver(); @@ -115,6 +116,7 @@ public: #endif private: + SystemStatus* mSystemStatus; SystemContext mContext; const string mAddress; IClientIndex* mClientIndex; diff --git a/core/data-items/DataItemConcreteTypesBase.h b/core/data-items/DataItemConcreteTypesBase.h index 74722d06..df3bf9a9 100644 --- a/core/data-items/DataItemConcreteTypesBase.h +++ b/core/data-items/DataItemConcreteTypesBase.h @@ -235,6 +235,21 @@ public: inline virtual DataItemId getId() { return mId; } virtual void stringify(string& /*valueStr*/) {} virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} + enum NetworkType { + TYPE_UNKNOWN, + TYPE_MOBILE, + TYPE_WIFI, + TYPE_ETHERNET, + TYPE_BLUETOOTH, + TYPE_MMS, + TYPE_SUPL, + TYPE_DUN, + TYPE_HIPRI, + TYPE_WIMAX + }; + inline virtual NetworkType getType(void) const { + return (NetworkType)mType; + } // Data members int32_t mType; string mTypeName;