| /* Copyright (c) 2017, The Linux Foundation. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation, nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| #ifndef __SYSTEM_STATUS__ |
| #define __SYSTEM_STATUS__ |
| |
| #include <stdint.h> |
| #include <string> |
| #include <vector> |
| #include <platform_lib_log_util.h> |
| #include <MsgTask.h> |
| #include <IDataItemCore.h> |
| #include <IOsObserver.h> |
| #include <SystemStatusOsObserver.h> |
| |
| #include <gps_extended_c.h> |
| |
| #define GPS_MIN (1) //1-32 |
| #define SBAS_MIN (33) |
| #define GLO_MIN (65) //65-88 |
| #define QZSS_MIN (193) //193-197 |
| #define BDS_MIN (201) //201-237 |
| #define GAL_MIN (301) //301-336 |
| |
| #define GPS_NUM (32) |
| #define SBAS_NUM (32) |
| #define GLO_NUM (24) |
| #define QZSS_NUM (5) |
| #define BDS_NUM (37) |
| #define GAL_NUM (36) |
| #define SV_ALL_NUM (GPS_NUM+GLO_NUM+QZSS_NUM+BDS_NUM+GAL_NUM) //=134 |
| |
| namespace loc_core |
| { |
| |
| /****************************************************************************** |
| SystemStatus report data structure |
| ******************************************************************************/ |
| class SystemStatusItemBase |
| { |
| public: |
| timespec mUtcTime; // UTC timestamp when this info was last updated |
| 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 void dump(void) { }; |
| }; |
| |
| class SystemStatusLocation : public SystemStatusItemBase |
| { |
| public: |
| bool mValid; |
| UlpLocation mLocation; |
| GpsLocationExtended mLocationEx; |
| inline SystemStatusLocation() : |
| mValid(false) {} |
| inline SystemStatusLocation(const UlpLocation& location, |
| const GpsLocationExtended& locationEx) : |
| mValid(true), |
| mLocation(location), |
| mLocationEx(locationEx) { } |
| bool equals(SystemStatusLocation& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWM1; |
| class SystemStatusTimeAndClock : public SystemStatusItemBase |
| { |
| public: |
| uint16_t mGpsWeek; |
| uint32_t mGpsTowMs; |
| uint8_t mTimeValid; |
| uint8_t mTimeSource; |
| int32_t mTimeUnc; |
| int32_t mClockFreqBias; |
| int32_t mClockFreqBiasUnc; |
| int32_t mLeapSeconds; |
| int32_t mLeapSecUnc; |
| inline SystemStatusTimeAndClock() : |
| mGpsWeek(0), |
| mGpsTowMs(0), |
| mTimeValid(0), |
| mTimeSource(0), |
| mTimeUnc(0), |
| mClockFreqBias(0), |
| mClockFreqBiasUnc(0), |
| mLeapSeconds(0), |
| mLeapSecUnc(0) {} |
| inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea); |
| bool equals(SystemStatusTimeAndClock& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusXoState : public SystemStatusItemBase |
| { |
| public: |
| uint8_t mXoState; |
| inline SystemStatusXoState() : |
| mXoState(0) {} |
| inline SystemStatusXoState(const SystemStatusPQWM1& nmea); |
| bool equals(SystemStatusXoState& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusRfAndParams : public SystemStatusItemBase |
| { |
| public: |
| int32_t mPgaGain; |
| uint32_t mGpsBpAmpI; |
| uint32_t mGpsBpAmpQ; |
| uint32_t mAdcI; |
| uint32_t mAdcQ; |
| uint32_t mJammerGps; |
| uint32_t mJammerGlo; |
| uint32_t mJammerBds; |
| uint32_t mJammerGal; |
| double mAgcGps; |
| double mAgcGlo; |
| double mAgcBds; |
| double mAgcGal; |
| inline SystemStatusRfAndParams() : |
| mPgaGain(0), |
| mGpsBpAmpI(0), |
| mGpsBpAmpQ(0), |
| mAdcI(0), |
| mAdcQ(0), |
| mJammerGps(0), |
| mJammerGlo(0), |
| mJammerBds(0), |
| mJammerGal(0), |
| mAgcGps(0), |
| mAgcGlo(0), |
| mAgcBds(0), |
| mAgcGal(0) {} |
| inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea); |
| bool equals(SystemStatusRfAndParams& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusErrRecovery : public SystemStatusItemBase |
| { |
| public: |
| uint32_t mRecErrorRecovery; |
| inline SystemStatusErrRecovery() : |
| mRecErrorRecovery(0) {}; |
| inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea); |
| bool equals(SystemStatusErrRecovery& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP1; |
| class SystemStatusInjectedPosition : public SystemStatusItemBase |
| { |
| public: |
| uint8_t mEpiValidity; |
| float mEpiLat; |
| float mEpiLon; |
| float mEpiAlt; |
| float mEpiHepe; |
| float mEpiAltUnc; |
| uint8_t mEpiSrc; |
| inline SystemStatusInjectedPosition() : |
| mEpiValidity(0), |
| mEpiLat(0), |
| mEpiLon(0), |
| mEpiAlt(0), |
| mEpiHepe(0), |
| mEpiAltUnc(0), |
| mEpiSrc(0) {} |
| inline SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea); |
| bool equals(SystemStatusInjectedPosition& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP2; |
| class SystemStatusBestPosition : public SystemStatusItemBase |
| { |
| public: |
| bool mValid; |
| float mBestLat; |
| float mBestLon; |
| float mBestAlt; |
| float mBestHepe; |
| float mBestAltUnc; |
| inline SystemStatusBestPosition() : |
| mValid(false), |
| mBestLat(0), |
| mBestLon(0), |
| mBestAlt(0), |
| mBestHepe(0), |
| mBestAltUnc(0) {} |
| inline SystemStatusBestPosition(const SystemStatusPQWP2& nmea); |
| bool equals(SystemStatusBestPosition& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP3; |
| class SystemStatusXtra : public SystemStatusItemBase |
| { |
| public: |
| uint8_t mXtraValidMask; |
| uint32_t mGpsXtraAge; |
| uint32_t mGloXtraAge; |
| uint32_t mBdsXtraAge; |
| uint32_t mGalXtraAge; |
| uint32_t mQzssXtraAge; |
| uint32_t mGpsXtraValid; |
| uint32_t mGloXtraValid; |
| uint64_t mBdsXtraValid; |
| uint64_t mGalXtraValid; |
| uint8_t mQzssXtraValid; |
| inline SystemStatusXtra() : |
| mXtraValidMask(0), |
| mGpsXtraAge(0), |
| mGloXtraAge(0), |
| mBdsXtraAge(0), |
| mGalXtraAge(0), |
| mQzssXtraAge(0), |
| mGpsXtraValid(0), |
| mGloXtraValid(0), |
| mBdsXtraValid(0ULL), |
| mGalXtraValid(0ULL), |
| mQzssXtraValid(0) {} |
| inline SystemStatusXtra(const SystemStatusPQWP3& nmea); |
| bool equals(SystemStatusXtra& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP4; |
| class SystemStatusEphemeris : public SystemStatusItemBase |
| { |
| public: |
| uint32_t mGpsEpheValid; |
| uint32_t mGloEpheValid; |
| uint64_t mBdsEpheValid; |
| uint64_t mGalEpheValid; |
| uint8_t mQzssEpheValid; |
| inline SystemStatusEphemeris() : |
| mGpsEpheValid(0), |
| mGloEpheValid(0), |
| mBdsEpheValid(0ULL), |
| mGalEpheValid(0ULL), |
| mQzssEpheValid(0) {} |
| inline SystemStatusEphemeris(const SystemStatusPQWP4& nmea); |
| bool equals(SystemStatusEphemeris& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP5; |
| class SystemStatusSvHealth : public SystemStatusItemBase |
| { |
| public: |
| uint32_t mGpsUnknownMask; |
| uint32_t mGloUnknownMask; |
| uint64_t mBdsUnknownMask; |
| uint64_t mGalUnknownMask; |
| uint8_t mQzssUnknownMask; |
| uint32_t mGpsGoodMask; |
| uint32_t mGloGoodMask; |
| uint64_t mBdsGoodMask; |
| uint64_t mGalGoodMask; |
| uint8_t mQzssGoodMask; |
| uint32_t mGpsBadMask; |
| uint32_t mGloBadMask; |
| uint64_t mBdsBadMask; |
| uint64_t mGalBadMask; |
| uint8_t mQzssBadMask; |
| inline SystemStatusSvHealth() : |
| mGpsUnknownMask(0), |
| mGloUnknownMask(0), |
| mBdsUnknownMask(0ULL), |
| mGalUnknownMask(0ULL), |
| mQzssUnknownMask(0), |
| mGpsGoodMask(0), |
| mGloGoodMask(0), |
| mBdsGoodMask(0ULL), |
| mGalGoodMask(0ULL), |
| mQzssGoodMask(0), |
| mGpsBadMask(0), |
| mGloBadMask(0), |
| mBdsBadMask(0ULL), |
| mGalBadMask(0ULL), |
| mQzssBadMask(0) {} |
| inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea); |
| bool equals(SystemStatusSvHealth& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP6; |
| class SystemStatusPdr : public SystemStatusItemBase |
| { |
| public: |
| uint32_t mFixInfoMask; |
| inline SystemStatusPdr() : |
| mFixInfoMask(0) {} |
| inline SystemStatusPdr(const SystemStatusPQWP6& nmea); |
| bool equals(SystemStatusPdr& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWP7; |
| struct SystemStatusNav |
| { |
| GnssEphemerisType mType; |
| GnssEphemerisSource mSource; |
| int32_t mAgeSec; |
| }; |
| |
| class SystemStatusNavData : public SystemStatusItemBase |
| { |
| public: |
| SystemStatusNav mNav[SV_ALL_NUM]; |
| inline SystemStatusNavData() { |
| for (uint32_t i=0; i<SV_ALL_NUM; i++) { |
| mNav[i].mType = GNSS_EPH_TYPE_UNKNOWN; |
| mNav[i].mSource = GNSS_EPH_SOURCE_UNKNOWN; |
| mNav[i].mAgeSec = 0; |
| } |
| } |
| inline SystemStatusNavData(const SystemStatusPQWP7& nmea); |
| bool equals(SystemStatusNavData& peer); |
| void dump(void); |
| }; |
| |
| class SystemStatusPQWS1; |
| class SystemStatusPositionFailure : public SystemStatusItemBase |
| { |
| public: |
| uint32_t mFixInfoMask; |
| uint32_t mHepeLimit; |
| inline SystemStatusPositionFailure() : |
| mFixInfoMask(0), |
| mHepeLimit(0) {} |
| inline SystemStatusPositionFailure(const SystemStatusPQWS1& nmea); |
| bool equals(SystemStatusPositionFailure& peer); |
| void dump(void); |
| }; |
| |
| /****************************************************************************** |
| SystemStatus report data structure - from DataItem observer |
| ******************************************************************************/ |
| class SystemStatusGpsState : public SystemStatusItemBase, public IDataItemCore |
| { |
| public: |
| inline SystemStatusGpsState() : |
| mEnabled(false) {} |
| inline SystemStatusGpsState(bool enabled) : |
| mEnabled(enabled) {} |
| |
| bool mEnabled; |
| |
| inline bool equals(SystemStatusGpsState& peer) { |
| return (mEnabled == peer.mEnabled); |
| } |
| inline void dump(void) { |
| 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<SystemStatusGpsState*>(src); |
| mEnabled = gpsstate->mEnabled; |
| if (dataItemCopied) { |
| *dataItemCopied = true; |
| } |
| return 1; |
| } |
| }; |
| |
| class SystemStatusNetworkInfo : public SystemStatusItemBase, public IDataItemCore |
| { |
| public: |
| inline SystemStatusNetworkInfo() : |
| mType(0), |
| mTypeName(""), |
| mSubTypeName(""), |
| mAvailable(false), |
| mConnected(false), |
| mRoaming(false) {} |
| inline SystemStatusNetworkInfo( |
| uint32_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) {} |
| |
| uint32_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)) { |
| return false; |
| } |
| return true; |
| } |
| inline void dump(void) { |
| 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<SystemStatusNetworkInfo*>(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 |
| { |
| public: |
| inline SystemStatusTac() : |
| mValue("") {} |
| inline SystemStatusTac(std::string value) : |
| mValue(value) {} |
| |
| std::string mValue; |
| |
| inline bool equals(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<SystemStatusTac*>(src); |
| mValue = tac->mValue; |
| if (dataItemCopied) { |
| *dataItemCopied = true; |
| } |
| return 1; |
| } |
| }; |
| |
| class SystemStatusMccMnc : public SystemStatusItemBase, public IDataItemCore |
| { |
| public: |
| inline SystemStatusMccMnc() : |
| mValue("") {} |
| inline SystemStatusMccMnc(std::string value) : |
| mValue(value) {} |
| |
| std::string mValue; |
| |
| inline bool equals(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; |
| } |
| inline void stringify(string& /*valueStr*/) { } |
| inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { |
| SystemStatusMccMnc* mccmnc = static_cast<SystemStatusMccMnc*>(src); |
| mValue = mccmnc->mValue; |
| if (dataItemCopied) { |
| *dataItemCopied = true; |
| } |
| return 1; |
| } |
| }; |
| |
| /****************************************************************************** |
| SystemStatusReports |
| ******************************************************************************/ |
| class SystemStatusReports |
| { |
| public: |
| // from QMI_LOC indication |
| std::vector<SystemStatusLocation> mLocation; |
| |
| // from ME debug NMEA |
| std::vector<SystemStatusTimeAndClock> mTimeAndClock; |
| std::vector<SystemStatusXoState> mXoState; |
| std::vector<SystemStatusRfAndParams> mRfAndParams; |
| std::vector<SystemStatusErrRecovery> mErrRecovery; |
| |
| // from PE debug NMEA |
| std::vector<SystemStatusInjectedPosition> mInjectedPosition; |
| std::vector<SystemStatusBestPosition> mBestPosition; |
| std::vector<SystemStatusXtra> mXtra; |
| std::vector<SystemStatusEphemeris> mEphemeris; |
| std::vector<SystemStatusSvHealth> mSvHealth; |
| std::vector<SystemStatusPdr> mPdr; |
| std::vector<SystemStatusNavData> mNavData; |
| |
| // from SM debug NMEA |
| std::vector<SystemStatusPositionFailure> mPositionFailure; |
| |
| // from dataitems observer |
| std::vector<SystemStatusGpsState> mGpsState; |
| std::vector<SystemStatusNetworkInfo> mNetworkInfo; |
| std::vector<SystemStatusTac> mTac; |
| std::vector<SystemStatusMccMnc> mMccMnc; |
| }; |
| |
| /****************************************************************************** |
| SystemStatus |
| ******************************************************************************/ |
| class SystemStatus |
| { |
| private: |
| static SystemStatus *mInstance; |
| SystemStatusOsObserver mSysStatusObsvr; |
| // ctor |
| SystemStatus(const MsgTask* msgTask); |
| // dtor |
| inline ~SystemStatus() {} |
| |
| // 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); |
| |
| bool setTimeAndCLock(const SystemStatusPQWM1& nmea); |
| bool setXoState(const SystemStatusPQWM1& nmea); |
| bool setRfAndParams(const SystemStatusPQWM1& nmea); |
| bool setErrRecovery(const SystemStatusPQWM1& nmea); |
| |
| 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); |
| |
| bool setPositionFailure(const SystemStatusPQWS1& nmea); |
| |
| bool setNetworkInfo(IDataItemCore* dataitem); |
| |
| public: |
| // Static methods |
| static SystemStatus* getInstance(const MsgTask* msgTask); |
| static void destroyInstance(); |
| IOsObserver* getOsObserver(); |
| |
| // Helpers |
| bool eventPosition(const UlpLocation& location,const GpsLocationExtended& locationEx); |
| bool eventDataItemNotify(IDataItemCore* dataitem); |
| bool setNmeaString(const char *data, uint32_t len); |
| bool getReport(SystemStatusReports& reports, bool isLatestonly = false) const; |
| bool setDefaultReport(void); |
| bool eventConnectionStatus(bool connected, uint8_t type); |
| }; |
| |
| } // namespace loc_core |
| |
| #endif //__SYSTEM_STATUS__ |
| |